Ignore:
Timestamp:
Mar 9, 2015 11:31:19 AM (10 years ago)
Author:
krzywon
Branches:
master, 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, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
d26dea0
Parents:
418e59f (diff), b1e609c (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 remote-tracking branch 'origin/master'

File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/sas/perspectives/fitting/pagestate.py

    rd838715 rb1e609c  
    22    Class that holds a fit page state 
    33""" 
     4#TODO: Refactor code so we don't need to use getattr/setattr 
    45################################################################################ 
    56#This software was developed by the University of Tennessee as part of the 
    … …  
    3536CANSAS_NS = "cansas1d/1.0" 
    3637 
    37 list_of_data_attributes = [["is_data", "is_data", "bool"], 
    38                       ["group_id", "data_group_id", "string"], 
    39                       ["data_name", "data_name", "string"], 
    40                       ["data_id", "data_id", "string"], 
    41                       ["name", "name", "string"], 
    42                       ["data_name", "data_name", "string"]] 
    43 list_of_state_attributes = [["engine_type", "engine_type", "string"], 
    44                        ["qmin", "qmin", "float"], 
    45                       ["qmax", "qmax", "float"], 
    46                       ["npts", "npts", "float"], 
    47                       #["shape_rbutton", "shape_rbutton", "bool"], 
    48                       #["shape_indep_rbutton", "shape_indep_rbutton", "bool"], 
    49                       #["plugin_rbutton", "plugin_rbutton", "bool"], 
    50                       #["struct_rbutton", "struct_rbutton", "bool"], 
    51                       ["categorycombobox", "categorycombobox", "string"], 
    52                       ["formfactorcombobox", "formfactorcombobox", "string"], 
    53                       ["structurecombobox", "structurecombobox", "string"], 
    54                       ["multi_factor","multi_factor","float"], 
    55                       ["magnetic_on","magnetic_on", "bool"], 
    56                       ["enable_smearer","enable_smearer","bool"], 
    57                       ["disable_smearer","disable_smearer","bool"], 
    58                       ["pinhole_smearer","pinhole_smearer","bool"], 
    59                       ["slit_smearer","slit_smearer","bool"], 
    60                       ["enable_disp","enable_disp","bool"], 
    61                       ["disable_disp","disable_disp","bool"], 
    62                       ["dI_noweight","dI_noweight","bool"], 
    63                       ["dI_didata","dI_didata","bool"], 
    64                       ["dI_sqrdata","dI_sqrdata","bool"], 
    65                       ["dI_idata","dI_idata","bool"], 
    66                       ["enable2D","enable2D","bool"], 
    67                       ["cb1","cb1","bool"], 
    68                       ["tcChi","tcChi","float"], 
    69                       ["smearer", "smearer", "float"], 
    70                       ["smear_type","smear_type", "string"], 
    71                       ["dq_l", "dq_l", "string"], 
    72                       ["dq_r","dq_r", "string"], 
    73                       ["dx_max", "dx_max", "float"], 
    74                       ["dx_min","dx_min", "float"], 
    75                       ["dxl", "dxl", "float"], 
    76                       ["dxw","dxw", "float"]] 
    77  
    78 list_of_model_attributes = [["values", "values"], 
     38LIST_OF_DATA_ATTRIBUTES = [["is_data", "is_data", "bool"], 
     39                           ["group_id", "data_group_id", "string"], 
     40                           ["data_name", "data_name", "string"], 
     41                           ["data_id", "data_id", "string"], 
     42                           ["name", "name", "string"], 
     43                           ["data_name", "data_name", "string"]] 
     44LIST_OF_STATE_ATTRIBUTES = [["engine_type", "engine_type", "string"], 
     45                            ["qmin", "qmin", "float"], 
     46                            ["qmax", "qmax", "float"], 
     47                            ["npts", "npts", "float"], 
     48                            ["categorycombobox", "categorycombobox", "string"], 
     49                            ["formfactorcombobox", "formfactorcombobox", "string"], 
     50                            ["structurecombobox", "structurecombobox", "string"], 
     51                            ["multi_factor", "multi_factor", "float"], 
     52                            ["magnetic_on", "magnetic_on", "bool"], 
     53                            ["enable_smearer", "enable_smearer", "bool"], 
     54                            ["disable_smearer", "disable_smearer", "bool"], 
     55                            ["pinhole_smearer", "pinhole_smearer", "bool"], 
     56                            ["slit_smearer", "slit_smearer", "bool"], 
     57                            ["enable_disp", "enable_disp", "bool"], 
     58                            ["disable_disp", "disable_disp", "bool"], 
     59                            ["dI_noweight", "dI_noweight", "bool"], 
     60                            ["dI_didata", "dI_didata", "bool"], 
     61                            ["dI_sqrdata", "dI_sqrdata", "bool"], 
     62                            ["dI_idata", "dI_idata", "bool"], 
     63                            ["enable2D", "enable2D", "bool"], 
     64                            ["cb1", "cb1", "bool"], 
     65                            ["tcChi", "tcChi", "float"], 
     66                            ["smearer", "smearer", "float"], 
     67                            ["smear_type", "smear_type", "string"], 
     68                            ["dq_l", "dq_l", "string"], 
     69                            ["dq_r", "dq_r", "string"], 
     70                            ["dx_max", "dx_max", "float"], 
     71                            ["dx_min", "dx_min", "float"], 
     72                            ["dxl", "dxl", "float"], 
     73                            ["dxw", "dxw", "float"]] 
     74 
     75LIST_OF_MODEL_ATTRIBUTES = [["values", "values"], 
    7976                            ["weights", "weights"]] 
    8077 
    81 list_of_obj_dic = [["disp_obj_dict", "_disp_obj_dict", "string"]] 
    82  
    83 list_of_state_parameters = [["parameters", "parameters"], 
     78DISPERSION_LIST = [["disp_obj_dict", "_disp_obj_dict", "string"]] 
     79 
     80LIST_OF_STATE_PARAMETERS = [["parameters", "parameters"], 
    8481                            ["str_parameters", "str_parameters"], 
    8582                            ["orientation_parameters", "orientation_params"], 
    … …  
    8784                            ["fixed_param", "fixed_param"], 
    8885                            ["fittable_param", "fittable_param"]] 
    89 list_of_data_2d_attr = [["xmin", "xmin", "float"], 
     86LIST_OF_DATA_2D_ATTR = [["xmin", "xmin", "float"], 
    9087                        ["xmax", "xmax", "float"], 
    9188                        ["ymin", "ymin", "float"], 
    … …  
    9794                        ["_zaxis", "_zaxis", "string"], 
    9895                        ["_zunit", "_zunit", "string"]] 
    99 list_of_data2d_values = [["qx_data", "qx_data", "float"], 
    100                          ["qy_data", "qy_data", "float"], 
    101                          ["dqx_data", "dqx_data", "float"], 
    102                          ["dqy_data", "dqy_data", "float"], 
    103                          ["data", "data", "float"], 
    104                          ["q_data", "q_data", "float"], 
    105                          ["err_data", "err_data", "float"], 
    106                          ["mask", "mask", "bool"]] 
     96LIST_OF_DATA_2D_VALUES = [["qx_data", "qx_data", "float"], 
     97                          ["qy_data", "qy_data", "float"], 
     98                          ["dqx_data", "dqx_data", "float"], 
     99                          ["dqy_data", "dqy_data", "float"], 
     100                          ["data", "data", "float"], 
     101                          ["q_data", "q_data", "float"], 
     102                          ["err_data", "err_data", "float"], 
     103                          ["mask", "mask", "bool"]] 
    107104 
    108105 
    … …  
    110107    """ 
    111108    Create a numpy list from value extrated from the node 
    112      
     109 
    113110    :param node: node from each the value is stored 
    114111    :param item: list name of three strings.the two first are name of data 
    115112        attribute and the third one is the type of the value of that 
    116113        attribute. type can be string, float, bool, etc. 
    117      
     114 
    118115    : return: numpy array 
    119116    """ 
    … …  
    124121            try: 
    125122                return node.get(item[0]).strip() == "True" 
    126                  
     123 
    127124            except: 
    128125                return None 
    … …  
    132129            except: 
    133130                return None 
    134              
    135              
     131 
     132 
    136133class PageState(object): 
    137134    """ 
    … …  
    141138        """ 
    142139        Initialize the current state 
    143          
     140 
    144141        :param model: a selected model within a page 
    145142        :param data: 
    146          
     143 
    147144        """ 
    148145        self.file = None 
    … …  
    159156        self.is_2D = False 
    160157        self.images = None 
    161          
     158 
    162159        #save additional information on data that dataloader.reader does not read 
    163160        self.is_data = None 
    … …  
    172169        if self.data is not None and hasattr(self.data, "group_id"): 
    173170            self.data_group_id = self.data.group_id 
    174          
     171 
    175172        ## reset True change the state of exsiting button 
    176173        self.reset = False 
    177         
     174 
    178175        #engine type 
    179176        self.engine_type = None 
    … …  
    225222        self.values = {} 
    226223        self.weights = {} 
    227                      
     224 
    228225        #contains link between a model and selected parameters to fit 
    229226        self.param_toFit = [] 
    … …  
    251248        self.qmax_x = None 
    252249        self.qmin_x = None 
    253          
     250 
    254251        self.npts = None 
    255252        self.name = "" 
    … …  
    269266        self.enable_disp = False 
    270267        self.disable_disp = True 
    271         
     268 
    272269        ## state of selected all check button 
    273270        self.cb1 = False 
    274271        ## store value of chisqr 
    275272        self.tcChi = None 
    276      
     273 
    277274    def clone(self): 
    278275        """ 
    … …  
    292289        obj.model_list_box = copy.deepcopy(self.model_list_box) 
    293290        obj.engine_type = copy.deepcopy(self.engine_type) 
    294          
     291 
    295292        obj.categorycombobox = self.categorycombobox 
    296293        obj.formfactorcombobox = self.formfactorcombobox 
    297294        obj.structurecombobox = self.structurecombobox 
    298          
     295 
    299296        #obj.shape_rbutton = self.shape_rbutton 
    300297        #obj.shape_indep_rbutton = self.shape_indep_rbutton 
    301298        #obj.struct_rbutton = self.struct_rbutton 
    302299        #obj.plugin_rbutton = self.plugin_rbutton 
    303          
     300 
    304301        obj.manager = self.manager 
    305302        obj.event_owner = self.event_owner 
    306303        obj.disp_list = copy.deepcopy(self.disp_list) 
    307          
     304 
    308305        obj.enable2D = copy.deepcopy(self.enable2D) 
    309306        obj.parameters = copy.deepcopy(self.parameters) 
    … …  
    316313        obj.disable_disp = copy.deepcopy(self.disable_disp) 
    317314        obj.tcChi = self.tcChi 
    318    
     315 
    319316        if len(self._disp_obj_dict) > 0: 
    320317            for k, v in self._disp_obj_dict.iteritems(): 
    … …  
    343340        obj.dx_min = copy.deepcopy(self.dx_min) 
    344341        obj.dxl = copy.deepcopy(self.dxl) 
    345         obj.dxw = copy.deepcopy(self.dxw)         
     342        obj.dxw = copy.deepcopy(self.dxw) 
    346343        obj.disp_box = copy.deepcopy(self.disp_box) 
    347344        obj.qmin = copy.deepcopy(self.qmin) 
    … …  
    352349        obj.cb1 = copy.deepcopy(self.cb1) 
    353350        obj.smearer = copy.deepcopy(self.smearer) 
    354          
     351 
    355352        for name, state in self.saved_states.iteritems(): 
    356353            copy_name = copy.deepcopy(name) 
    … …  
    358355            obj.saved_states[copy_name] = copy_state 
    359356        return obj 
    360      
     357 
    361358    def _repr_helper(self, list, rep): 
    362359        """ 
    … …  
    375372            rep += "parameter unit: %s\n\n" % str(item[7]) 
    376373        return rep 
    377      
     374 
    378375    def __repr__(self): 
    379376        """ 
    … …  
    397394        else: 
    398395            rep += "model name : None\n" 
    399         #rep += "model type (form factor) selected: %s\n" % self.shape_rbutton  
    400396        rep += "multi_factor : %s\n" % str(self.multi_factor) 
    401         rep += "magnetic_on : %s\n"% str(self.magnetic_on) 
     397        rep += "magnetic_on : %s\n" % str(self.magnetic_on) 
    402398        rep += "model type (Category) selected: %s\n" % self.categorycombobox 
    403         #rep += "model type (shape independent) selected: %s\n" % self.shape_indep_rbutton 
    404         #rep += "model type (structure factor) selected: %s\n" % self.struct_rbutton 
    405         #rep += "model type (plug-in ) selected: %s\n" % self.plugin_rbutton 
    406399        rep += "data : %s\n" % str(self.data) 
    407400        rep += "Plotting Range: min: %s, max: %s, steps: %s\n" % (str(self.qmin), 
    408                                                 str(self.qmax), str(self.npts)) 
     401                                                                  str(self.qmax), str(self.npts)) 
    409402        rep += "Dispersion selection : %s\n" % str(self.disp_box) 
    410403        rep += "Smearing enable : %s\n" % str(self.enable_smearer) 
    … …  
    415408        rep += "Dispersity disable : %s\n" % str(self.disable_disp) 
    416409        rep += "Slit smearer enable: %s\n" % str(self.slit_smearer) 
    417          
     410 
    418411        rep += "dI_noweight : %s\n" % str(self.dI_noweight) 
    419412        rep += "dI_didata : %s\n" % str(self.dI_didata) 
    420413        rep += "dI_sqrdata : %s\n" % str(self.dI_sqrdata) 
    421414        rep += "dI_idata : %s\n" % str(self.dI_idata) 
    422          
     415 
    423416        rep += "2D enable : %s\n" % str(self.enable2D) 
    424417        rep += "All parameters checkbox selected: %s\n" % (self.cb1) 
    … …  
    429422        rep += "dq_r  : %s\n" % self.dq_r 
    430423        rep += "dx_max  : %s\n" % str(self.dx_max) 
    431         rep += "dx_min : %s\n" % str(self.dx_min)   
     424        rep += "dx_min : %s\n" % str(self.dx_min) 
    432425        rep += "dxl  : %s\n" % str(self.dxl) 
    433         rep += "dxw : %s\n" % str(self.dxw)     
     426        rep += "dxw : %s\n" % str(self.dxw) 
    434427        rep += "model  : %s\n\n" % str(self.model) 
    435428        temp_parameters = [] 
    … …  
    450443                temp_parameters = self.parameters 
    451444                temp_fittable_param = self.fittable_param 
    452                  
     445 
    453446            rep += "number parameters(self.parameters): %s\n" % len(temp_parameters) 
    454447            rep = self._repr_helper(list=temp_parameters, rep=rep) 
    … …  
    457450            rep += "number fittable_param(self.fittable_param): %s\n" % len(temp_fittable_param) 
    458451            rep = self._repr_helper(list=temp_fittable_param, rep=rep) 
    459             """ 
    460             if is_2D: 
    461                 rep += "number orientation parameters" 
    462                 rep += "(self.orientation_params): %s\n"%len(self.orientation_params) 
    463                 rep = self._repr_helper( list=self.orientation_params, rep=rep) 
    464                 rep += "number dispersity parameters" 
    465                 rep += "(self.orientation_params_disp): %s\n"%len(self.orientation_params_disp) 
    466                 rep = self._repr_helper( list=self.orientation_params_disp, rep=rep) 
    467             """ 
    468452        return rep 
    469453 
    … …  
    481465        paramval_string = "" 
    482466        chi2_string = "" 
    483         multi_factor_string = "" 
    484467        q_range = "" 
    485468        strings = self.__repr__() 
    … …  
    494477                value = content[1] 
    495478            except: 
    496                 pass 
     479                logging.error(sys.exc_value) 
    497480            if name.count("State created"): 
    498481                repo_time = "" + value 
    … …  
    508491            if name == "value": 
    509492                param_string += value + ',' 
    510             if name == "selected": 
    511                 if value == u' False': 
    512                     fixed_parameter = True 
    513                 else: 
    514                     fixed_parameter = False 
     493            if name == "selected": 
     494                if value == u' False': 
     495                    fixed_parameter = True 
     496                else: 
     497                    fixed_parameter = False 
    515498            if name == "error value": 
    516                 if fixed_parameter: 
    517                     param_string += '(fixed),' 
    518                 else: 
     499                if fixed_parameter: 
     500                    param_string += '(fixed),' 
     501                else: 
    519502                    param_string += value + ',' 
    520503            if name == "parameter unit": 
    … …  
    523506                chi2 = ("Chi2/Npts = " + value) 
    524507                chi2_string = CENTRE % chi2 
    525             if name == "multi_factor ": 
    526                 muti_factor = ("muti_factor = " + value) 
    527                 muti_factor_string = CENTRE % muti_factor 
    528             if name == "magentic_on ": 
    529                 magentic_on = ("magentic_on = " + value) 
    530                 if string(value) == 'True': 
    531                     magentic_on_string = CENTRE % magentic_on 
    532508            if name == "Title": 
    533509                if len(value.strip()) == 0: 
    … …  
    537513            if name == "data ": 
    538514                try: 
    539                     file = ("File name:" + content[2]) 
    540                     file_name = CENTRE % file 
     515                    file_value = ("File name:" + content[2]) 
     516                    file_name = CENTRE % file_value 
    541517                    if len(title) == 0: 
    542518                        title = content[2] + " [" + repo_time + "]" 
    543519                        title_name = HEADER % title 
    544520                except: 
    545                     pass 
     521                    logging.error(sys.exc_value) 
    546522            if name == "model name ": 
    547523                try: 
    … …  
    550526                    modelname = "Model name:" + " NAN" 
    551527                model_name = CENTRE % modelname 
    552                   
     528 
    553529            if name == "Plotting Range": 
    554530                try: 
    … …  
    558534                    q_range = CENTRE % q_name 
    559535                except: 
    560                     pass 
     536                    logging.error(sys.exc_value) 
    561537        paramval = "" 
    562538        for lines in param_string.split(":"): 
    … …  
    572548                    paramval += param + "\n" 
    573549                    paramval_string += CENTRE % param + "\n" 
    574          
     550 
    575551        text_string = "\n\n\n" + title + "\n\n" + file + \ 
    576552                      "\n" + q_name + \ 
    577553                      "\n" + chi2 + \ 
    578554                      "\n\n" + paramval 
    579          
     555 
    580556        title_name = self._check_html_format(title_name) 
    581557        file_name = self._check_html_format(file_name) 
    582558        title = self._check_html_format(title) 
    583                                    
     559 
    584560        html_string = title_name + "\n" + file_name + \ 
    585561                                   "\n" + model_name + \ 
    … …  
    591567                                   "\n" + FEET_1 % title + \ 
    592568                                   "\n" + FEET_2 
    593                                                                        
     569 
    594570        return html_string, text_string, title 
    595      
     571 
    596572    def _check_html_format(self, name): 
    597573        """ 
    … …  
    600576        if name.count('%'): 
    601577            name = name.replace('%', '&#37') 
    602          
     578 
    603579        return name 
    604      
     580 
    605581    def report(self, figs=None, canvases=None): 
    606582        """ 
    607583        Invoke report dialog panel 
    608          
     584 
    609585        : param figs: list of pylab figures [list] 
    610586        """ 
    … …  
    638614        dialog = ReportDialog(report_list, None, -1, "") 
    639615        dialog.Show() 
    640          
     616 
    641617    def _toXML_helper(self, thelist, element, newdoc): 
    642618        """ 
    … …  
    656632            sub_element.setAttribute('unit', str(item[7])) 
    657633            element.appendChild(sub_element) 
    658          
     634 
    659635    def toXML(self, file="fitting_state.fitv", doc=None, entry_node=None): 
    660636        """ 
    661637        Writes the state of the InversionControl panel to file, as XML. 
    662          
     638 
    663639        Compatible with standalone writing, or appending to an 
    664640        already existing XML document. In that case, the XML document 
    665641        is required. An optional entry node in the XML document may also be given. 
    666          
     642 
    667643        :param file: file to write to 
    668644        :param doc: XML document object [optional] 
    669645        :param entry_node: XML node within the XML document at which we will append the data [optional] 
    670          
     646 
    671647        """ 
    672648        from xml.dom.minidom import getDOMImplementation 
    … …  
    697673                    entry_node = node_list.item(0) 
    698674                    entry_node.appendChild(top_element) 
    699                      
     675 
    700676        attr = newdoc.createAttribute("version") 
    701677        attr.nodeValue = '1.0' 
    702678        top_element.setAttributeNode(attr) 
    703          
     679 
    704680        # File name 
    705681        element = newdoc.createElement("filename") 
    … …  
    709685            element.appendChild(newdoc.createTextNode(str(file))) 
    710686        top_element.appendChild(element) 
    711          
     687 
    712688        element = newdoc.createElement("timestamp") 
    713689        element.appendChild(newdoc.createTextNode(time.ctime(self.timestamp))) 
    … …  
    719695        inputs = newdoc.createElement("Attributes") 
    720696        top_element.appendChild(inputs) 
    721         
     697 
    722698        if self.data is not None and hasattr(self.data, "group_id"): 
    723699            self.data_group_id = self.data.group_id 
    … …  
    728704        if self.data is not None and hasattr(self.data, "id"): 
    729705            self.data_id = self.data.id 
    730         
    731         for item in list_of_data_attributes: 
     706 
     707        for item in LIST_OF_DATA_ATTRIBUTES: 
    732708            element = newdoc.createElement(item[0]) 
    733             exec "element.setAttribute(item[0], str(self.%s))" % (item[1]) 
     709            element.setAttribute(item[0], str(getattr(self, item[1]))) 
    734710            inputs.appendChild(element) 
    735          
    736         for item in list_of_state_attributes: 
     711 
     712        for item in LIST_OF_STATE_ATTRIBUTES: 
    737713            element = newdoc.createElement(item[0]) 
    738             exec "element.setAttribute(item[0], str(self.%s))" % (item[1]) 
     714            element.setAttribute(item[0], str(getattr(self, item[1]))) 
    739715            inputs.appendChild(element) 
    740              
     716 
    741717        # For self.values ={ disp_param_name: [vals,...],...} 
    742718        # and for self.weights ={ disp_param_name: [weights,...],...} 
    743         list = {} 
    744         for item in list_of_model_attributes: 
     719        value_list = {} 
     720        for item in LIST_OF_MODEL_ATTRIBUTES: 
    745721            element = newdoc.createElement(item[0]) 
    746             exec "list = self.%s" % item[1] 
    747             for key, value in list.iteritems(): 
     722            value_list = getattr(self, item[1]) 
     723            for key, value in value_list.iteritems(): 
    748724                sub_element = newdoc.createElement(key) 
    749725                sub_element.setAttribute('name', str(key)) 
    750726                for val in value: 
    751                     com = "sub_element.appendChild" 
    752                     com += "(newdoc.createTextNode(str(%s)))" 
    753                     exec com % val 
    754                     
     727                    sub_element.appendChild(newdoc.createTextNode(str(val))) 
     728 
    755729                element.appendChild(sub_element) 
    756730            inputs.appendChild(element) 
    757          
     731 
    758732        # Create doc for the dictionary of self._disp_obj_dic 
    759         for item in list_of_obj_dic: 
     733        for item in DISPERSION_LIST: 
    760734            element = newdoc.createElement(item[0]) 
    761             exec "list = self.%s" % item[1] 
    762             for key, val in list.iteritems(): 
     735            value_list = getattr(self, item[1]) 
     736            for key, val in value_list.iteritems(): 
    763737                value = repr(val) 
    764738                sub_element = newdoc.createElement(key) 
    … …  
    767741                element.appendChild(sub_element) 
    768742            inputs.appendChild(element) 
    769                   
    770         for item in list_of_state_parameters: 
     743 
     744        for item in LIST_OF_STATE_PARAMETERS: 
    771745            element = newdoc.createElement(item[0]) 
    772             com = "self._toXML_helper(thelist=self.%s," 
    773             com += " element=element, newdoc=newdoc)" 
    774             exec com % item[1] 
     746            self._toXML_helper(thelist=getattr(self, item[1]), element=element, newdoc=newdoc) 
    775747            inputs.appendChild(element) 
    776          
     748 
    777749        # Save the file 
    778750        if doc is None: 
    … …  
    783755        else: 
    784756            return newdoc 
    785          
     757 
    786758    def _fromXML_helper(self, node, list): 
    787759        """ 
    … …  
    833805                         [minimum_displayed, minimum_value], 
    834806                         [maximum_displayed, maximum_value], unit]) 
    835         
     807 
    836808    def fromXML(self, file=None, node=None): 
    837809        """ 
    838810        Load fitting state from a file 
    839          
     811 
    840812        :param file: .fitv file 
    841813        :param node: node of a XML document to read from 
    842          
     814 
    843815        """ 
    844816        if file is not None: 
    … …  
    846818            msg += " format for fitting files" 
    847819            raise RuntimeError, msg 
    848              
     820 
    849821        if node.get('version')and node.get('version') == '1.0': 
    850              
     822 
    851823            # Get file name 
    852824            entry = get_content('ns:filename', node) 
    853825            if entry is not None: 
    854826                self.file = entry.text.strip() 
    855                  
     827 
    856828            # Get time stamp 
    857829            entry = get_content('ns:timestamp', node) 
    … …  
    863835                    msg += " read timestamp\n %s" % sys.exc_value 
    864836                    logging.error(msg) 
    865              
     837 
    866838            # Parse fitting attributes 
    867839            entry = get_content('ns:Attributes', node) 
    868             for item in list_of_data_attributes: 
     840            for item in LIST_OF_DATA_ATTRIBUTES: 
    869841                node = get_content('ns:%s' % item[0], entry) 
    870                 try: 
    871                     exec "self.%s = parse_entry_helper(node, item)" % item[0] 
    872                      
    873                 except: 
    874                     raise 
     842                setattr(self, item[0], parse_entry_helper(node, item)) 
    875843 
    876844            if entry is not None: 
    877                  
    878                 for item in list_of_state_attributes: 
     845                for item in LIST_OF_STATE_ATTRIBUTES: 
    879846                    node = get_content('ns:%s' % item[0], entry) 
    880                     try: 
    881                         exec "self.%s = parse_entry_helper(node, item)" % \ 
    882                                                                 str(item[0]) 
    883                     except: 
    884                         raise 
    885                      
    886                 for item in list_of_state_parameters: 
     847                    setattr(self, item[0], parse_entry_helper(node, item)) 
     848 
     849                for item in LIST_OF_STATE_PARAMETERS: 
    887850                    node = get_content("ns:%s" % item[0], entry) 
    888                     exec "self._fromXML_helper(node=node, list=self.%s)" % \ 
    889                                                                     item[1] 
    890                  
     851                    self._fromXML_helper(node=node, list=getattr(self, item[1])) 
     852 
    891853                # Recover _disp_obj_dict from xml file 
    892854                self._disp_obj_dict = {} 
    893                 disp_model = None 
    894                 for item in list_of_obj_dic: 
     855                for item in DISPERSION_LIST: 
    895856                    # Get node 
    896857                    node = get_content("ns:%s" % item[0], entry) 
    897858                    for attr in node: 
    898                         name = attr.get('name') 
     859                        name = str(attr.get('name')) 
    899860                        val = attr.get('value') 
    900861                        value = val.split(" instance")[0] 
    … …  
    907868                            exec com % com_name 
    908869                            disp_model = disp() 
    909                             exec "self.%s['%s'] = com_name" % (item[1], name) 
     870                            attribute = getattr(self, item[1]) 
     871                            attribute[name] = com_name 
    910872                        except: 
    911                             pass 
    912                          
     873                            logging.error(sys.exc_value) 
     874 
    913875                # get self.values and self.weights dic. if exists 
    914                 for item in list_of_model_attributes: 
     876                for item in LIST_OF_MODEL_ATTRIBUTES: 
    915877                    node = get_content("ns:%s" % item[0], entry) 
    916878                    dic = {} 
    917                     list = [] 
     879                    value_list = [] 
    918880                    for par in node: 
    919881                        name = par.get('name') 
    … …  
    923885                            try: 
    924886                                val = float(line) 
    925                                 list.append(val) 
     887                                value_list.append(val) 
    926888                            except: 
    927889                                # pass if line is empty (it happens) 
    928                                 pass 
    929                     dic[name] = numpy.array(list) 
    930                     exec "self.%s = dic" % item[1] 
    931                      
     890                                logging.error(sys.exc_value) 
     891                    dic[name] = numpy.array(value_list) 
     892                    setattr(self, item[1], dic) 
     893 
    932894    def set_plot_state(self, figs, canvases): 
    933895        """ 
    … …  
    943905        self.imgRAM = None 
    944906        wx.MemoryFSHandler() 
    945          
     907 
    946908        # For no figures in the list, prepare empty plot 
    947909        if figs == None or len(figs) == 0: 
    948910            figs = [None] 
    949              
     911 
    950912        # Loop over the list of figures 
    951913        # use wx.MemoryFSHandler 
    … …  
    955917                ind = figs.index(fig) 
    956918                canvas = canvases[ind] 
    957                  
    958             #store the image in wx.FileSystem Object  
     919 
     920            #store the image in wx.FileSystem Object 
    959921            wx.FileSystem.AddHandler(wx.MemoryFSHandler()) 
    960              
     922 
    961923            # index of the fig 
    962924            ind = figs.index(fig) 
    963              
     925 
    964926            #AddFile, image can be retrieved with 'memory:filename' 
    965927            self.imgRAM.AddFile('img_fit%s.png' % ind, 
    966928                                canvas.bitmap, wx.BITMAP_TYPE_PNG) 
    967              
     929 
    968930            #append figs 
    969931            images.append(fig) 
    970              
     932 
    971933        return images 
    972934 
    … …  
    978940    ## File type 
    979941    type_name = "Fitting" 
    980      
     942 
    981943    ## Wildcards 
    982944    type = ["Fitting files (*.fitv)|*.fitv" 
    … …  
    984946    ## List of allowed extensions 
    985947    ext = ['.fitv', '.FITV', '.svs', 'SVS'] 
    986      
     948 
    987949    def __init__(self, call_back=None, cansas=True): 
    988950        CansasReader.__init__(self) 
    … …  
    990952        Initialize the call-back method to be called 
    991953        after we load a file 
    992          
     954 
    993955        :param call_back: call-back method 
    994956        :param cansas:  True = files will be written/read in CanSAS format 
    995957                        False = write CanSAS format 
    996              
     958 
    997959        """ 
    998960        ## Call back method to be executed after a file is read 
    … …  
    1001963        self.cansas = cansas 
    1002964        self.state = None 
    1003          
     965 
    1004966    def get_state(self): 
    1005967        return self.state 
    1006          
     968 
    1007969    def read(self, path): 
    1008970        """ 
    1009971        Load a new P(r) inversion state from file 
    1010          
     972 
    1011973        :param path: file path 
    1012          
     974 
    1013975        """ 
    1014976        if self.cansas == True: 
    1015977            return self._read_cansas(path) 
    1016       
     978 
    1017979    def _data2d_to_xml_doc(self, datainfo): 
    1018980        """ 
    1019981        Create an XML document to contain the content of a Data2D 
    1020          
     982 
    1021983        :param datainfo: Data2D object 
    1022          
     984 
    1023985        """ 
    1024986        if not issubclass(datainfo.__class__, Data2D): 
    1025987            raise RuntimeError, "The cansas writer expects a Data2D instance" 
    1026          
     988 
    1027989        doc = xml.dom.minidom.Document() 
    1028990        main_node = doc.createElement("SASroot") 
    … …  
    1030992        main_node.setAttribute("xmlns", "cansas1d/%s" % self.version) 
    1031993        main_node.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance") 
    1032         main_node.setAttribute("xsi:schemaLocation", "cansas1d/%s http://svn.smallangles.net/svn/canSAS/1dwg/trunk/cansas1d.xsd" % self.version) 
    1033          
     994        main_node.setAttribute("xsi:schemaLocation", 
     995                               "cansas1d/%s http://svn.smallangles.net/svn/canSAS/1dwg/trunk/cansas1d.xsd" % self.version) 
     996 
    1034997        doc.appendChild(main_node) 
    1035          
     998 
    1036999        entry_node = doc.createElement("SASentry") 
    10371000        main_node.appendChild(entry_node) 
    1038         
     1001 
    10391002        write_node(doc, entry_node, "Title", datainfo.title) 
    10401003        if datainfo is not None: 
    … …  
    10421005        for item in datainfo.run: 
    10431006            runname = {} 
    1044             if datainfo.run_name.has_key(item) and len(str(datainfo.run_name[item]))>1: 
    1045                 runname = {'name': datainfo.run_name[item] } 
     1007            if datainfo.run_name.has_key(item) and len(str(datainfo.run_name[item])) > 1: 
     1008                runname = {'name': datainfo.run_name[item]} 
    10461009            write_node(doc, entry_node, "Run", item, runname) 
    10471010        # Data info 
    10481011        new_node = doc.createElement("SASdata") 
    10491012        entry_node.appendChild(new_node) 
    1050         for item in list_of_data_2d_attr: 
     1013        for item in LIST_OF_DATA_2D_ATTR: 
    10511014            element = doc.createElement(item[0]) 
    1052             exec "element.setAttribute(item[0], str(datainfo.%s))" % (item[1]) 
     1015            element.setAttribute(item[0], str(getattr(datainfo, item[1]))) 
    10531016            new_node.appendChild(element) 
    1054              
    1055         for item in list_of_data2d_values: 
     1017 
     1018        for item in LIST_OF_DATA_2D_VALUES: 
    10561019            root_node = doc.createElement(item[0]) 
    10571020            new_node.appendChild(root_node) 
    10581021            temp_list = None 
    1059             exec "temp_list = datainfo.%s" % item[1] 
    1060  
    1061             if temp_list is None or len(temp_list)== 0: 
     1022            temp_list = getattr(datainfo, item[1]) 
     1023 
     1024            if temp_list is None or len(temp_list) == 0: 
    10621025                element = doc.createElement(item[0]) 
    1063                 exec "element.appendChild(doc.createTextNode(str(%s)))" % temp_list 
     1026                element.appendChild(doc.createTextNode(str(temp_list))) 
    10641027                root_node.appendChild(element) 
    10651028            else: 
    10661029                for value in temp_list: 
    10671030                    element = doc.createElement(item[0]) 
    1068                     exec "element.setAttribute(item[0], str(%s))" % value 
     1031                    element.setAttribute(item[0], str(value)) 
    10691032                    root_node.appendChild(element) 
    1070         
     1033 
    10711034        # Sample info 
    10721035        sample = doc.createElement("SASsample") 
    … …  
    10801043        write_node(doc, sample, "temperature", datainfo.sample.temperature, 
    10811044                   {"unit": datainfo.sample.temperature_unit}) 
    1082          
     1045 
    10831046        for item in datainfo.sample.details: 
    10841047            write_node(doc, sample, "details", item) 
    1085          
     1048 
    10861049        pos = doc.createElement("position") 
    10871050        written = write_node(doc, pos, "x", datainfo.sample.position.x, 
    … …  
    10951058        if written == True: 
    10961059            sample.appendChild(pos) 
    1097          
     1060 
    10981061        ori = doc.createElement("orientation") 
    10991062        written = write_node(doc, ori, "roll", datainfo.sample.orientation.x, 
    … …  
    11071070        if written == True: 
    11081071            sample.appendChild(ori) 
    1109          
     1072 
    11101073        # Instrument info 
    11111074        instr = doc.createElement("SASinstrument") 
    11121075        entry_node.appendChild(instr) 
    1113          
     1076 
    11141077        write_node(doc, instr, "name", datainfo.instrument) 
    1115          
     1078 
    11161079        #   Source 
    11171080        source = doc.createElement("SASsource") 
    … …  
    11191082            source.setAttribute("name", str(datainfo.source.name)) 
    11201083        instr.appendChild(source) 
    1121          
     1084 
    11221085        write_node(doc, source, "radiation", datainfo.source.radiation) 
    11231086        write_node(doc, source, "beam_shape", datainfo.source.beam_shape) 
    … …  
    11351098        if written == True: 
    11361099            source.appendChild(size) 
    1137              
     1100 
    11381101        write_node(doc, source, "wavelength", datainfo.source.wavelength, 
    11391102                   {"unit": datainfo.source.wavelength_unit}) 
    … …  
    11471110                   datainfo.source.wavelength_spread, 
    11481111                   {"unit": datainfo.source.wavelength_spread_unit}) 
    1149          
     1112 
    11501113        #   Collimation 
    11511114        for item in datainfo.collimation: 
    … …  
    11541117                coll.setAttribute("name", str(item.name)) 
    11551118            instr.appendChild(coll) 
    1156              
     1119 
    11571120            write_node(doc, coll, "length", item.length, 
    11581121                       {"unit": item.length_unit}) 
    1159              
     1122 
    11601123            for apert in item.aperture: 
    11611124                ap = doc.createElement("aperture") 
    … …  
    11651128                    ap.setAttribute("type", str(apert.type)) 
    11661129                coll.appendChild(ap) 
    1167                  
     1130 
    11681131                write_node(doc, ap, "distance", apert.distance, 
    11691132                           {"unit": apert.distance_unit}) 
    1170                  
     1133 
    11711134                size = doc.createElement("size") 
    11721135                if apert.size_name is not None: 
    … …  
    11921155            if written == True: 
    11931156                instr.appendChild(det) 
    1194              
     1157 
    11951158            off = doc.createElement("offset") 
    11961159            written = write_node(doc, off, "x", item.offset.x, 
    … …  
    12021165            if written == True: 
    12031166                det.appendChild(off) 
    1204              
     1167 
    12051168            center = doc.createElement("beam_center") 
    12061169            written = write_node(doc, center, "x", item.beam_center.x, 
    … …  
    12141177            if written == True: 
    12151178                det.appendChild(center) 
    1216                  
     1179 
    12171180            pix = doc.createElement("pixel_size") 
    12181181            written = write_node(doc, pix, "x", item.pixel_size.x, 
    … …  
    12241187            if written == True: 
    12251188                det.appendChild(pix) 
    1226                  
     1189 
    12271190            ori = doc.createElement("orientation") 
    12281191            written = write_node(doc, ori, "roll", item.orientation.x, 
    … …  
    12351198            if written == True: 
    12361199                det.appendChild(ori) 
    1237                  
     1200 
    12381201        # Processes info 
    12391202        for item in datainfo.process: 
    … …  
    12531216        # the data we just wrote 
    12541217        return doc, entry_node 
    1255     
     1218 
    12561219    def _parse_state(self, entry): 
    12571220        """ 
    12581221        Read a fit result from an XML node 
    1259          
     1222 
    12601223        :param entry: XML node to read from 
    1261          
     1224 
    12621225        :return: PageState object 
    12631226        """ 
    12641227        # Create an empty state 
    1265         state = None    
     1228        state = None 
    12661229        # Locate the P(r) node 
    12671230        try: 
    … …  
    12721235                state = PageState() 
    12731236                state.fromXML(node=nodes[0]) 
    1274                  
     1237 
    12751238        except: 
    12761239            logging.info("XML document does not contain fitting information.\n %s" % sys.exc_value) 
    1277              
     1240 
    12781241        return state 
    1279        
     1242 
    12801243    def _parse_save_state_entry(self, dom): 
    12811244        """ 
    12821245        Parse a SASentry 
    1283          
     1246 
    12841247        :param node: SASentry node 
    1285          
     1248 
    12861249        :return: Data1D/Data2D object 
    1287          
     1250 
    12881251        """ 
    12891252        node = dom.xpath('ns:data_class', namespaces={'ns': CANSAS_NS}) 
    … …  
    13051268                numpy.trim_zeros(return_value.dxl) 
    13061269                numpy.trim_zeros(return_value.dxw) 
    1307                              
     1270 
    13081271            return return_value, _ 
    1309          
     1272 
    13101273        #Parse 2D 
    13111274        data_info = Data2D() 
    1312          
     1275 
    13131276        # Look up title 
    13141277        self._store_content('ns:Title', dom, 'title', data_info) 
    1315          
     1278 
    13161279        # Look up run number 
    13171280        nodes = dom.xpath('ns:Run', namespaces={'ns': CANSAS_NS}) 
    … …  
    13231286                    if item.get('name') is not None: 
    13241287                        data_info.run_name[value] = item.get('name') 
    1325                             
     1288 
    13261289        # Look up instrument name 
    13271290        self._store_content('ns:SASinstrument/ns:name', dom, 
    … …  
    13401303                self.errors.append(err_mess) 
    13411304                logging.error(err_mess) 
    1342          
     1305 
    13431306        # Sample info ################### 
    13441307        entry = get_content('ns:SASsample', dom) 
    13451308        if entry is not None: 
    13461309            data_info.sample.name = entry.get('name') 
    1347              
    1348         self._store_content('ns:SASsample/ns:ID', 
    1349                      dom, 'ID', data_info.sample) 
    1350         self._store_float('ns:SASsample/ns:thickness', 
    1351                      dom, 'thickness', data_info.sample) 
    1352         self._store_float('ns:SASsample/ns:transmission', 
    1353                      dom, 'transmission', data_info.sample) 
    1354         self._store_float('ns:SASsample/ns:temperature', 
    1355                      dom, 'temperature', data_info.sample) 
    1356          
    1357         nodes = dom.xpath('ns:SASsample/ns:details', 
    1358                           namespaces={'ns': CANSAS_NS}) 
     1310 
     1311        self._store_content('ns:SASsample/ns:ID', dom, 'ID', data_info.sample) 
     1312        self._store_float('ns:SASsample/ns:thickness', dom, 'thickness', data_info.sample) 
     1313        self._store_float('ns:SASsample/ns:transmission', dom, 'transmission', data_info.sample) 
     1314        self._store_float('ns:SASsample/ns:temperature', dom, 'temperature', data_info.sample) 
     1315 
     1316        nodes = dom.xpath('ns:SASsample/ns:details', namespaces={'ns': CANSAS_NS}) 
    13591317        for item in nodes: 
    13601318            try: 
    … …  
    13671325                self.errors.append(err_mess) 
    13681326                logging.error(err_mess) 
    1369          
     1327 
    13701328        # Position (as a vector) 
    1371         self._store_float('ns:SASsample/ns:position/ns:x', 
    1372                      dom, 'position.x', data_info.sample) 
    1373         self._store_float('ns:SASsample/ns:position/ns:y', 
    1374                      dom, 'position.y', data_info.sample) 
    1375         self._store_float('ns:SASsample/ns:position/ns:z', 
    1376                      dom, 'position.z', data_info.sample) 
    1377          
     1329        self._store_float('ns:SASsample/ns:position/ns:x', dom, 'position.x', data_info.sample) 
     1330        self._store_float('ns:SASsample/ns:position/ns:y', dom, 'position.y', data_info.sample) 
     1331        self._store_float('ns:SASsample/ns:position/ns:z', dom, 'position.z', data_info.sample) 
     1332 
    13781333        # Orientation (as a vector) 
    13791334        self._store_float('ns:SASsample/ns:orientation/ns:roll', 
    1380                      dom, 'orientation.x', data_info.sample) 
     1335                          dom, 'orientation.x', data_info.sample) 
    13811336        self._store_float('ns:SASsample/ns:orientation/ns:pitch', 
    1382                      dom, 'orientation.y', data_info.sample) 
     1337                          dom, 'orientation.y', data_info.sample) 
    13831338        self._store_float('ns:SASsample/ns:orientation/ns:yaw', 
    1384                      dom, 'orientation.z', data_info.sample) 
    1385         
     1339                          dom, 'orientation.z', data_info.sample) 
     1340 
    13861341        # Source info ################### 
    13871342        entry = get_content('ns:SASinstrument/ns:SASsource', dom) 
    13881343        if entry is not None: 
    13891344            data_info.source.name = entry.get('name') 
    1390          
     1345 
    13911346        self._store_content('ns:SASinstrument/ns:SASsource/ns:radiation', 
    1392                      dom, 'radiation', data_info.source) 
     1347                            dom, 'radiation', data_info.source) 
    13931348        self._store_content('ns:SASinstrument/ns:SASsource/ns:beam_shape', 
    1394                      dom, 'beam_shape', data_info.source) 
     1349                            dom, 'beam_shape', data_info.source) 
    13951350        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength', 
    1396                      dom, 'wavelength', data_info.source) 
     1351                          dom, 'wavelength', data_info.source) 
    13971352        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_min', 
    1398                      dom, 'wavelength_min', data_info.source) 
     1353                          dom, 'wavelength_min', data_info.source) 
    13991354        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_max', 
    1400                      dom, 'wavelength_max', data_info.source) 
     1355                          dom, 'wavelength_max', data_info.source) 
    14011356        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_spread', 
    1402                      dom, 'wavelength_spread', data_info.source) 
    1403          
     1357                          dom, 'wavelength_spread', data_info.source) 
     1358 
    14041359        # Beam size (as a vector) 
    14051360        entry = get_content('ns:SASinstrument/ns:SASsource/ns:beam_size', dom) 
    14061361        if entry is not None: 
    14071362            data_info.source.beam_size_name = entry.get('name') 
    1408              
     1363 
    14091364        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:x', 
    1410                      dom, 'beam_size.x', data_info.source) 
     1365                          dom, 'beam_size.x', data_info.source) 
    14111366        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:y', 
    1412                      dom, 'beam_size.y', data_info.source) 
     1367                          dom, 'beam_size.y', data_info.source) 
    14131368        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:z', 
    1414                      dom, 'beam_size.z', data_info.source) 
    1415          
     1369                          dom, 'beam_size.z', data_info.source) 
     1370 
    14161371        # Collimation info ################### 
    14171372        nodes = dom.xpath('ns:SASinstrument/ns:SAScollimation', 
    … …  
    14221377                collim.name = item.get('name') 
    14231378            self._store_float('ns:length', item, 'length', collim) 
    1424              
     1379 
    14251380            # Look for apertures 
    14261381            apert_list = item.xpath('ns:aperture', 
    … …  
    14281383            for apert in apert_list: 
    14291384                aperture = Aperture() 
    1430                  
     1385 
    14311386                # Get the name and type of the aperture 
    14321387                aperture.name = apert.get('name') 
    14331388                aperture.type = apert.get('type') 
    1434                      
     1389 
    14351390                self._store_float('ns:distance', apert, 'distance', aperture) 
    1436                  
     1391 
    14371392                entry = get_content('ns:size', apert) 
    14381393                if entry is not None: 
    14391394                    aperture.size_name = entry.get('name') 
    1440                  
     1395 
    14411396                self._store_float('ns:size/ns:x', apert, 'size.x', aperture) 
    14421397                self._store_float('ns:size/ns:y', apert, 'size.y', aperture) 
    14431398                self._store_float('ns:size/ns:z', apert, 'size.z', aperture) 
    1444                  
     1399 
    14451400                collim.aperture.append(aperture) 
    1446                  
     1401 
    14471402            data_info.collimation.append(collim) 
    1448          
     1403 
    14491404        # Detector info ###################### 
    14501405        nodes = dom.xpath('ns:SASinstrument/ns:SASdetector', 
    14511406                          namespaces={'ns': CANSAS_NS}) 
    14521407        for item in nodes: 
    1453              
     1408 
    14541409            detector = Detector() 
    1455              
     1410 
    14561411            self._store_content('ns:name', item, 'name', detector) 
    14571412            self._store_float('ns:SDD', item, 'distance', detector) 
    1458              
     1413 
    14591414            # Detector offset (as a vector) 
    14601415            self._store_float('ns:offset/ns:x', item, 'offset.x', detector) 
    14611416            self._store_float('ns:offset/ns:y', item, 'offset.y', detector) 
    14621417            self._store_float('ns:offset/ns:z', item, 'offset.z', detector) 
    1463              
     1418 
    14641419            # Detector orientation (as a vector) 
    14651420            self._store_float('ns:orientation/ns:roll', item, 
    … …  
    14691424            self._store_float('ns:orientation/ns:yaw', item, 
    14701425                              'orientation.z', detector) 
    1471              
     1426 
    14721427            # Beam center (as a vector) 
    14731428            self._store_float('ns:beam_center/ns:x', item, 
    … …  
    14771432            self._store_float('ns:beam_center/ns:z', item, 
    14781433                              'beam_center.z', detector) 
    1479              
     1434 
    14801435            # Pixel size (as a vector) 
    14811436            self._store_float('ns:pixel_size/ns:x', item, 
    … …  
    14851440            self._store_float('ns:pixel_size/ns:z', item, 
    14861441                              'pixel_size.z', detector) 
    1487              
     1442 
    14881443            self._store_float('ns:slit_length', item, 'slit_length', detector) 
    1489              
     1444 
    14901445            data_info.detector.append(detector) 
    14911446 
    … …  
    14971452            self._store_content('ns:date', item, 'date', process) 
    14981453            self._store_content('ns:description', item, 'description', process) 
    1499              
     1454 
    15001455            term_list = item.xpath('ns:term', namespaces={'ns': CANSAS_NS}) 
    15011456            for term in term_list: 
    … …  
    15111466                    self.errors.append(err_mess) 
    15121467                    logging.error(err_mess) 
    1513              
     1468 
    15141469            note_list = item.xpath('ns:SASprocessnote', 
    15151470                                   namespaces={'ns': CANSAS_NS}) 
    … …  
    15171472                if note.text is not None: 
    15181473                    process.notes.append(note.text.strip()) 
    1519              
     1474 
    15201475            data_info.process.append(process) 
    1521              
     1476 
    15221477        # Data info ###################### 
    15231478        nodes = dom.xpath('ns:SASdata', namespaces={'ns': CANSAS_NS}) 
    15241479        if len(nodes) > 1: 
    15251480            raise RuntimeError, "CanSAS reader is not compatible with multiple SASdata entries" 
    1526         
     1481 
    15271482        for entry in nodes: 
    1528             for item in list_of_data_2d_attr: 
     1483            for item in LIST_OF_DATA_2D_ATTR: 
    15291484                #get node 
    15301485                node = get_content('ns:%s' % item[0], entry) 
    1531                 exec "data_info.%s = parse_entry_helper(node, item)" % item[1] 
    1532                      
    1533             for item in list_of_data2d_values: 
     1486                setattr(data_info, item[1], parse_entry_helper(node, item)) 
     1487 
     1488            for item in LIST_OF_DATA_2D_VALUES: 
    15341489                field = get_content('ns:%s' % item[0], entry) 
    1535                 list = [] 
     1490                value_list = [] 
    15361491                if field is not None: 
    1537                     list = [parse_entry_helper(node, item) for node in field] 
    1538                 if len(list) < 2: 
    1539                     exec "data_info.%s = None" % item[0] 
     1492                    value_list = [parse_entry_helper(node, item) for node in field] 
     1493                if len(value_list) < 2: 
     1494                    setattr(data_info, item[0], None) 
    15401495                else: 
    1541                     exec "data_info.%s = numpy.array(list)" % item[0] 
    1542          
     1496                    setattr(data_info, item[0], numpy.array(value_list)) 
     1497 
    15431498        return data_info 
    15441499 
    … …  
    15461501        """ 
    15471502        Load data and P(r) information from a CanSAS XML file. 
    1548          
     1503 
    15491504        :param path: file path 
    1550          
     1505 
    15511506        :return: Data1D object if a single SASentry was found, 
    15521507                    or a list of Data1D objects if multiple entries were found, 
    15531508                    or None of nothing was found 
    1554                      
     1509 
    15551510        :raise RuntimeError: when the file can't be opened 
    15561511        :raise ValueError: when the length of the data vectors are inconsistent 
    1557          
     1512 
    15581513        """ 
    15591514        output = [] 
    … …  
    15631518        try: 
    15641519            if os.path.isfile(path): 
    1565                  
     1520 
    15661521                #TODO: eventually remove the check for .xml once 
    15671522                # the P(r) writer/reader is truly complete. 
    15681523                if  ext in self.ext or \ 
    15691524                    ext == '.xml': 
    1570                      
     1525 
    15711526                    tree = etree.parse(path, parser=etree.ETCompatXMLParser()) 
    15721527                    # Check the format version number 
    … …  
    15811536                            raise 
    15821537                        fitstate = self._parse_state(entry) 
    1583                          
     1538 
    15841539                        #state could be None when .svs file is loaded 
    15851540                        #in this case, skip appending to output 
    … …  
    16081563                    original_fname = state.file[0:max_char] 
    16091564                    state.file = original_fname + ' [' + time_str + ']' 
    1610                       
     1565 
    16111566                    if state is not None and state.is_data is not None: 
    1612                         exec 'output[%d].is_data = state.is_data' % ind 
    1613                       
     1567                        output[ind].is_data = state.is_data 
     1568 
    16141569                    output[ind].filename = state.file 
    16151570                    state.data = output[ind] 
    … …  
    16291584                    self.state = state 
    16301585                return output 
    1631                
    16321586        except: 
    16331587            self.call_back(format=ext) 
    1634             #self.state= state 
    16351588            raise 
    1636             
     1589 
    16371590    def write(self, filename, datainfo=None, fitstate=None): 
    16381591        """ 
    16391592        Write the content of a Data1D as a CanSAS XML file only for standalone 
    1640          
     1593 
    16411594        :param filename: name of the file to write 
    16421595        :param datainfo: Data1D object 
    16431596        :param fitstate: PageState object 
    1644          
     1597 
    16451598        """ 
    16461599        # Sanity check 
    … …  
    16511604        else: 
    16521605            doc = fitstate.toXML(file=filename) 
    1653          
     1606 
    16541607        # Save the document no matter the type 
    16551608        fd = open(filename, 'w') 
    16561609        fd.write(doc.toprettyxml()) 
    16571610        fd.close() 
    1658          
     1611 
    16591612    def write_toXML(self, datainfo=None, state=None): 
    16601613        """ 
    16611614        Write toXML, a helper for write(), 
    16621615        could be used by guimanager._on_save() 
    1663          
     1616 
    16641617        : return: xml doc 
    16651618        """ 
    … …  
    16771630                state.data.run = [str(state.data.name)] 
    16781631                state.data.run_name[0] = state.data.name 
    1679              
     1632 
    16801633            if issubclass(state.data.__class__, 
    16811634                          sas.dataloader.data_info.Data1D): 
    … …  
    16851638                data = state.data 
    16861639                doc, sasentry = self._data2d_to_xml_doc(data) 
    1687              
     1640 
    16881641        if state is not None: 
    16891642            doc = state.toXML(doc=doc, file=data.filename, entry_node=sasentry) 
    1690          
     1643 
    16911644        return doc 
    1692      
     1645 
    16931646# Simple html report templet 
    16941647HEADER = "<html>\n" 
    … …  
    17361689    #state.toXML() 
    17371690    """ 
    1738      
     1691 
    17391692    file = open("test_state", "w") 
    17401693    pickle.dump(state, file) 
    … …  
    17691722    db.keys().sort() 
    17701723    print pickle.loads(db['state2']) 
    1771    
     1724 
    17721725    db.close() 
Note: See TracChangeset for help on using the changeset viewer.