Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    re6de6b8 r6c382da  
    22    Class that holds a fit page state 
    33""" 
    4 # TODO: Refactor code so we don't need to use getattr/setattr 
     4#TODO: Refactor code so we don't need to use getattr/setattr 
    55################################################################################ 
    6 # This software was developed by the University of Tennessee as part of the 
    7 # Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    8 # project funded by the US National Science Foundation. 
     6#This software was developed by the University of Tennessee as part of the 
     7#Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
     8#project funded by the US National Science Foundation. 
    99# 
    10 # See the license text in license.txt 
     10#See the license text in license.txt 
    1111# 
    12 # copyright 2009, University of Tennessee 
     12#copyright 2009, University of Tennessee 
    1313################################################################################ 
    1414import time 
    … …  
    3030from sas.sascalc.dataloader.readers.cansas_reader import Reader as CansasReader 
    3131from sas.sascalc.dataloader.readers.cansas_reader import get_content, write_node 
    32 from sas.sascalc.dataloader.data_info import Data2D, Collimation, Detector 
    33 from sas.sascalc.dataloader.data_info import Process, Aperture 
    34 # Information to read/write state as xml 
     32from sas.sascalc.dataloader.data_info import Data2D 
     33from sas.sascalc.dataloader.data_info import Collimation 
     34from sas.sascalc.dataloader.data_info import Detector 
     35from sas.sascalc.dataloader.data_info import Process 
     36from sas.sascalc.dataloader.data_info import Aperture 
     37#Information to read/write state as xml 
    3538FITTING_NODE_NAME = 'fitting_plug_in' 
    3639CANSAS_NS = "cansas1d/1.0" 
    … …  
    120123            try: 
    121124                return node.get(item[0]).strip() == "True" 
     125 
    122126            except: 
    123127                return None 
    … …  
    142146        """ 
    143147        self.file = None 
    144         # Time of state creation 
     148        #Time of state creation 
    145149        self.timestamp = time.time() 
    146         # Data member to store the dispersion object created 
     150        ## Data member to store the dispersion object created 
    147151        self._disp_obj_dict = {} 
    148         # ------------------------ 
    149         # Data used for fitting 
     152        #------------------------ 
     153        #Data used for fitting 
    150154        self.data = data 
    151155        # model data 
    152156        self.theory_data = None 
    153         # Is 2D 
     157        #Is 2D 
    154158        self.is_2D = False 
    155159        self.images = None 
    156160 
    157         # save additional information on data that dataloader.reader 
    158         # does not read 
     161        #save additional information on data that dataloader.reader does not read 
    159162        self.is_data = None 
    160163        self.data_name = "" 
    … …  
    169172            self.data_group_id = self.data.group_id 
    170173 
    171         # reset True change the state of existing button 
     174        ## reset True change the state of exsiting button 
    172175        self.reset = False 
    173176 
    … …  
    177180        self.model = model 
    178181        self.m_name = None 
    179         # list of process done to model 
     182        #list of process done to model 
    180183        self.process = [] 
    181         # fit page manager 
     184        #fit page manager 
    182185        self.manager = None 
    183         # Store the parent of this panel parent 
     186        #Store the parent of this panel parent 
    184187        # For this application fitpanel is the parent 
    185188        self.parent = parent 
    186189        # Event_owner is the owner of model event 
    187190        self.event_owner = None 
    188         # page name 
     191        ##page name 
    189192        self.page_name = "" 
    190193        # Contains link between model, all its parameters, and panel organization 
    … …  
    193196        self.str_parameters = [] 
    194197        # Contains list of parameters that cannot be fitted and reference to 
    195         # panel objects 
     198        #panel objects 
    196199        self.fixed_param = [] 
    197200        # Contains list of parameters with dispersity and reference to 
    198         # panel objects 
     201        #panel objects 
    199202        self.fittable_param = [] 
    200         # orientation parameters 
     203        ## orientation parameters 
    201204        self.orientation_params = [] 
    202         # orientation parameters for gaussian dispersity 
     205        ## orientation parameters for gaussian dispersity 
    203206        self.orientation_params_disp = [] 
    204         # smearer info 
     207        ## smearer info 
    205208        self.smearer = None 
    206209        self.smear_type = None 
    … …  
    211214        self.dxl = None 
    212215        self.dxw = None 
    213         # list of dispersion parameters 
     216        #list of dispersion parameters 
    214217        self.disp_list = [] 
    215218        if self.model is not None: 
    … …  
    220223        self.weights = {} 
    221224 
    222         # contains link between a model and selected parameters to fit 
     225        #contains link between a model and selected parameters to fit 
    223226        self.param_toFit = [] 
    224         # dictionary of model type and model class 
     227        ##dictionary of model type and model class 
    225228        self.model_list_box = None 
    226         # save the state of the context menu 
     229        ## save the state of the context menu 
    227230        self.saved_states = {} 
    228         # save selection of combobox 
     231        ## save selection of combobox 
    229232        self.formfactorcombobox = None 
    230233        self.categorycombobox = None 
    231234        self.structurecombobox = None 
    232235 
    233         # radio box to select type of model 
    234         # self.shape_rbutton = False 
    235         # self.shape_indep_rbutton = False 
    236         # self.struct_rbutton = False 
    237         # self.plugin_rbutton = False 
    238         # the indice of the current selection 
     236        ## radio box to select type of model 
     237        #self.shape_rbutton = False 
     238        #self.shape_indep_rbutton = False 
     239        #self.struct_rbutton = False 
     240        #self.plugin_rbutton = False 
     241        ## the indice of the current selection 
    239242        self.disp_box = 0 
    240         # Qrange 
    241         # Q range 
     243        ## Qrange 
     244        ## Q range 
    242245        self.qmin = 0.001 
    243246        self.qmax = 0.1 
    244         # reset data range 
     247        #reset data range 
    245248        self.qmax_x = None 
    246249        self.qmin_x = None 
    … …  
    250253        self.multi_factor = None 
    251254        self.magnetic_on = False 
    252         # enable smearering state 
     255        ## enable smearering state 
    253256        self.enable_smearer = False 
    254257        self.disable_smearer = True 
    … …  
    260263        self.dI_sqrdata = False 
    261264        self.dI_idata = False 
    262         # disperity selection 
     265        ## disperity selection 
    263266        self.enable_disp = False 
    264267        self.disable_disp = True 
    265268 
    266         # state of selected all check button 
     269        ## state of selected all check button 
    267270        self.cb1 = False 
    268         # store value of chisqr 
     271        ## store value of chisqr 
    269272        self.tcChi = None 
    270273 
    … …  
    290293        obj.structurecombobox = self.structurecombobox 
    291294 
    292         # obj.shape_rbutton = self.shape_rbutton 
    293         # obj.shape_indep_rbutton = self.shape_indep_rbutton 
    294         # obj.struct_rbutton = self.struct_rbutton 
    295         # obj.plugin_rbutton = self.plugin_rbutton 
     295        #obj.shape_rbutton = self.shape_rbutton 
     296        #obj.shape_indep_rbutton = self.shape_indep_rbutton 
     297        #obj.struct_rbutton = self.struct_rbutton 
     298        #obj.plugin_rbutton = self.plugin_rbutton 
    296299 
    297300        obj.manager = self.manager 
    … …  
    378381 
    379382        rep += "State created: %s\n" % time_str 
    380         rep += "State form factor combobox selection: %s\n" % \ 
    381                self.formfactorcombobox 
    382         rep += "State structure factor combobox selection: %s\n" % \ 
    383                self.structurecombobox 
     383        rep += "State form factor combobox selection: %s\n" % self.formfactorcombobox 
     384        rep += "State structure factor combobox selection: %s\n" % self.structurecombobox 
    384385        rep += "is data : %s\n" % self.is_data 
    385386        rep += "data's name : %s\n" % self.data_name 
    386387        rep += "data's id : %s\n" % self.data_id 
    387         if self.model is not None: 
     388        if self.model != None: 
    388389            m_name = self.model.__class__.__name__ 
    389390            if m_name == 'Model': 
    … …  
    396397        rep += "model type (Category) selected: %s\n" % self.categorycombobox 
    397398        rep += "data : %s\n" % str(self.data) 
    398         rep += "Plotting Range: min: %s, max: %s, steps: %s\n" % \ 
    399                (str(self.qmin),str(self.qmax), str(self.npts)) 
     399        rep += "Plotting Range: min: %s, max: %s, steps: %s\n" % (str(self.qmin), 
     400                                                                  str(self.qmax), str(self.npts)) 
    400401        rep += "Dispersion selection : %s\n" % str(self.disp_box) 
    401402        rep += "Smearing enable : %s\n" % str(self.enable_smearer) 
    … …  
    413414 
    414415        rep += "2D enable : %s\n" % str(self.enable2D) 
    415         rep += "All parameters checkbox selected: %s\n" % str(self.cb1) 
     416        rep += "All parameters checkbox selected: %s\n" % (self.cb1) 
    416417        rep += "Value of Chisqr : %s\n" % str(self.tcChi) 
    417418        rep += "Smear object : %s\n" % str(self.smearer) 
    418         rep += "Smear type : %s\n" % str(self.smear_type) 
     419        rep += "Smear type : %s\n" % (self.smear_type) 
    419420        rep += "dq_l  : %s\n" % self.dq_l 
    420421        rep += "dq_r  : %s\n" % self.dq_r 
    … …  
    433434            if not self.is_2D: 
    434435                for item in self.parameters: 
    435                     if item not in self.orientation_params: 
     436                    if not item in self.orientation_params: 
    436437                        temp_parameters.append(item) 
    437438                for item in self.fittable_param: 
    438                     if item not in self.orientation_params_disp: 
     439                    if not item in self.orientation_params_disp: 
    439440                        temp_fittable_param.append(item) 
    440441            else: 
    … …  
    442443                temp_fittable_param = self.fittable_param 
    443444 
    444             rep += "number parameters(self.parameters): %s\n" % \ 
    445                    len(temp_parameters) 
     445            rep += "number parameters(self.parameters): %s\n" % len(temp_parameters) 
    446446            rep = self._repr_helper(list=temp_parameters, rep=rep) 
    447             rep += "number str_parameters(self.str_parameters): %s\n" % \ 
    448                    len(self.str_parameters) 
     447            rep += "number str_parameters(self.str_parameters): %s\n" % len(self.str_parameters) 
    449448            rep = self._repr_helper(list=self.str_parameters, rep=rep) 
    450             rep += "number fittable_param(self.fittable_param): %s\n" % \ 
    451                    len(temp_fittable_param) 
     449            rep += "number fittable_param(self.fittable_param): %s\n" % len(temp_fittable_param) 
    452450            rep = self._repr_helper(list=temp_fittable_param, rep=rep) 
    453451        return rep 
    … …  
    553551                    paramval_string += CENTRE % param + "\n" 
    554552 
    555         text_string = "\n\n\n%s\n\n%s\n%s\n%s\n\n%s" % \ 
    556                       (title, file, q_name, chi2, paramval) 
     553        text_string = "\n\n\n%s\n\n%s\n%s\n%s\n\n%s" % (title, file, q_name, chi2, paramval) 
    557554 
    558555        title_name = self._check_html_format(title_name) 
    … …  
    635632            element.appendChild(sub_element) 
    636633 
    637     def toXML(self, file="fitting_state.fitv", doc=None, 
    638               entry_node=None, batch_fit_state=None): 
    639         """ 
    640         Writes the state of the fit panel to file, as XML. 
     634    def toXML(self, file="fitting_state.fitv", doc=None, entry_node=None): 
     635        """ 
     636        Writes the state of the InversionControl panel to file, as XML. 
    641637 
    642638        Compatible with standalone writing, or appending to an 
    643         already existing XML document. In that case, the XML document is 
    644         required. An optional entry node in the XML document may also be given. 
     639        already existing XML document. In that case, the XML document 
     640        is required. An optional entry node in the XML document may also be given. 
    645641 
    646642        :param file: file to write to 
    647643        :param doc: XML document object [optional] 
    648         :param entry_node: XML node within the XML document at which we 
    649                            will append the data [optional] 
     644        :param entry_node: XML node within the XML document at which we will append the data [optional] 
     645 
    650646        """ 
    651647        from xml.dom.minidom import getDOMImplementation 
    … …  
    695691        element.setAttributeNode(attr) 
    696692        top_element.appendChild(element) 
    697  
    698693        # Inputs 
    699694        inputs = newdoc.createElement("Attributes") 
    … …  
    746741        for item in LIST_OF_STATE_PARAMETERS: 
    747742            element = newdoc.createElement(item[0]) 
    748             self._toXML_helper(thelist=getattr(self, item[1]), 
    749                                element=element, newdoc=newdoc) 
     743            self._toXML_helper(thelist=getattr(self, item[1]), element=element, newdoc=newdoc) 
    750744            inputs.appendChild(element) 
    751  
    752         # Combined and Simultaneous Fit Parameters 
    753         if batch_fit_state is not None: 
    754             batch_combo = newdoc.createElement('simultaneous_fit') 
    755             top_element.appendChild(batch_combo) 
    756  
    757             # Simultaneous Fit Number For Linking Later 
    758             element = newdoc.createElement('sim_fit_number') 
    759             element.setAttribute('fit_number', str(batch_fit_state.fit_page_no)) 
    760             batch_combo.appendChild(element) 
    761  
    762             # Save constraints 
    763             constraints = newdoc.createElement('constraints') 
    764             batch_combo.appendChild(constraints) 
    765             for constraint in batch_fit_state.constraints_list: 
    766                 if constraint.model_cbox.GetValue() != "": 
    767                     # model_cbox, param_cbox, egal_txt, constraint, btRemove, sizer 
    768                     doc_cons = newdoc.createElement('constraint') 
    769                     doc_cons.setAttribute('model_cbox', 
    770                                           str(constraint.model_cbox.GetValue())) 
    771                     doc_cons.setAttribute('param_cbox', 
    772                                           str(constraint.param_cbox.GetValue())) 
    773                     doc_cons.setAttribute('egal_txt', 
    774                                           str(constraint.egal_txt.GetLabel())) 
    775                     doc_cons.setAttribute('constraint', 
    776                                           str(constraint.constraint.GetValue())) 
    777                     constraints.appendChild(doc_cons) 
    778  
    779             # Save all models 
    780             models = newdoc.createElement('model_list') 
    781             batch_combo.appendChild(models) 
    782             for model in batch_fit_state.model_list: 
    783                 doc_model = newdoc.createElement('model_list_item') 
    784                 doc_model.setAttribute('checked', str(model[0].GetValue())) 
    785                 keys = model[1].keys() 
    786                 doc_model.setAttribute('name', str(keys[0])) 
    787                 values = model[1].get(keys[0]) 
    788                 doc_model.setAttribute('fit_number', str(model[2])) 
    789                 doc_model.setAttribute('fit_page_source', str(model[3])) 
    790                 doc_model.setAttribute('model_name', str(values.model.id)) 
    791                 models.appendChild(doc_model) 
    792  
    793             # Select All Checkbox 
    794             element = newdoc.createElement('select_all') 
    795             if batch_fit_state.select_all: 
    796                 element.setAttribute('checked', 'True') 
    797             else: 
    798                 element.setAttribute('checked', 'False') 
    799             batch_combo.appendChild(element) 
    800745 
    801746        # Save the file 
    … …  
    864809        :param file: .fitv file 
    865810        :param node: node of a XML document to read from 
     811 
    866812        """ 
    867813        if file is not None: 
    … …  
    870816            raise RuntimeError, msg 
    871817 
    872         if node.get('version') and node.get('version') == '1.0': 
     818        if node.get('version')and node.get('version') == '1.0': 
    873819 
    874820            # Get file name 
    … …  
    916862                                value = cls.type 
    917863                            except Exception: 
    918                                 base = "unable to load distribution %r for %s" 
    919                                 logging.error(base % (value, parameter)) 
     864                                logging.error("unable to load distribution %r for %s" 
     865                                              % (value, parameter)) 
    920866                                continue 
    921867                        _disp_obj_dict = getattr(self, varname) 
    … …  
    1014960        self.cansas = cansas 
    1015961        self.state = None 
    1016         # batch fitting params for saving 
    1017         self.batchfit_params = [] 
    1018962 
    1019963    def get_state(self): 
    … …  
    1040984            raise RuntimeError, "The cansas writer expects a Data2D instance" 
    1041985 
    1042         title = "cansas1d/%s" % self.version 
    1043         title += "http://svn.smallangles.net/svn/canSAS/1dwg/trunk/cansas1d.xsd" 
    1044986        doc = xml.dom.minidom.Document() 
    1045987        main_node = doc.createElement("SASroot") 
    1046988        main_node.setAttribute("version", self.version) 
    1047989        main_node.setAttribute("xmlns", "cansas1d/%s" % self.version) 
    1048         main_node.setAttribute("xmlns:xsi", 
    1049                                "http://www.w3.org/2001/XMLSchema-instance") 
    1050         main_node.setAttribute("xsi:schemaLocation", title) 
     990        main_node.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance") 
     991        main_node.setAttribute("xsi:schemaLocation", 
     992                               "cansas1d/%s http://svn.smallangles.net/svn/canSAS/1dwg/trunk/cansas1d.xsd" % self.version) 
    1051993 
    1052994        doc.appendChild(main_node) 
    … …  
    1057999        write_node(doc, entry_node, "Title", datainfo.title) 
    10581000        if datainfo is not None: 
    1059             write_node(doc, entry_node, "data_class", 
    1060                        datainfo.__class__.__name__) 
     1001            write_node(doc, entry_node, "data_class", datainfo.__class__.__name__) 
    10611002        for item in datainfo.run: 
    10621003            runname = {} 
    1063             if datainfo.run_name.has_key(item) and \ 
    1064                             len(str(datainfo.run_name[item])) > 1: 
     1004            if datainfo.run_name.has_key(item) and len(str(datainfo.run_name[item])) > 1: 
    10651005                runname = {'name': datainfo.run_name[item]} 
    10661006            write_node(doc, entry_node, "Run", item, runname) 
    … …  
    12791219 
    12801220        :param entry: XML node to read from 
     1221 
    12811222        :return: PageState object 
    12821223        """ 
    … …  
    12871228            nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME, 
    12881229                                namespaces={'ns': CANSAS_NS}) 
    1289             if nodes: 
     1230            if nodes != []: 
    12901231                # Create an empty state 
    12911232                state = PageState() 
    … …  
    12971238 
    12981239        return state 
    1299  
    1300     def _parse_simfit_state(self, entry): 
    1301         """ 
    1302         Parses the saved data for a simultaneous fit 
    1303         :param entry: XML object to read from 
    1304         :return: XML object for a simultaneous fit or None 
    1305         """ 
    1306         nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME, 
    1307                             namespaces={'ns': CANSAS_NS}) 
    1308         if nodes: 
    1309             simfitstate = nodes[0].xpath('ns:simultaneous_fit', 
    1310                                          namespaces={'ns': CANSAS_NS}) 
    1311             if simfitstate: 
    1312                 from simfitpage import SimFitPageState 
    1313                 sim_fit_state = SimFitPageState() 
    1314                 simfitstate_0 = simfitstate[0] 
    1315                 all = simfitstate_0.xpath('ns:select_all', 
    1316                                         namespaces={'ns': CANSAS_NS}) 
    1317                 atts = all[0].attrib 
    1318                 checked = atts.get('checked') 
    1319                 sim_fit_state.select_all = bool(checked) 
    1320                 model_list = simfitstate_0.xpath('ns:model_list', 
    1321                                                namespaces={'ns': CANSAS_NS}) 
    1322                 model_list_items = model_list[0].xpath('ns:model_list_item', 
    1323                                                    namespaces={'ns': CANSAS_NS}) 
    1324                 for model in model_list_items: 
    1325                     attrs = model.attrib 
    1326                     sim_fit_state.model_list.append(attrs) 
    1327  
    1328                 constraints = simfitstate_0.xpath('ns:constraints', 
    1329                                                 namespaces={'ns': CANSAS_NS}) 
    1330                 constraint_list = constraints[0].xpath('ns:constraint', 
    1331                                                namespaces={'ns': CANSAS_NS}) 
    1332                 for constraint in constraint_list: 
    1333                     attrs = constraint.attrib 
    1334                     sim_fit_state.constraints_list.append(attrs) 
    1335  
    1336                 return sim_fit_state 
    1337             else: 
    1338                 return None 
    13391240 
    13401241    def _parse_save_state_entry(self, dom): 
    … …  
    13971298                        data_info.notes.append(note_value) 
    13981299            except Exception: 
    1399                 err_mess = "cansas_reader.read: error processing entry notes\n" 
    1400                 err_mess += "  %s" % sys.exc_value 
     1300                err_mess = "cansas_reader.read: error processing entry notes\n  %s" % sys.exc_value 
    14011301                self.errors.append(err_mess) 
    14021302                logging.error(err_mess) 
    … …  
    14081308 
    14091309        self._store_content('ns:SASsample/ns:ID', dom, 'ID', data_info.sample) 
    1410         self._store_float('ns:SASsample/ns:thickness', dom, 'thickness', 
    1411                           data_info.sample) 
    1412         self._store_float('ns:SASsample/ns:transmission', dom, 'transmission', 
    1413                           data_info.sample) 
    1414         self._store_float('ns:SASsample/ns:temperature', dom, 'temperature', 
    1415                           data_info.sample) 
    1416  
    1417         nodes = dom.xpath('ns:SASsample/ns:details', 
    1418                           namespaces={'ns': CANSAS_NS}) 
     1310        self._store_float('ns:SASsample/ns:thickness', dom, 'thickness', data_info.sample) 
     1311        self._store_float('ns:SASsample/ns:transmission', dom, 'transmission', data_info.sample) 
     1312        self._store_float('ns:SASsample/ns:temperature', dom, 'temperature', data_info.sample) 
     1313 
     1314        nodes = dom.xpath('ns:SASsample/ns:details', namespaces={'ns': CANSAS_NS}) 
    14191315        for item in nodes: 
    14201316            try: 
    … …  
    14241320                        data_info.sample.details.append(detail_value) 
    14251321            except Exception: 
    1426                 err_mess = "cansas_reader.read: error processing entry notes\n" 
    1427                 err_mess += "  %s" % sys.exc_value 
     1322                err_mess = "cansas_reader.read: error processing sample details\n  %s" % sys.exc_value 
    14281323                self.errors.append(err_mess) 
    14291324                logging.error(err_mess) 
    14301325 
    14311326        # Position (as a vector) 
    1432         self._store_float('ns:SASsample/ns:position/ns:x', dom, 'position.x', 
    1433                           data_info.sample) 
    1434         self._store_float('ns:SASsample/ns:position/ns:y', dom, 'position.y', 
    1435                           data_info.sample) 
    1436         self._store_float('ns:SASsample/ns:position/ns:z', dom, 'position.z', 
    1437                           data_info.sample) 
     1327        self._store_float('ns:SASsample/ns:position/ns:x', dom, 'position.x', data_info.sample) 
     1328        self._store_float('ns:SASsample/ns:position/ns:y', dom, 'position.y', data_info.sample) 
     1329        self._store_float('ns:SASsample/ns:position/ns:z', dom, 'position.z', data_info.sample) 
    14381330 
    14391331        # Orientation (as a vector) 
    … …  
    15691461                        process.term.append(term_attr) 
    15701462                except: 
    1571                     err_mess = "cansas_reader.read: error processing " 
    1572                     err_mess += "entry notes\n  %s" % sys.exc_value 
     1463                    err_mess = "cansas_reader.read: error processing process term\n  %s" % sys.exc_value 
    15731464                    self.errors.append(err_mess) 
    15741465                    logging.error(err_mess) 
    … …  
    15851476        nodes = dom.xpath('ns:SASdata', namespaces={'ns': CANSAS_NS}) 
    15861477        if len(nodes) > 1: 
    1587             raise RuntimeError, "CanSAS reader is not compatible with" + \ 
    1588                                 " multiple SASdata entries" 
     1478            raise RuntimeError, "CanSAS reader is not compatible with multiple SASdata entries" 
    15891479 
    15901480        for entry in nodes: 
    … …  
    15981488                value_list = [] 
    15991489                if field is not None: 
    1600                     value_list = \ 
    1601                         [parse_entry_helper(node, item) for node in field] 
     1490                    value_list = [parse_entry_helper(node, item) for node in field] 
    16021491                if len(value_list) < 2: 
    16031492                    setattr(data_info, item[0], None) 
    … …  
    16091498    def _read_cansas(self, path): 
    16101499        """ 
    1611         Load data and fitting information from a CanSAS XML file. 
     1500        Load data and P(r) information from a CanSAS XML file. 
    16121501 
    16131502        :param path: file path 
     1503 
    16141504        :return: Data1D object if a single SASentry was found, 
    16151505                    or a list of Data1D objects if multiple entries were found, 
    16161506                    or None of nothing was found 
     1507 
    16171508        :raise RuntimeError: when the file can't be opened 
    16181509        :raise ValueError: when the length of the data vectors are inconsistent 
     1510 
    16191511        """ 
    16201512        output = [] 
    1621         simfitstate = None 
    16221513        basename = os.path.basename(path) 
    16231514        root, extension = os.path.splitext(basename) 
    … …  
    16251516        try: 
    16261517            if os.path.isfile(path): 
    1627                 if ext in self.ext or ext == '.xml': 
     1518 
     1519                #TODO: eventually remove the check for .xml once 
     1520                # the P(r) writer/reader is truly complete. 
     1521                if  ext in self.ext or \ 
     1522                    ext == '.xml': 
     1523 
    16281524                    tree = etree.parse(path, parser=etree.ETCompatXMLParser()) 
    16291525                    # Check the format version number 
    1630                     # Specifying the namespace will take care of the file 
    1631                     # format version 
     1526                    # Specifying the namespace will take care of the file format version 
    16321527                    root = tree.getroot() 
    16331528                    entry_list = root.xpath('ns:SASentry', 
    16341529                                            namespaces={'ns': CANSAS_NS}) 
    1635                     name_map = {} 
    16361530                    for entry in entry_list: 
    16371531                        try: 
    … …  
    16411535                        fitstate = self._parse_state(entry) 
    16421536 
    1643                         # state could be None when .svs file is loaded 
    1644                         # in this case, skip appending to output 
    1645                         if fitstate is not None: 
     1537                        #state could be None when .svs file is loaded 
     1538                        #in this case, skip appending to output 
     1539                        if fitstate != None: 
    16461540                            sas_entry.meta_data['fitstate'] = fitstate 
    16471541                            sas_entry.filename = fitstate.file 
    16481542                            output.append(sas_entry) 
    1649  
    16501543            else: 
    16511544                self.call_back(format=ext) 
    … …  
    16871580                        name = original_fname 
    16881581                    state.data.group_id = name 
    1689                     # store state in fitting 
     1582                    #store state in fitting 
    16901583                    self.call_back(state=state, 
    16911584                                   datainfo=output[ind], format=ext) 
    16921585                    self.state = state 
    1693                 simfitstate = self._parse_simfit_state(entry) 
    1694                 if simfitstate is not None: 
    1695                     self.call_back(state=simfitstate) 
    1696  
    16971586                return output 
    16981587        except: 
    … …  
    17101599        """ 
    17111600        # Sanity check 
    1712         if self.cansas: 
     1601        if self.cansas == True: 
    17131602            # Add fitting information to the XML document 
    17141603            doc = self.write_toXML(datainfo, fitstate) 
    … …  
    17221611        fd.close() 
    17231612 
    1724     def write_toXML(self, datainfo=None, state=None, batchfit=None): 
     1613    def write_toXML(self, datainfo=None, state=None): 
    17251614        """ 
    17261615        Write toXML, a helper for write(), 
    … …  
    17301619        """ 
    17311620 
    1732         self.batchfit_params = batchfit 
    1733         if state.data is None or not state.data.is_data: 
     1621        if state.data is None: 
     1622            data = sas.sascalc.dataloader.data_info.Data1D(x=[], y=[]) 
    17341623            return None 
    1735         # make sure title and data run are filled. 
    1736         if state.data.title is None or state.data.title == '': 
    1737             state.data.title = state.data.name 
    1738         if state.data.run_name is None or state.data.run_name == {}: 
    1739             state.data.run = [str(state.data.name)] 
    1740             state.data.run_name[0] = state.data.name 
    1741  
    1742         if issubclass(state.data.__class__, 
    1743                       sas.sascalc.dataloader.data_info.Data1D): 
    1744             data = state.data 
    1745             doc, sasentry = self._to_xml_doc(data) 
     1624        elif not state.data.is_data: 
     1625            return None 
    17461626        else: 
    1747             data = state.data 
    1748             doc, sasentry = self._data2d_to_xml_doc(data) 
     1627            #make sure title and data run is filled up. 
     1628            if state.data.title == None or state.data.title == '': 
     1629                state.data.title = state.data.name 
     1630            if state.data.run_name == None or state.data.run_name == {}: 
     1631                state.data.run = [str(state.data.name)] 
     1632                state.data.run_name[0] = state.data.name 
     1633 
     1634            if issubclass(state.data.__class__, 
     1635                          sas.sascalc.dataloader.data_info.Data1D): 
     1636                data = state.data 
     1637                doc, sasentry = self._to_xml_doc(data) 
     1638            else: 
     1639                data = state.data 
     1640                doc, sasentry = self._data2d_to_xml_doc(data) 
    17491641 
    17501642        if state is not None: 
    1751             doc = state.toXML(doc=doc, file=data.filename, entry_node=sasentry, 
    1752                               batch_fit_state=self.batchfit_params) 
     1643            doc = state.toXML(doc=doc, file=data.filename, entry_node=sasentry) 
    17531644 
    17541645        return doc 
     1646 
     1647# Simple html report templet 
     1648HEADER = "<html>\n" 
     1649HEADER += "<head>\n" 
     1650HEADER += "<meta http-equiv=Content-Type content='text/html; " 
     1651HEADER += "charset=windows-1252'> \n" 
     1652HEADER += "<meta name=Generator >\n" 
     1653HEADER += "</head>\n" 
     1654HEADER += "<body lang=EN-US>\n" 
     1655HEADER += "<div class=WordSection1>\n" 
     1656HEADER += "<p class=MsoNormal><b><span ><center><font size='4' >" 
     1657HEADER += "%s</font></center></span></center></b></p>" 
     1658HEADER += "<p class=MsoNormal>&nbsp;</p>" 
     1659PARA = "<p class=MsoNormal><font size='4' > %s \n" 
     1660PARA += "</font></p>" 
     1661CENTRE = "<p class=MsoNormal><center><font size='4' > %s \n" 
     1662CENTRE += "</font></center></p>" 
     1663FEET_1 = \ 
     1664""" 
     1665<p class=MsoNormal>&nbsp;</p> 
     1666<br> 
     1667<p class=MsoNormal><b><span ><center> <font size='4' > Graph 
     1668</font></span></center></b></p> 
     1669<p class=MsoNormal>&nbsp;</p> 
     1670<center> 
     1671<br><font size='4' >Model Computation</font> 
     1672<br><font size='4' >Data: "%s"</font><br> 
     1673""" 
     1674FEET_2 = \ 
     1675""" 
     1676<img src="%s" > 
     1677</img> 
     1678""" 
     1679FEET_3 = \ 
     1680""" 
     1681</center> 
     1682</div> 
     1683</body> 
     1684</html> 
     1685""" 
     1686ELINE = "<p class=MsoNormal>&nbsp;</p>" 
     1687 
     1688if __name__ == "__main__": 
     1689    state = PageState(parent=None) 
     1690    #state.toXML() 
     1691    """ 
     1692 
     1693    file = open("test_state", "w") 
     1694    pickle.dump(state, file) 
     1695    print pickle.dumps(state) 
     1696    state.data_name = "hello---->" 
     1697    pickle.dump(state, file) 
     1698    file = open("test_state", "r") 
     1699    new_state= pickle.load(file) 
     1700    print "new state", new_state 
     1701    new_state= pickle.load(file) 
     1702    print "new state", new_state 
     1703    #print "state", state 
     1704    """ 
     1705    import bsddb 
     1706    import pickle 
     1707    db = bsddb.btopen('file_state.db', 'c') 
     1708    val = (pickle.dumps(state), "hello", "hi") 
     1709    db['state1'] = pickle.dumps(val) 
     1710    print pickle.loads(db['state1']) 
     1711    state.data_name = "hello---->22" 
     1712    db['state2'] = pickle.dumps(state) 
     1713    state.data_name = "hello---->2" 
     1714    db['state3'] = pickle.dumps(state) 
     1715    del db['state3'] 
     1716    state.data_name = "hello---->3" 
     1717    db['state4'] = pickle.dumps(state) 
     1718    new_state = pickle.loads(db['state1']) 
     1719    #print db.last() 
     1720    db.set_location('state2') 
     1721    state.data_name = "hello---->5" 
     1722    db['aastate5'] = pickle.dumps(state) 
     1723    db.keys().sort() 
     1724    print pickle.loads(db['state2']) 
     1725 
     1726    db.close() 
Note: See TracChangeset for help on using the changeset viewer.