Ignore:
Timestamp:
Mar 4, 2015 3:39:45 PM (10 years ago)
Author:
Doucet, Mathieu <doucetm@…>
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:
74f419d
Parents:
2f732b0
Message:

Take care of white spaces (pylint)

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    rd838715 r2f4b430  
    4545                      ["qmax", "qmax", "float"], 
    4646                      ["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"], 
    5147                      ["categorycombobox", "categorycombobox", "string"], 
    5248                      ["formfactorcombobox", "formfactorcombobox", "string"], 
    5349                      ["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"], 
     50                      ["multi_factor", "multi_factor", "float"], 
     51                      ["magnetic_on", "magnetic_on", "bool"], 
     52                      ["enable_smearer", "enable_smearer", "bool"], 
     53                      ["disable_smearer", "disable_smearer", "bool"], 
     54                      ["pinhole_smearer", "pinhole_smearer", "bool"], 
     55                      ["slit_smearer", "slit_smearer", "bool"], 
     56                      ["enable_disp", "enable_disp", "bool"], 
     57                      ["disable_disp", "disable_disp", "bool"], 
     58                      ["dI_noweight", "dI_noweight", "bool"], 
     59                      ["dI_didata", "dI_didata", "bool"], 
     60                      ["dI_sqrdata", "dI_sqrdata", "bool"], 
     61                      ["dI_idata", "dI_idata", "bool"], 
     62                      ["enable2D", "enable2D", "bool"], 
     63                      ["cb1", "cb1", "bool"], 
     64                      ["tcChi", "tcChi", "float"], 
    6965                      ["smearer", "smearer", "float"], 
    70                       ["smear_type","smear_type", "string"], 
     66                      ["smear_type", "smear_type", "string"], 
    7167                      ["dq_l", "dq_l", "string"], 
    72                       ["dq_r","dq_r", "string"], 
     68                      ["dq_r", "dq_r", "string"], 
    7369                      ["dx_max", "dx_max", "float"], 
    74                       ["dx_min","dx_min", "float"], 
     70                      ["dx_min", "dx_min", "float"], 
    7571                      ["dxl", "dxl", "float"], 
    76                       ["dxw","dxw", "float"]] 
     72                      ["dxw", "dxw", "float"]] 
    7773 
    7874list_of_model_attributes = [["values", "values"], 
    … …  
    110106    """ 
    111107    Create a numpy list from value extrated from the node 
    112      
     108 
    113109    :param node: node from each the value is stored 
    114110    :param item: list name of three strings.the two first are name of data 
    115111        attribute and the third one is the type of the value of that 
    116112        attribute. type can be string, float, bool, etc. 
    117      
     113 
    118114    : return: numpy array 
    119115    """ 
    … …  
    124120            try: 
    125121                return node.get(item[0]).strip() == "True" 
    126                  
     122 
    127123            except: 
    128124                return None 
    … …  
    132128            except: 
    133129                return None 
    134              
    135              
     130 
     131 
    136132class PageState(object): 
    137133    """ 
    … …  
    141137        """ 
    142138        Initialize the current state 
    143          
     139 
    144140        :param model: a selected model within a page 
    145141        :param data: 
    146          
     142 
    147143        """ 
    148144        self.file = None 
    … …  
    159155        self.is_2D = False 
    160156        self.images = None 
    161          
     157 
    162158        #save additional information on data that dataloader.reader does not read 
    163159        self.is_data = None 
    … …  
    172168        if self.data is not None and hasattr(self.data, "group_id"): 
    173169            self.data_group_id = self.data.group_id 
    174          
     170 
    175171        ## reset True change the state of exsiting button 
    176172        self.reset = False 
    177         
     173 
    178174        #engine type 
    179175        self.engine_type = None 
    … …  
    225221        self.values = {} 
    226222        self.weights = {} 
    227                      
     223 
    228224        #contains link between a model and selected parameters to fit 
    229225        self.param_toFit = [] 
    … …  
    251247        self.qmax_x = None 
    252248        self.qmin_x = None 
    253          
     249 
    254250        self.npts = None 
    255251        self.name = "" 
    … …  
    269265        self.enable_disp = False 
    270266        self.disable_disp = True 
    271         
     267 
    272268        ## state of selected all check button 
    273269        self.cb1 = False 
    274270        ## store value of chisqr 
    275271        self.tcChi = None 
    276      
     272 
    277273    def clone(self): 
    278274        """ 
    … …  
    292288        obj.model_list_box = copy.deepcopy(self.model_list_box) 
    293289        obj.engine_type = copy.deepcopy(self.engine_type) 
    294          
     290 
    295291        obj.categorycombobox = self.categorycombobox 
    296292        obj.formfactorcombobox = self.formfactorcombobox 
    297293        obj.structurecombobox = self.structurecombobox 
    298          
     294 
    299295        #obj.shape_rbutton = self.shape_rbutton 
    300296        #obj.shape_indep_rbutton = self.shape_indep_rbutton 
    301297        #obj.struct_rbutton = self.struct_rbutton 
    302298        #obj.plugin_rbutton = self.plugin_rbutton 
    303          
     299 
    304300        obj.manager = self.manager 
    305301        obj.event_owner = self.event_owner 
    306302        obj.disp_list = copy.deepcopy(self.disp_list) 
    307          
     303 
    308304        obj.enable2D = copy.deepcopy(self.enable2D) 
    309305        obj.parameters = copy.deepcopy(self.parameters) 
    … …  
    316312        obj.disable_disp = copy.deepcopy(self.disable_disp) 
    317313        obj.tcChi = self.tcChi 
    318    
     314 
    319315        if len(self._disp_obj_dict) > 0: 
    320316            for k, v in self._disp_obj_dict.iteritems(): 
    … …  
    343339        obj.dx_min = copy.deepcopy(self.dx_min) 
    344340        obj.dxl = copy.deepcopy(self.dxl) 
    345         obj.dxw = copy.deepcopy(self.dxw)         
     341        obj.dxw = copy.deepcopy(self.dxw) 
    346342        obj.disp_box = copy.deepcopy(self.disp_box) 
    347343        obj.qmin = copy.deepcopy(self.qmin) 
    … …  
    352348        obj.cb1 = copy.deepcopy(self.cb1) 
    353349        obj.smearer = copy.deepcopy(self.smearer) 
    354          
     350 
    355351        for name, state in self.saved_states.iteritems(): 
    356352            copy_name = copy.deepcopy(name) 
    … …  
    358354            obj.saved_states[copy_name] = copy_state 
    359355        return obj 
    360      
     356 
    361357    def _repr_helper(self, list, rep): 
    362358        """ 
    … …  
    375371            rep += "parameter unit: %s\n\n" % str(item[7]) 
    376372        return rep 
    377      
     373 
    378374    def __repr__(self): 
    379375        """ 
    … …  
    399395        #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 
    403399        #rep += "model type (shape independent) selected: %s\n" % self.shape_indep_rbutton 
    … …  
    415411        rep += "Dispersity disable : %s\n" % str(self.disable_disp) 
    416412        rep += "Slit smearer enable: %s\n" % str(self.slit_smearer) 
    417          
     413 
    418414        rep += "dI_noweight : %s\n" % str(self.dI_noweight) 
    419415        rep += "dI_didata : %s\n" % str(self.dI_didata) 
    420416        rep += "dI_sqrdata : %s\n" % str(self.dI_sqrdata) 
    421417        rep += "dI_idata : %s\n" % str(self.dI_idata) 
    422          
     418 
    423419        rep += "2D enable : %s\n" % str(self.enable2D) 
    424420        rep += "All parameters checkbox selected: %s\n" % (self.cb1) 
    … …  
    429425        rep += "dq_r  : %s\n" % self.dq_r 
    430426        rep += "dx_max  : %s\n" % str(self.dx_max) 
    431         rep += "dx_min : %s\n" % str(self.dx_min)   
     427        rep += "dx_min : %s\n" % str(self.dx_min) 
    432428        rep += "dxl  : %s\n" % str(self.dxl) 
    433         rep += "dxw : %s\n" % str(self.dxw)     
     429        rep += "dxw : %s\n" % str(self.dxw) 
    434430        rep += "model  : %s\n\n" % str(self.model) 
    435431        temp_parameters = [] 
    … …  
    450446                temp_parameters = self.parameters 
    451447                temp_fittable_param = self.fittable_param 
    452                  
     448 
    453449            rep += "number parameters(self.parameters): %s\n" % len(temp_parameters) 
    454450            rep = self._repr_helper(list=temp_parameters, rep=rep) 
    … …  
    550546                    modelname = "Model name:" + " NAN" 
    551547                model_name = CENTRE % modelname 
    552                   
     548 
    553549            if name == "Plotting Range": 
    554550                try: 
    … …  
    572568                    paramval += param + "\n" 
    573569                    paramval_string += CENTRE % param + "\n" 
    574          
     570 
    575571        text_string = "\n\n\n" + title + "\n\n" + file + \ 
    576572                      "\n" + q_name + \ 
    577573                      "\n" + chi2 + \ 
    578574                      "\n\n" + paramval 
    579          
     575 
    580576        title_name = self._check_html_format(title_name) 
    581577        file_name = self._check_html_format(file_name) 
    582578        title = self._check_html_format(title) 
    583                                    
     579 
    584580        html_string = title_name + "\n" + file_name + \ 
    585581                                   "\n" + model_name + \ 
    … …  
    591587                                   "\n" + FEET_1 % title + \ 
    592588                                   "\n" + FEET_2 
    593                                                                        
     589 
    594590        return html_string, text_string, title 
    595      
     591 
    596592    def _check_html_format(self, name): 
    597593        """ 
    … …  
    600596        if name.count('%'): 
    601597            name = name.replace('%', '&#37') 
    602          
     598 
    603599        return name 
    604      
     600 
    605601    def report(self, figs=None, canvases=None): 
    606602        """ 
    607603        Invoke report dialog panel 
    608          
     604 
    609605        : param figs: list of pylab figures [list] 
    610606        """ 
    … …  
    638634        dialog = ReportDialog(report_list, None, -1, "") 
    639635        dialog.Show() 
    640          
     636 
    641637    def _toXML_helper(self, thelist, element, newdoc): 
    642638        """ 
    … …  
    656652            sub_element.setAttribute('unit', str(item[7])) 
    657653            element.appendChild(sub_element) 
    658          
     654 
    659655    def toXML(self, file="fitting_state.fitv", doc=None, entry_node=None): 
    660656        """ 
    661657        Writes the state of the InversionControl panel to file, as XML. 
    662          
     658 
    663659        Compatible with standalone writing, or appending to an 
    664660        already existing XML document. In that case, the XML document 
    665661        is required. An optional entry node in the XML document may also be given. 
    666          
     662 
    667663        :param file: file to write to 
    668664        :param doc: XML document object [optional] 
    669665        :param entry_node: XML node within the XML document at which we will append the data [optional] 
    670          
     666 
    671667        """ 
    672668        from xml.dom.minidom import getDOMImplementation 
    … …  
    697693                    entry_node = node_list.item(0) 
    698694                    entry_node.appendChild(top_element) 
    699                      
     695 
    700696        attr = newdoc.createAttribute("version") 
    701697        attr.nodeValue = '1.0' 
    702698        top_element.setAttributeNode(attr) 
    703          
     699 
    704700        # File name 
    705701        element = newdoc.createElement("filename") 
    … …  
    709705            element.appendChild(newdoc.createTextNode(str(file))) 
    710706        top_element.appendChild(element) 
    711          
     707 
    712708        element = newdoc.createElement("timestamp") 
    713709        element.appendChild(newdoc.createTextNode(time.ctime(self.timestamp))) 
    … …  
    719715        inputs = newdoc.createElement("Attributes") 
    720716        top_element.appendChild(inputs) 
    721         
     717 
    722718        if self.data is not None and hasattr(self.data, "group_id"): 
    723719            self.data_group_id = self.data.group_id 
    … …  
    728724        if self.data is not None and hasattr(self.data, "id"): 
    729725            self.data_id = self.data.id 
    730         
     726 
    731727        for item in list_of_data_attributes: 
    732728            element = newdoc.createElement(item[0]) 
    733729            exec "element.setAttribute(item[0], str(self.%s))" % (item[1]) 
    734730            inputs.appendChild(element) 
    735          
     731 
    736732        for item in list_of_state_attributes: 
    737733            element = newdoc.createElement(item[0]) 
    738734            exec "element.setAttribute(item[0], str(self.%s))" % (item[1]) 
    739735            inputs.appendChild(element) 
    740              
     736 
    741737        # For self.values ={ disp_param_name: [vals,...],...} 
    742738        # and for self.weights ={ disp_param_name: [weights,...],...} 
    … …  
    752748                    com += "(newdoc.createTextNode(str(%s)))" 
    753749                    exec com % val 
    754                     
     750 
    755751                element.appendChild(sub_element) 
    756752            inputs.appendChild(element) 
    757          
     753 
    758754        # Create doc for the dictionary of self._disp_obj_dic 
    759755        for item in list_of_obj_dic: 
    … …  
    767763                element.appendChild(sub_element) 
    768764            inputs.appendChild(element) 
    769                   
     765 
    770766        for item in list_of_state_parameters: 
    771767            element = newdoc.createElement(item[0]) 
    … …  
    774770            exec com % item[1] 
    775771            inputs.appendChild(element) 
    776          
     772 
    777773        # Save the file 
    778774        if doc is None: 
    … …  
    783779        else: 
    784780            return newdoc 
    785          
     781 
    786782    def _fromXML_helper(self, node, list): 
    787783        """ 
    … …  
    833829                         [minimum_displayed, minimum_value], 
    834830                         [maximum_displayed, maximum_value], unit]) 
    835         
     831 
    836832    def fromXML(self, file=None, node=None): 
    837833        """ 
    838834        Load fitting state from a file 
    839          
     835 
    840836        :param file: .fitv file 
    841837        :param node: node of a XML document to read from 
    842          
     838 
    843839        """ 
    844840        if file is not None: 
    … …  
    846842            msg += " format for fitting files" 
    847843            raise RuntimeError, msg 
    848              
     844 
    849845        if node.get('version')and node.get('version') == '1.0': 
    850              
     846 
    851847            # Get file name 
    852848            entry = get_content('ns:filename', node) 
    853849            if entry is not None: 
    854850                self.file = entry.text.strip() 
    855                  
     851 
    856852            # Get time stamp 
    857853            entry = get_content('ns:timestamp', node) 
    … …  
    863859                    msg += " read timestamp\n %s" % sys.exc_value 
    864860                    logging.error(msg) 
    865              
     861 
    866862            # Parse fitting attributes 
    867863            entry = get_content('ns:Attributes', node) 
    … …  
    870866                try: 
    871867                    exec "self.%s = parse_entry_helper(node, item)" % item[0] 
    872                      
     868 
    873869                except: 
    874870                    raise 
    875871 
    876872            if entry is not None: 
    877                  
     873 
    878874                for item in list_of_state_attributes: 
    879875                    node = get_content('ns:%s' % item[0], entry) 
    … …  
    883879                    except: 
    884880                        raise 
    885                      
     881 
    886882                for item in list_of_state_parameters: 
    887883                    node = get_content("ns:%s" % item[0], entry) 
    888884                    exec "self._fromXML_helper(node=node, list=self.%s)" % \ 
    889885                                                                    item[1] 
    890                  
     886 
    891887                # Recover _disp_obj_dict from xml file 
    892888                self._disp_obj_dict = {} 
    … …  
    910906                        except: 
    911907                            pass 
    912                          
     908 
    913909                # get self.values and self.weights dic. if exists 
    914910                for item in list_of_model_attributes: 
    … …  
    929925                    dic[name] = numpy.array(list) 
    930926                    exec "self.%s = dic" % item[1] 
    931                      
     927 
    932928    def set_plot_state(self, figs, canvases): 
    933929        """ 
    … …  
    943939        self.imgRAM = None 
    944940        wx.MemoryFSHandler() 
    945          
     941 
    946942        # For no figures in the list, prepare empty plot 
    947943        if figs == None or len(figs) == 0: 
    948944            figs = [None] 
    949              
     945 
    950946        # Loop over the list of figures 
    951947        # use wx.MemoryFSHandler 
    … …  
    955951                ind = figs.index(fig) 
    956952                canvas = canvases[ind] 
    957                  
     953 
    958954            #store the image in wx.FileSystem Object  
    959955            wx.FileSystem.AddHandler(wx.MemoryFSHandler()) 
    960              
     956 
    961957            # index of the fig 
    962958            ind = figs.index(fig) 
    963              
     959 
    964960            #AddFile, image can be retrieved with 'memory:filename' 
    965961            self.imgRAM.AddFile('img_fit%s.png' % ind, 
    966962                                canvas.bitmap, wx.BITMAP_TYPE_PNG) 
    967              
     963 
    968964            #append figs 
    969965            images.append(fig) 
    970              
     966 
    971967        return images 
    972968 
    … …  
    978974    ## File type 
    979975    type_name = "Fitting" 
    980      
     976 
    981977    ## Wildcards 
    982978    type = ["Fitting files (*.fitv)|*.fitv" 
    … …  
    984980    ## List of allowed extensions 
    985981    ext = ['.fitv', '.FITV', '.svs', 'SVS'] 
    986      
     982 
    987983    def __init__(self, call_back=None, cansas=True): 
    988984        CansasReader.__init__(self) 
    … …  
    990986        Initialize the call-back method to be called 
    991987        after we load a file 
    992          
     988 
    993989        :param call_back: call-back method 
    994990        :param cansas:  True = files will be written/read in CanSAS format 
    995991                        False = write CanSAS format 
    996              
     992 
    997993        """ 
    998994        ## Call back method to be executed after a file is read 
    … …  
    1001997        self.cansas = cansas 
    1002998        self.state = None 
    1003          
     999 
    10041000    def get_state(self): 
    10051001        return self.state 
    1006          
     1002 
    10071003    def read(self, path): 
    10081004        """ 
    10091005        Load a new P(r) inversion state from file 
    1010          
     1006 
    10111007        :param path: file path 
    1012          
     1008 
    10131009        """ 
    10141010        if self.cansas == True: 
    10151011            return self._read_cansas(path) 
    1016       
     1012 
    10171013    def _data2d_to_xml_doc(self, datainfo): 
    10181014        """ 
    10191015        Create an XML document to contain the content of a Data2D 
    1020          
     1016 
    10211017        :param datainfo: Data2D object 
    1022          
     1018 
    10231019        """ 
    10241020        if not issubclass(datainfo.__class__, Data2D): 
    10251021            raise RuntimeError, "The cansas writer expects a Data2D instance" 
    1026          
     1022 
    10271023        doc = xml.dom.minidom.Document() 
    10281024        main_node = doc.createElement("SASroot") 
    … …  
    10311027        main_node.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance") 
    10321028        main_node.setAttribute("xsi:schemaLocation", "cansas1d/%s http://svn.smallangles.net/svn/canSAS/1dwg/trunk/cansas1d.xsd" % self.version) 
    1033          
     1029 
    10341030        doc.appendChild(main_node) 
    1035          
     1031 
    10361032        entry_node = doc.createElement("SASentry") 
    10371033        main_node.appendChild(entry_node) 
    1038         
     1034 
    10391035        write_node(doc, entry_node, "Title", datainfo.title) 
    10401036        if datainfo is not None: 
    … …  
    10421038        for item in datainfo.run: 
    10431039            runname = {} 
    1044             if datainfo.run_name.has_key(item) and len(str(datainfo.run_name[item]))>1: 
     1040            if datainfo.run_name.has_key(item) and len(str(datainfo.run_name[item])) > 1: 
    10451041                runname = {'name': datainfo.run_name[item] } 
    10461042            write_node(doc, entry_node, "Run", item, runname) 
    … …  
    10521048            exec "element.setAttribute(item[0], str(datainfo.%s))" % (item[1]) 
    10531049            new_node.appendChild(element) 
    1054              
     1050 
    10551051        for item in list_of_data2d_values: 
    10561052            root_node = doc.createElement(item[0]) 
    … …  
    10591055            exec "temp_list = datainfo.%s" % item[1] 
    10601056 
    1061             if temp_list is None or len(temp_list)== 0: 
     1057            if temp_list is None or len(temp_list) == 0: 
    10621058                element = doc.createElement(item[0]) 
    10631059                exec "element.appendChild(doc.createTextNode(str(%s)))" % temp_list 
    … …  
    10681064                    exec "element.setAttribute(item[0], str(%s))" % value 
    10691065                    root_node.appendChild(element) 
    1070         
     1066 
    10711067        # Sample info 
    10721068        sample = doc.createElement("SASsample") 
    … …  
    10801076        write_node(doc, sample, "temperature", datainfo.sample.temperature, 
    10811077                   {"unit": datainfo.sample.temperature_unit}) 
    1082          
     1078 
    10831079        for item in datainfo.sample.details: 
    10841080            write_node(doc, sample, "details", item) 
    1085          
     1081 
    10861082        pos = doc.createElement("position") 
    10871083        written = write_node(doc, pos, "x", datainfo.sample.position.x, 
    … …  
    10951091        if written == True: 
    10961092            sample.appendChild(pos) 
    1097          
     1093 
    10981094        ori = doc.createElement("orientation") 
    10991095        written = write_node(doc, ori, "roll", datainfo.sample.orientation.x, 
    … …  
    11071103        if written == True: 
    11081104            sample.appendChild(ori) 
    1109          
     1105 
    11101106        # Instrument info 
    11111107        instr = doc.createElement("SASinstrument") 
    11121108        entry_node.appendChild(instr) 
    1113          
     1109 
    11141110        write_node(doc, instr, "name", datainfo.instrument) 
    1115          
     1111 
    11161112        #   Source 
    11171113        source = doc.createElement("SASsource") 
    … …  
    11191115            source.setAttribute("name", str(datainfo.source.name)) 
    11201116        instr.appendChild(source) 
    1121          
     1117 
    11221118        write_node(doc, source, "radiation", datainfo.source.radiation) 
    11231119        write_node(doc, source, "beam_shape", datainfo.source.beam_shape) 
    … …  
    11351131        if written == True: 
    11361132            source.appendChild(size) 
    1137              
     1133 
    11381134        write_node(doc, source, "wavelength", datainfo.source.wavelength, 
    11391135                   {"unit": datainfo.source.wavelength_unit}) 
    … …  
    11471143                   datainfo.source.wavelength_spread, 
    11481144                   {"unit": datainfo.source.wavelength_spread_unit}) 
    1149          
     1145 
    11501146        #   Collimation 
    11511147        for item in datainfo.collimation: 
    … …  
    11541150                coll.setAttribute("name", str(item.name)) 
    11551151            instr.appendChild(coll) 
    1156              
     1152 
    11571153            write_node(doc, coll, "length", item.length, 
    11581154                       {"unit": item.length_unit}) 
    1159              
     1155 
    11601156            for apert in item.aperture: 
    11611157                ap = doc.createElement("aperture") 
    … …  
    11651161                    ap.setAttribute("type", str(apert.type)) 
    11661162                coll.appendChild(ap) 
    1167                  
     1163 
    11681164                write_node(doc, ap, "distance", apert.distance, 
    11691165                           {"unit": apert.distance_unit}) 
    1170                  
     1166 
    11711167                size = doc.createElement("size") 
    11721168                if apert.size_name is not None: 
    … …  
    11921188            if written == True: 
    11931189                instr.appendChild(det) 
    1194              
     1190 
    11951191            off = doc.createElement("offset") 
    11961192            written = write_node(doc, off, "x", item.offset.x, 
    … …  
    12021198            if written == True: 
    12031199                det.appendChild(off) 
    1204              
     1200 
    12051201            center = doc.createElement("beam_center") 
    12061202            written = write_node(doc, center, "x", item.beam_center.x, 
    … …  
    12141210            if written == True: 
    12151211                det.appendChild(center) 
    1216                  
     1212 
    12171213            pix = doc.createElement("pixel_size") 
    12181214            written = write_node(doc, pix, "x", item.pixel_size.x, 
    … …  
    12241220            if written == True: 
    12251221                det.appendChild(pix) 
    1226                  
     1222 
    12271223            ori = doc.createElement("orientation") 
    12281224            written = write_node(doc, ori, "roll", item.orientation.x, 
    … …  
    12351231            if written == True: 
    12361232                det.appendChild(ori) 
    1237                  
     1233 
    12381234        # Processes info 
    12391235        for item in datainfo.process: 
    … …  
    12531249        # the data we just wrote 
    12541250        return doc, entry_node 
    1255     
     1251 
    12561252    def _parse_state(self, entry): 
    12571253        """ 
    12581254        Read a fit result from an XML node 
    1259          
     1255 
    12601256        :param entry: XML node to read from 
    1261          
     1257 
    12621258        :return: PageState object 
    12631259        """ 
    12641260        # Create an empty state 
    1265         state = None    
     1261        state = None 
    12661262        # Locate the P(r) node 
    12671263        try: 
    … …  
    12721268                state = PageState() 
    12731269                state.fromXML(node=nodes[0]) 
    1274                  
     1270 
    12751271        except: 
    12761272            logging.info("XML document does not contain fitting information.\n %s" % sys.exc_value) 
    1277              
     1273 
    12781274        return state 
    1279        
     1275 
    12801276    def _parse_save_state_entry(self, dom): 
    12811277        """ 
    12821278        Parse a SASentry 
    1283          
     1279 
    12841280        :param node: SASentry node 
    1285          
     1281 
    12861282        :return: Data1D/Data2D object 
    1287          
     1283 
    12881284        """ 
    12891285        node = dom.xpath('ns:data_class', namespaces={'ns': CANSAS_NS}) 
    … …  
    13051301                numpy.trim_zeros(return_value.dxl) 
    13061302                numpy.trim_zeros(return_value.dxw) 
    1307                              
     1303 
    13081304            return return_value, _ 
    1309          
     1305 
    13101306        #Parse 2D 
    13111307        data_info = Data2D() 
    1312          
     1308 
    13131309        # Look up title 
    13141310        self._store_content('ns:Title', dom, 'title', data_info) 
    1315          
     1311 
    13161312        # Look up run number 
    13171313        nodes = dom.xpath('ns:Run', namespaces={'ns': CANSAS_NS}) 
    … …  
    13231319                    if item.get('name') is not None: 
    13241320                        data_info.run_name[value] = item.get('name') 
    1325                             
     1321 
    13261322        # Look up instrument name 
    13271323        self._store_content('ns:SASinstrument/ns:name', dom, 
    … …  
    13401336                self.errors.append(err_mess) 
    13411337                logging.error(err_mess) 
    1342          
     1338 
    13431339        # Sample info ################### 
    13441340        entry = get_content('ns:SASsample', dom) 
    13451341        if entry is not None: 
    13461342            data_info.sample.name = entry.get('name') 
    1347              
     1343 
    13481344        self._store_content('ns:SASsample/ns:ID', 
    13491345                     dom, 'ID', data_info.sample) 
    … …  
    13541350        self._store_float('ns:SASsample/ns:temperature', 
    13551351                     dom, 'temperature', data_info.sample) 
    1356          
     1352 
    13571353        nodes = dom.xpath('ns:SASsample/ns:details', 
    13581354                          namespaces={'ns': CANSAS_NS}) 
    … …  
    13671363                self.errors.append(err_mess) 
    13681364                logging.error(err_mess) 
    1369          
     1365 
    13701366        # Position (as a vector) 
    13711367        self._store_float('ns:SASsample/ns:position/ns:x', 
    … …  
    13751371        self._store_float('ns:SASsample/ns:position/ns:z', 
    13761372                     dom, 'position.z', data_info.sample) 
    1377          
     1373 
    13781374        # Orientation (as a vector) 
    13791375        self._store_float('ns:SASsample/ns:orientation/ns:roll', 
    … …  
    13831379        self._store_float('ns:SASsample/ns:orientation/ns:yaw', 
    13841380                     dom, 'orientation.z', data_info.sample) 
    1385         
     1381 
    13861382        # Source info ################### 
    13871383        entry = get_content('ns:SASinstrument/ns:SASsource', dom) 
    13881384        if entry is not None: 
    13891385            data_info.source.name = entry.get('name') 
    1390          
     1386 
    13911387        self._store_content('ns:SASinstrument/ns:SASsource/ns:radiation', 
    13921388                     dom, 'radiation', data_info.source) 
    … …  
    14011397        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_spread', 
    14021398                     dom, 'wavelength_spread', data_info.source) 
    1403          
     1399 
    14041400        # Beam size (as a vector) 
    14051401        entry = get_content('ns:SASinstrument/ns:SASsource/ns:beam_size', dom) 
    14061402        if entry is not None: 
    14071403            data_info.source.beam_size_name = entry.get('name') 
    1408              
     1404 
    14091405        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:x', 
    14101406                     dom, 'beam_size.x', data_info.source) 
    … …  
    14131409        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:z', 
    14141410                     dom, 'beam_size.z', data_info.source) 
    1415          
     1411 
    14161412        # Collimation info ################### 
    14171413        nodes = dom.xpath('ns:SASinstrument/ns:SAScollimation', 
    … …  
    14221418                collim.name = item.get('name') 
    14231419            self._store_float('ns:length', item, 'length', collim) 
    1424              
     1420 
    14251421            # Look for apertures 
    14261422            apert_list = item.xpath('ns:aperture', 
    … …  
    14281424            for apert in apert_list: 
    14291425                aperture = Aperture() 
    1430                  
     1426 
    14311427                # Get the name and type of the aperture 
    14321428                aperture.name = apert.get('name') 
    14331429                aperture.type = apert.get('type') 
    1434                      
     1430 
    14351431                self._store_float('ns:distance', apert, 'distance', aperture) 
    1436                  
     1432 
    14371433                entry = get_content('ns:size', apert) 
    14381434                if entry is not None: 
    14391435                    aperture.size_name = entry.get('name') 
    1440                  
     1436 
    14411437                self._store_float('ns:size/ns:x', apert, 'size.x', aperture) 
    14421438                self._store_float('ns:size/ns:y', apert, 'size.y', aperture) 
    14431439                self._store_float('ns:size/ns:z', apert, 'size.z', aperture) 
    1444                  
     1440 
    14451441                collim.aperture.append(aperture) 
    1446                  
     1442 
    14471443            data_info.collimation.append(collim) 
    1448          
     1444 
    14491445        # Detector info ###################### 
    14501446        nodes = dom.xpath('ns:SASinstrument/ns:SASdetector', 
    14511447                          namespaces={'ns': CANSAS_NS}) 
    14521448        for item in nodes: 
    1453              
     1449 
    14541450            detector = Detector() 
    1455              
     1451 
    14561452            self._store_content('ns:name', item, 'name', detector) 
    14571453            self._store_float('ns:SDD', item, 'distance', detector) 
    1458              
     1454 
    14591455            # Detector offset (as a vector) 
    14601456            self._store_float('ns:offset/ns:x', item, 'offset.x', detector) 
    14611457            self._store_float('ns:offset/ns:y', item, 'offset.y', detector) 
    14621458            self._store_float('ns:offset/ns:z', item, 'offset.z', detector) 
    1463              
     1459 
    14641460            # Detector orientation (as a vector) 
    14651461            self._store_float('ns:orientation/ns:roll', item, 
    … …  
    14691465            self._store_float('ns:orientation/ns:yaw', item, 
    14701466                              'orientation.z', detector) 
    1471              
     1467 
    14721468            # Beam center (as a vector) 
    14731469            self._store_float('ns:beam_center/ns:x', item, 
    … …  
    14771473            self._store_float('ns:beam_center/ns:z', item, 
    14781474                              'beam_center.z', detector) 
    1479              
     1475 
    14801476            # Pixel size (as a vector) 
    14811477            self._store_float('ns:pixel_size/ns:x', item, 
    … …  
    14851481            self._store_float('ns:pixel_size/ns:z', item, 
    14861482                              'pixel_size.z', detector) 
    1487              
     1483 
    14881484            self._store_float('ns:slit_length', item, 'slit_length', detector) 
    1489              
     1485 
    14901486            data_info.detector.append(detector) 
    14911487 
    … …  
    14971493            self._store_content('ns:date', item, 'date', process) 
    14981494            self._store_content('ns:description', item, 'description', process) 
    1499              
     1495 
    15001496            term_list = item.xpath('ns:term', namespaces={'ns': CANSAS_NS}) 
    15011497            for term in term_list: 
    … …  
    15111507                    self.errors.append(err_mess) 
    15121508                    logging.error(err_mess) 
    1513              
     1509 
    15141510            note_list = item.xpath('ns:SASprocessnote', 
    15151511                                   namespaces={'ns': CANSAS_NS}) 
    … …  
    15171513                if note.text is not None: 
    15181514                    process.notes.append(note.text.strip()) 
    1519              
     1515 
    15201516            data_info.process.append(process) 
    1521              
     1517 
    15221518        # Data info ###################### 
    15231519        nodes = dom.xpath('ns:SASdata', namespaces={'ns': CANSAS_NS}) 
    15241520        if len(nodes) > 1: 
    15251521            raise RuntimeError, "CanSAS reader is not compatible with multiple SASdata entries" 
    1526         
     1522 
    15271523        for entry in nodes: 
    15281524            for item in list_of_data_2d_attr: 
    … …  
    15301526                node = get_content('ns:%s' % item[0], entry) 
    15311527                exec "data_info.%s = parse_entry_helper(node, item)" % item[1] 
    1532                      
     1528 
    15331529            for item in list_of_data2d_values: 
    15341530                field = get_content('ns:%s' % item[0], entry) 
    … …  
    15401536                else: 
    15411537                    exec "data_info.%s = numpy.array(list)" % item[0] 
    1542          
     1538 
    15431539        return data_info 
    15441540 
    … …  
    15461542        """ 
    15471543        Load data and P(r) information from a CanSAS XML file. 
    1548          
     1544 
    15491545        :param path: file path 
    1550          
     1546 
    15511547        :return: Data1D object if a single SASentry was found, 
    15521548                    or a list of Data1D objects if multiple entries were found, 
    15531549                    or None of nothing was found 
    1554                      
     1550 
    15551551        :raise RuntimeError: when the file can't be opened 
    15561552        :raise ValueError: when the length of the data vectors are inconsistent 
    1557          
     1553 
    15581554        """ 
    15591555        output = [] 
    … …  
    15631559        try: 
    15641560            if os.path.isfile(path): 
    1565                  
     1561 
    15661562                #TODO: eventually remove the check for .xml once 
    15671563                # the P(r) writer/reader is truly complete. 
    15681564                if  ext in self.ext or \ 
    15691565                    ext == '.xml': 
    1570                      
     1566 
    15711567                    tree = etree.parse(path, parser=etree.ETCompatXMLParser()) 
    15721568                    # Check the format version number 
    … …  
    15811577                            raise 
    15821578                        fitstate = self._parse_state(entry) 
    1583                          
     1579 
    15841580                        #state could be None when .svs file is loaded 
    15851581                        #in this case, skip appending to output 
    … …  
    16081604                    original_fname = state.file[0:max_char] 
    16091605                    state.file = original_fname + ' [' + time_str + ']' 
    1610                       
     1606 
    16111607                    if state is not None and state.is_data is not None: 
    16121608                        exec 'output[%d].is_data = state.is_data' % ind 
    1613                       
     1609 
    16141610                    output[ind].filename = state.file 
    16151611                    state.data = output[ind] 
    … …  
    16291625                    self.state = state 
    16301626                return output 
    1631                
     1627 
    16321628        except: 
    16331629            self.call_back(format=ext) 
    16341630            #self.state= state 
    16351631            raise 
    1636             
     1632 
    16371633    def write(self, filename, datainfo=None, fitstate=None): 
    16381634        """ 
    16391635        Write the content of a Data1D as a CanSAS XML file only for standalone 
    1640          
     1636 
    16411637        :param filename: name of the file to write 
    16421638        :param datainfo: Data1D object 
    16431639        :param fitstate: PageState object 
    1644          
     1640 
    16451641        """ 
    16461642        # Sanity check 
    … …  
    16511647        else: 
    16521648            doc = fitstate.toXML(file=filename) 
    1653          
     1649 
    16541650        # Save the document no matter the type 
    16551651        fd = open(filename, 'w') 
    16561652        fd.write(doc.toprettyxml()) 
    16571653        fd.close() 
    1658          
     1654 
    16591655    def write_toXML(self, datainfo=None, state=None): 
    16601656        """ 
    16611657        Write toXML, a helper for write(), 
    16621658        could be used by guimanager._on_save() 
    1663          
     1659 
    16641660        : return: xml doc 
    16651661        """ 
    … …  
    16771673                state.data.run = [str(state.data.name)] 
    16781674                state.data.run_name[0] = state.data.name 
    1679              
     1675 
    16801676            if issubclass(state.data.__class__, 
    16811677                          sas.dataloader.data_info.Data1D): 
    … …  
    16851681                data = state.data 
    16861682                doc, sasentry = self._data2d_to_xml_doc(data) 
    1687              
     1683 
    16881684        if state is not None: 
    16891685            doc = state.toXML(doc=doc, file=data.filename, entry_node=sasentry) 
    1690          
     1686 
    16911687        return doc 
    1692      
     1688 
    16931689# Simple html report templet 
    16941690HEADER = "<html>\n" 
    … …  
    17361732    #state.toXML() 
    17371733    """ 
    1738      
     1734 
    17391735    file = open("test_state", "w") 
    17401736    pickle.dump(state, file) 
    … …  
    17691765    db.keys().sort() 
    17701766    print pickle.loads(db['state2']) 
    1771    
     1767 
    17721768    db.close() 
Note: See TracChangeset for help on using the changeset viewer.