source: sasview/sansview/perspectives/fitting/pagestate.py @ 26f3dd5

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 26f3dd5 was 26f3dd5, checked in by Gervaise Alina <gervyh@…>, 14 years ago

working on save option
  • Property mode set to 100644
File size: 33.7 KB
Line 
1import time, os, sys
2import logging
3import DataLoader
4from xml.dom.minidom import parse
5from lxml import etree
6
7
8import copy
9
10from DataLoader.readers.cansas_reader import Reader as CansasReader
11from DataLoader.readers.cansas_reader import get_content
12
13FITTING_NODE_NAME = 'fitting_plug_in'
14CANSAS_NS = "cansas1d/1.0"
15
16list_of_data_attributes = [["is_data", "is_data", "bool"],
17                      ["group_id", "data_group_id", "string"],
18                      ["data_name", "data_name", "string"],
19                      ["data_id", "data_id", "string"],
20                      ["name", "name", "string"],
21                      ["data_name", "data_name", "string"]]
22list_of_state_attributes = [["qmin", "qmin", "float"],
23                      ["qmax", "qmax", "float"],
24                      ["npts", "npts", "float"],
25                      ["shape_rbutton", "shape_rbutton", "bool"],
26                      ["shape_indep_rbutton", "shape_indep_rbutton", "bool"],
27                      ["plugin_rbutton", "plugin_rbutton","bool"],
28                      ["struct_rbutton", "struct_rbutton", "bool"],
29                      ["formfactorcombobox", "formfactorcombobox", "bool"],
30                      ["structurecombobox", "structurecombobox", "bool"],
31                      ["disp_box", "disp_box"],
32                      ["enable_smearer","enable_smearer","bool"],
33                      ["disable_smearer","disable_smearer","bool"],
34                      ["pinhole_smearer","pinhole_smearer","bool"],
35                      ["slit_smearer","slit_smearer","bool"],
36                      ["enable_disp","enable_disp","bool"],
37                      ["disable_disp","disable_disp","bool"],
38                      ["slit_smearer","slit_smearer","bool"],
39                      ["enable2D","enable2D","bool"],
40                      ["cb1","cb1","bool"],
41                      ["tcChi","tcChi","float"]]
42list_of_state_parameters = [["parameters", "parameters"] ,                     
43                            ["orientation_parameters", "orientation_params"],
44                            ["dispersity_parameters", "orientation_params_disp"],
45                            ["fixed_param", "fixed_param"],                     
46                            ["fittable_param","fittable_param"]]
47
48class PageState(object):
49    """
50        Contains information to reconstruct a page of the fitpanel
51    """
52    def __init__(self, parent=None, model=None, data=None):
53       
54        """
55            Initialize the current state
56        """
57        self.file = None
58        #TODO: remove this once the inheritence is cleaned up
59        ## Data member to store the dispersion object created
60        self._disp_obj_dict = {}
61        #------------------------
62        #Data used for fitting
63        self.data = data
64        #save additional information on data that dataloader.reader does not read
65        self.is_data = None
66        self.data_name = ""
67       
68        if self.data is not None:
69            self.data_name = self.data.name
70        self.data_id = None
71        if self.data is not None and hasattr(self.data, "id"):
72            self.data_id = self.data.id
73        self.data_group_id = None
74        if self.data is not None and hasattr(self.data, "group_id"):
75            self.data_group_id = self.data.group_id
76        #-------------------------
77        ## reset True change the state of exsiting button
78        self.reset = False
79       
80        #engine type
81        self.engine_type = None
82        # flag to allow data2D plot
83        self.enable2D = False
84        # model on which the fit would be performed
85        self.model = model
86       
87        #fit page manager
88        self.manager = None
89        #Store the parent of this panel parent
90        # For this application fitpanel is the parent
91        self.parent  = parent
92        # Event_owner is the owner of model event
93        self.event_owner = None
94        ##page name
95        self.page_name = ""
96        # Contains link between  model ,all its parameters, and panel organization
97        self.parameters = []
98        # Contains list of parameters that cannot be fitted and reference to
99        #panel objects
100        self.fixed_param = []
101        # Contains list of parameters with dispersity and reference to
102        #panel objects
103        self.fittable_param = []
104        ## orientation parameters
105        self.orientation_params = []
106        ## orientation parmaters for gaussian dispersity
107        self.orientation_params_disp = []
108        ## smearer info
109        self.smearer = None
110        self.smear_type = None
111        self.dq_l = None
112        self.dq_r = None
113
114        #list of dispersion paramaters
115        self.disp_list =[]
116        if self.model is not None:
117            self.disp_list = self.model.getDispParamList()
118        self._disp_obj_dict = {}
119        self.disp_cb_dict = {}
120        self.values = []
121        self.weights = []
122                   
123        #contains link between a model and selected parameters to fit
124        self.param_toFit = []
125        ##dictionary of model type and model class
126        self.model_list_box = None
127        ## save the state of the context menu
128        self.saved_states = {}
129        ## save selection of combobox
130        self.formfactorcombobox = None
131        self.structurecombobox  = None
132        ## radio box to select type of model
133        self.shape_rbutton = False
134        self.shape_indep_rbutton = False
135        self.struct_rbutton = False
136        self.plugin_rbutton = False
137        ## the indice of the current selection
138        self.disp_box = 0
139        ## Qrange
140        ## Q range
141        self.qmin = 0.001
142        self.qmax = 0.1
143        self.npts = None
144        self.name = ""
145        ## enable smearering state
146        self.enable_smearer = False
147        self.disable_smearer = True
148        self.pinhole_smearer = False
149        self.slit_smearer   = False
150        ## disperity selection
151        self.enable_disp = False
152        self.disable_disp = True
153        ## plot 2D data
154        self.enable2D = False
155        ## state of selected all check button
156        self.cb1 = False
157        ## store value of chisqr
158        self.tcChi = None
159   
160    def clone(self):
161        """
162            Create a new copy of the current object
163        """
164        model = None
165        if self.model is not None:
166            model = self.model.clone()
167       
168        obj = PageState(self.parent, model=model)
169        obj.file = copy.deepcopy(self.file)
170        obj.data = copy.deepcopy(self.data)
171        if self.data is not None:
172            self.data_name = self.data.name
173        obj.data_name = self.data_name
174        obj.is_data = self.is_data
175        obj.model_list_box = copy.deepcopy(self.model_list_box)
176        obj.engine_type = copy.deepcopy(self.engine_type)
177       
178        obj.formfactorcombobox = self.formfactorcombobox
179        obj.structurecombobox  = self.structurecombobox 
180       
181        obj.shape_rbutton = self.shape_rbutton
182        obj.shape_indep_rbutton = self.shape_indep_rbutton
183        obj.struct_rbutton = self.struct_rbutton
184        obj.plugin_rbutton = self.plugin_rbutton
185       
186        obj.manager = self.manager
187        obj.event_owner = self.event_owner
188        obj.disp_list = copy.deepcopy(self.disp_list)
189       
190        obj.enable2D = copy.deepcopy(self.enable2D)
191        obj.parameters = copy.deepcopy(self.parameters)
192        obj.fixed_param = copy.deepcopy(self.fixed_param)
193        obj.fittable_param = copy.deepcopy(self.fittable_param)
194        obj.orientation_params =  copy.deepcopy(self.orientation_params)
195        obj.orientation_params_disp =  copy.deepcopy(self.orientation_params_disp)
196        obj.enable_disp = copy.deepcopy(self.enable_disp)
197        obj.disable_disp = copy.deepcopy(self.disable_disp)
198        obj.tcChi = self.tcChi
199 
200        if len(self._disp_obj_dict)>0:
201            for k , v in self._disp_obj_dict.iteritems():
202                obj._disp_obj_dict[k]= v
203        if len(self.disp_cb_dict)>0:
204            for k , v in self.disp_cb_dict.iteritems():
205                obj.disp_cb_dict[k]= v
206               
207        obj.values = copy.deepcopy(self.values)
208        obj.weights = copy.deepcopy(self.weights)
209        obj.enable_smearer = copy.deepcopy(self.enable_smearer)
210        obj.disable_smearer = copy.deepcopy(self.disable_smearer)
211        obj.pinhole_smearer = copy.deepcopy(self.pinhole_smearer)
212        obj.slit_smearer = copy.deepcopy(self.slit_smearer)
213        obj.smear_type = copy.deepcopy(self.smear_type)
214        obj.dq_l = copy.deepcopy(self.dq_l)
215        obj.dq_r = copy.deepcopy(self.dq_r)
216
217        obj.disp_box = copy.deepcopy(self.disp_box)
218        obj.qmin = copy.deepcopy(self.qmin)
219        obj.qmax = copy.deepcopy(self.qmax)
220        obj.npts = copy.deepcopy(self.npts )
221        obj.cb1 = copy.deepcopy(self.cb1)
222        obj.smearer = copy.deepcopy(self.smearer)
223       
224        for name, state in self.saved_states.iteritems():
225            copy_name = copy.deepcopy(name)
226            copy_state = state.clone()
227            obj.saved_states[copy_name]= copy_state
228        return obj
229   
230    def _repr_helper(self, list, rep):
231        """
232        """
233        for item in list:
234            rep += "parameter name: %s \n"%str(item[1])
235            rep += "value: %s\n"%str(item[2])
236            rep += "selected: %s\n"%str(item[0])
237            rep += "error displayed : %s \n"%str(item[4][0])
238            rep += "error value:%s \n"%str(item[4][1])
239            rep += "minimum displayed : %s \n"%str(item[5][0])
240            rep += "minimum value : %s \n"%str(item[5][1])
241            rep += "maximum displayed : %s \n"%str(item[6][0])
242            rep += "maximum value : %s \n"%str(item[6][1])
243            rep += "parameter unit: %s\n\n"%str(item[7])
244        return rep
245   
246    def __repr__(self):
247        """ output string for printing"""
248        rep = "\n\nState name: %s\n"%self.name
249        rep += "\n\nState form factor combobox selection: %s\n"%self.formfactorcombobox
250        rep += "\n\nState structure factor combobox selection: %s\n"%self.structurecombobox
251        rep += "\n\n is data : %s\n"%self.is_data
252        rep += "\n\n data's name : %s\n"%self.data_name
253        rep += "\n\n data's id : %s\n"%self.data_id
254        rep += "\n\n model type (form factor) selected: %s\n"%self.shape_rbutton
255        rep += "\n\n model type (shape independent) selected: %s\n "%self.shape_indep_rbutton
256        rep += "\n\n model type (structure factor) selected: %s\n"%self.struct_rbutton
257        rep += "\n\n model type (plug-in ) selected: %s\n"%self.plugin_rbutton
258        #rep +="data : %s\n"% str(self.data)
259        #rep += "Plotting Range: min: %s, max: %s, steps: %s\n"%(str(self.qmin),
260        #                                        str(self.qmax),str(self.npts))
261        #rep +="model  : %s\n\n"% str(self.model)
262        #rep +="number parameters(self.parameters): %s\n"%len(self.parameters)
263        #rep += self._repr_helper( list=self.parameters, rep=rep)
264        #rep +="number orientation parameters"
265        #rep +="(self.orientation_params): %s\n"%len(self.orientation_params)
266        #rep += self._repr_helper( list=self.orientation_params, rep=rep)
267        #rep +="number dispersity parameters"
268        #rep +="(self.orientation_params_disp): %s\n"%len(self.orientation_params_disp)
269        #rep += self._repr_helper( list=self.orientation_params_disp, rep=rep)
270       
271        return rep
272   
273    def _toXML_helper(self, list, element, newdoc):
274        """
275        """
276        for item in list:
277            sub_element = newdoc.createElement('parameter')
278            sub_element.setAttribute('name', str(item[1]))
279            sub_element.setAttribute('value', str(item[2]))
280            sub_element.setAttribute('selected_to_fit', str(item[0]))
281            sub_element.setAttribute('error_displayed', str(item[4][0]))
282            sub_element.setAttribute('error_value', str(item[4][1]))
283            sub_element.setAttribute('minimum_displayed', str(item[5][0]))
284            sub_element.setAttribute('minimum_value', str(item[5][1]))
285            sub_element.setAttribute('maximum_displayed', str(item[6][0]))
286            sub_element.setAttribute('maximum_value', str(item[6][1]))
287            sub_element.setAttribute('unit', str(item[7]))
288            element.appendChild(sub_element)
289       
290           
291    def toXML(self, file="fitting_state.fitv", doc=None, entry_node=None):
292        """
293            Writes the state of the InversionControl panel to file, as XML.
294           
295            Compatible with standalone writing, or appending to an
296            already existing XML document. In that case, the XML document
297            is required. An optional entry node in the XML document may also be given.
298           
299            @param file: file to write to
300            @param doc: XML document object [optional]
301            @param entry_node: XML node within the XML document at which we will append the data [optional]
302        """
303        from xml.dom.minidom import getDOMImplementation
304
305        # Check whether we have to write a standalone XML file
306        if doc is None:
307            impl = getDOMImplementation()
308            doc_type = impl.createDocumentType(FITTING_NODE_NAME, "1.0", "1.0")     
309            newdoc = impl.createDocument(None, FITTING_NODE_NAME, doc_type)
310            top_element = newdoc.documentElement
311        else:
312            # We are appending to an existing document
313            newdoc = doc
314            top_element = newdoc.createElement(FITTING_NODE_NAME)
315            if entry_node is None:
316                newdoc.documentElement.appendChild(top_element)
317            else:
318                entry_node.appendChild(top_element)
319           
320        attr = newdoc.createAttribute("version")
321        attr.nodeValue = '1.0'
322        top_element.setAttributeNode(attr)
323       
324        # File name
325        element = newdoc.createElement("filename")
326        if self.file is not None:
327            element.appendChild(newdoc.createTextNode(str(self.file)))
328        else:
329            element.appendChild(newdoc.createTextNode(str(file)))
330        top_element.appendChild(element)
331   
332        # Inputs
333        inputs = newdoc.createElement("Attributes")
334        top_element.appendChild(inputs)
335       
336        element = newdoc.createElement('data_attributes')
337        if self.data is not None and hasattr(self.data, "group_id"):
338            self.data_group_id = self.data.group_id
339        if self.data is not None and hasattr(self.data, "is_data"):
340            self.is_data = self.data.is_data
341        if self.data is not None:
342            self.data_name = self.data.name
343        if self.data is not None and hasattr(self.data, "id"):
344            self.data_id = self.data.id
345       
346        for item in list_of_data_attributes:
347            exec "element.setAttribute(item[0], str(self.%s))"%(item[1])
348        inputs.appendChild(element)   
349       
350        for item in list_of_state_attributes:
351            element = newdoc.createElement(item[0])
352            exec "element.setAttribute(item[0], str(self.%s))"%(item[1])
353            inputs.appendChild(element)
354       
355        for item in list_of_state_parameters:
356            element = newdoc.createElement(item[0])
357            exec "self._toXML_helper(list=self.%s, element=element, newdoc=newdoc)"%item[1]                       
358            inputs.appendChild(element)
359       
360        # Save the file
361        if doc is None:
362            fd = open(file, 'w')
363            fd.write(newdoc.toprettyxml())
364            fd.close()
365            return None
366        else:
367            return newdoc.toprettyxml()
368       
369    def _fromXML_helper(self, node, list):
370        """
371        """
372        for item in node:
373            name = item.get('name')
374            value = item.get('value')
375            selected_to_fit = item.get('selected_to_fit')
376            error_displayed = item.get('error_displayed')
377            error_value = item.get('error_value')
378            minimum_displayed = item.get('minimum_displayed')
379            minimum_value = item.get('minimum_value')
380            maximum_displayed = item.get('maximum_displayed')
381            maximum_value = item.get('maximum_value')
382            unit = item.get('unit')
383            list.append([selected_to_fit, name, value, "+/-",[error_displayed, error_value],
384                         [minimum_displayed,minimum_value],[maximum_displayed,maximum_value], unit])
385       
386    def fromXML(self, file=None, node=None):
387        """
388            Load fitting state from a file
389           
390            @param file: .fitv file
391            @param node: node of a XML document to read from
392        """
393     
394        if file is not None:
395            raise RuntimeError, "PageState no longer supports non-CanSAS format for fitting files"
396           
397        if node.get('version')\
398            and node.get('version') == '1.0':
399           
400            # Get file name
401            entry = get_content('ns:filename', node)
402            if entry is not None:
403                self.file = entry.text.strip()
404       
405            # Parse fitting attributes
406            entry = get_content('ns:Attributes', node)
407            if entry is not None:
408                for item in list_of_state_attributes:
409                    field = get_content('ns:%s'%item[0], entry)
410                    if field is not None:
411                        if item[2] == "string":
412                            exec "self.%s= str(field.text)"%item[1]
413                        elif item[2] == "bool":
414                            try:
415                                exec "self.%s= field.get(str(%s))"%(item[1], item[0])
416                            except:
417                                exec "self.%s = None"%item[1]
418                        else:
419                            try:
420                                exec "self.%s = float(field.get(%s))"%(item[1], item[0])
421                            except:
422                                exec "self.%s = None"%item[1]
423               
424                for item in list_of_state_parameters:
425                    field = get_content("ns:%s"%item[0], entry)
426                    self._fromXML_helper(node=field, list=self.parameters)
427               
428
429class Reader(CansasReader):
430    """
431        Class to load a .fitv fitting file
432    """
433    ## File type
434    type_name = "Fitting"
435   
436    ## Wildcards
437    type = ["Fitting files (*.fitv)|*.fitv"]
438    ## List of allowed extensions
439    ext=['.fitv', '.FITV'] 
440   
441    def __init__(self, call_back=None, cansas=True):
442        """
443            Initialize the call-back method to be called
444            after we load a file
445            @param call_back: call-back method
446            @param cansas:  True = files will be written/read in CanSAS format
447                            False = write CanSAS format
448           
449        """
450        ## Call back method to be executed after a file is read
451        self.call_back = call_back
452        ## CanSAS format flag
453        self.cansas = cansas
454       
455    def read(self, path):
456        """
457            Load a new P(r) inversion state from file
458           
459            @param path: file path
460            @return: None
461        """
462        if self.cansas==True:
463            return self._read_cansas(path)
464        else:
465            return self._read_standalone(path)
466       
467    def _data2d_to_xml_doc(self):
468        """
469            Create an XML document to contain the content of a Data2D
470           
471            @param datainfo: Data2D object
472        """
473        if not issubclass(datainfo.__class__, Data2D):
474            raise RuntimeError, "The cansas writer expects a Data2D instance"
475       
476        doc = xml.dom.minidom.Document()
477        main_node = doc.createElement("SASroot")
478        main_node.setAttribute("version", self.version)
479     
480        doc.appendChild(main_node)
481       
482        entry_node = doc.createElement("SASentry")
483        main_node.appendChild(entry_node)
484       
485        write_node(doc, entry_node, "Title", datainfo.title)
486       
487        for item in datainfo.run:
488            runname = {}
489            if datainfo.run_name.has_key(item) and len(str(datainfo.run_name[item]))>1:
490                runname = {'name': datainfo.run_name[item] }
491            write_node(doc, entry_node, "Run", item, runname)
492       
493        # Data info
494        node = doc.createElement("SASdata")
495        entry_node.appendChild(node)
496       
497        for i in range(len(datainfo.x)):
498            pt = doc.createElement("Idata")
499            node.appendChild(pt)
500            write_node(doc, pt, "Q", datainfo.x[i], {'unit':datainfo.x_unit})
501            if len(datainfo.y)>=i:
502                write_node(doc, pt, "I", datainfo.y[i], {'unit':datainfo.y_unit})
503            if datainfo.dx !=None and len(datainfo.dx)>=i:
504                write_node(doc, pt, "Qdev", datainfo.dx[i], {'unit':datainfo.x_unit})
505            if datainfo.dy !=None and len(datainfo.dy)>=i:
506                write_node(doc, pt, "Idev", datainfo.dy[i], {'unit':datainfo.y_unit})
507
508       
509        # Sample info
510        sample = doc.createElement("SASsample")
511        if datainfo.sample.name is not None:
512            sample.setAttribute("name", str(datainfo.sample.name))
513        entry_node.appendChild(sample)
514        write_node(doc, sample, "ID", str(datainfo.sample.ID))
515        write_node(doc, sample, "thickness", datainfo.sample.thickness, {"unit":datainfo.sample.thickness_unit})
516        write_node(doc, sample, "transmission", datainfo.sample.transmission)
517        write_node(doc, sample, "temperature", datainfo.sample.temperature, {"unit":datainfo.sample.temperature_unit})
518       
519        for item in datainfo.sample.details:
520            write_node(doc, sample, "details", item)
521       
522        pos = doc.createElement("position")
523        written = write_node(doc, pos, "x", datainfo.sample.position.x, {"unit":datainfo.sample.position_unit})
524        written = written | write_node(doc, pos, "y", datainfo.sample.position.y, {"unit":datainfo.sample.position_unit})
525        written = written | write_node(doc, pos, "z", datainfo.sample.position.z, {"unit":datainfo.sample.position_unit})
526        if written == True:
527            sample.appendChild(pos)
528       
529        ori = doc.createElement("orientation")
530        written = write_node(doc, ori, "roll",  datainfo.sample.orientation.x, {"unit":datainfo.sample.orientation_unit})
531        written = written | write_node(doc, ori, "pitch", datainfo.sample.orientation.y, {"unit":datainfo.sample.orientation_unit})
532        written = written | write_node(doc, ori, "yaw",   datainfo.sample.orientation.z, {"unit":datainfo.sample.orientation_unit})
533        if written == True:
534            sample.appendChild(ori)
535       
536        # Instrument info
537        instr = doc.createElement("SASinstrument")
538        entry_node.appendChild(instr)
539       
540        write_node(doc, instr, "name", datainfo.instrument)
541       
542        #   Source
543        source = doc.createElement("SASsource")
544        if datainfo.source.name is not None:
545            source.setAttribute("name", str(datainfo.source.name))
546        instr.appendChild(source)
547       
548        write_node(doc, source, "radiation", datainfo.source.radiation)
549        write_node(doc, source, "beam_shape", datainfo.source.beam_shape)
550        size = doc.createElement("beam_size")
551        if datainfo.source.beam_size_name is not None:
552            size.setAttribute("name", str(datainfo.source.beam_size_name))
553        written = write_node(doc, size, "x", datainfo.source.beam_size.x, {"unit":datainfo.source.beam_size_unit})
554        written = written | write_node(doc, size, "y", datainfo.source.beam_size.y, {"unit":datainfo.source.beam_size_unit})
555        written = written | write_node(doc, size, "z", datainfo.source.beam_size.z, {"unit":datainfo.source.beam_size_unit})
556        if written == True:
557            source.appendChild(size)
558           
559        write_node(doc, source, "wavelength", datainfo.source.wavelength, {"unit":datainfo.source.wavelength_unit})
560        write_node(doc, source, "wavelength_min", datainfo.source.wavelength_min, {"unit":datainfo.source.wavelength_min_unit})
561        write_node(doc, source, "wavelength_max", datainfo.source.wavelength_max, {"unit":datainfo.source.wavelength_max_unit})
562        write_node(doc, source, "wavelength_spread", datainfo.source.wavelength_spread, {"unit":datainfo.source.wavelength_spread_unit})
563       
564        #   Collimation
565        for item in datainfo.collimation:
566            coll = doc.createElement("SAScollimation")
567            if item.name is not None:
568                coll.setAttribute("name", str(item.name))
569            instr.appendChild(coll)
570           
571            write_node(doc, coll, "length", item.length, {"unit":item.length_unit})
572           
573            for apert in item.aperture:
574                ap = doc.createElement("aperture")
575                if apert.name is not None:
576                    ap.setAttribute("name", str(apert.name))
577                if apert.type is not None:
578                    ap.setAttribute("type", str(apert.type))
579                coll.appendChild(ap)
580               
581                write_node(doc, ap, "distance", apert.distance, {"unit":apert.distance_unit})
582               
583                size = doc.createElement("size")
584                if apert.size_name is not None:
585                    size.setAttribute("name", str(apert.size_name))
586                written = write_node(doc, size, "x", apert.size.x, {"unit":apert.size_unit})
587                written = written | write_node(doc, size, "y", apert.size.y, {"unit":apert.size_unit})
588                written = written | write_node(doc, size, "z", apert.size.z, {"unit":apert.size_unit})
589                if written == True:
590                    ap.appendChild(size)
591
592        #   Detectors
593        for item in datainfo.detector:
594            det = doc.createElement("SASdetector")
595            written = write_node(doc, det, "name", item.name)
596            written = written | write_node(doc, det, "SDD", item.distance, {"unit":item.distance_unit})
597            written = written | write_node(doc, det, "slit_length", item.slit_length, {"unit":item.slit_length_unit})
598            if written == True:
599                instr.appendChild(det)
600           
601            off = doc.createElement("offset")
602            written = write_node(doc, off, "x", item.offset.x, {"unit":item.offset_unit})
603            written = written | write_node(doc, off, "y", item.offset.y, {"unit":item.offset_unit})
604            written = written | write_node(doc, off, "z", item.offset.z, {"unit":item.offset_unit})
605            if written == True:
606                det.appendChild(off)
607           
608            center = doc.createElement("beam_center")
609            written = write_node(doc, center, "x", item.beam_center.x, {"unit":item.beam_center_unit})
610            written = written | write_node(doc, center, "y", item.beam_center.y, {"unit":item.beam_center_unit})
611            written = written | write_node(doc, center, "z", item.beam_center.z, {"unit":item.beam_center_unit})
612            if written == True:
613                det.appendChild(center)
614               
615            pix = doc.createElement("pixel_size")
616            written = write_node(doc, pix, "x", item.pixel_size.x, {"unit":item.pixel_size_unit})
617            written = written | write_node(doc, pix, "y", item.pixel_size.y, {"unit":item.pixel_size_unit})
618            written = written | write_node(doc, pix, "z", item.pixel_size.z, {"unit":item.pixel_size_unit})
619            if written == True:
620                det.appendChild(pix)
621               
622            ori = doc.createElement("orientation")
623            written = write_node(doc, ori, "roll",  item.orientation.x, {"unit":item.orientation_unit})
624            written = written | write_node(doc, ori, "pitch", item.orientation.y, {"unit":item.orientation_unit})
625            written = written | write_node(doc, ori, "yaw",   item.orientation.z, {"unit":item.orientation_unit})
626            if written == True:
627                det.appendChild(ori)
628               
629       
630        # Processes info
631        for item in datainfo.process:
632            node = doc.createElement("SASprocess")
633            entry_node.appendChild(node)
634
635            write_node(doc, node, "name", item.name)
636            write_node(doc, node, "date", item.date)
637            write_node(doc, node, "description", item.description)
638            for term in item.term:
639                value = term['value']
640                del term['value']
641                write_node(doc, node, "term", value, term)
642            for note in item.notes:
643                write_node(doc, node, "SASprocessnote", note)
644       
645        # Return the document, and the SASentry node associated with
646        # the data we just wrote
647        return doc, entry_node
648   
649    def _read_standalone(self, path):
650        """
651            Load a new P(r) inversion state from file.
652            The P(r) node is assumed to be the top element.
653           
654            @param path: file path
655            @return: None
656        """
657        # Read the new state from file
658        state = PageState()
659        state.fromXML(file=path)
660        # Call back to post the new state
661        self.call_back(state)
662        return None
663   
664    def _parse_state(self, entry):
665        """
666            Read a fit result from an XML node
667            @param entry: XML node to read from
668            @return: PageState object
669        """
670        # Create an empty state
671        state = PageState()
672        # Locate the P(r) node
673        try:
674            nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME, namespaces={'ns': CANSAS_NS})
675            state.fromXML(node=nodes[0])
676        except:
677            logging.info("XML document does not contain fitting information.\n %s" % sys.exc_value)
678           
679        return state
680   
681    def _read_cansas(self, path):
682        """
683            Load data and P(r) information from a CanSAS XML file.
684           
685            @param path: file path
686            @return: Data1D object if a single SASentry was found,
687                        or a list of Data1D objects if multiple entries were found,
688                        or None of nothing was found
689            @raise RuntimeError: when the file can't be opened
690            @raise ValueError: when the length of the data vectors are inconsistent
691        """
692        output = []
693        try:
694            if os.path.isfile(path):
695                basename  = os.path.basename(path)
696                root, extension = os.path.splitext(basename)
697                #TODO: eventually remove the check for .xml once
698                # the P(r) writer/reader is truly complete.
699                if  extension.lower() in self.ext or \
700                    extension.lower() == '.xml':
701                   
702                    tree = etree.parse(path, parser=etree.ETCompatXMLParser())
703                    # Check the format version number
704                    # Specifying the namespace will take care of the file format version
705                    root = tree.getroot()
706                    entry_list = root.xpath('/ns:SASroot/ns:SASentry', namespaces={'ns': CANSAS_NS})
707                    for entry in entry_list:
708                        sas_entry = self._parse_entry(entry)
709                        fitstate = self._parse_state(entry)
710                        sas_entry.meta_data['fitstate'] = fitstate
711                        sas_entry.filename = fitstate.file
712                        output.append(sas_entry)
713                   
714            else:
715                raise RuntimeError, "%s is not a file" % path
716           
717            # Return output consistent with the loader's api
718            if len(output)==0:
719                return None
720            elif len(output)==1:
721                # Call back to post the new state
722                state = output[0].meta_data['fitstate']
723                if state is not None and state.is_data is not None:
724                    exec 'output[0].is_data = state.is_data' 
725                 
726                output[0].filename = state.data_name
727                state.data = output[0]
728                state.data.name = state.data_name
729                state.data.id = state.data_id
730                state.data.group_id = state.data_group_id
731                self.call_back(state=state, datainfo=output[0])
732                return output[0]
733            else:
734                return output               
735        except:
736            raise
737           
738    def write(self, filename, datainfo=None, fitstate=None):
739        """
740            Write the content of a Data1D as a CanSAS XML file
741           
742            @param filename: name of the file to write
743            @param datainfo: Data1D object
744            @param fitstate: PageState object
745        """
746        # Sanity check
747        if self.cansas == True:
748           
749            # Add fitting information to the XML document
750            if fitstate is not None:
751                if fitstate.data is None:
752                    data = DataLoader.data_info.Data1D(x=[], y=[])   
753                elif issubclass(fitstate.data.__class__, DataLoader.data_info.Data1D):
754                    data = fitstate.data
755                    doc, sasentry = self._to_xml_doc(data)
756                else:
757                    data = fitstate.data
758                    doc, sasentry = self._data2d_to_xml_doc(data)
759                fitstate.toXML(doc=doc, entry_node=sasentry)
760            # Write the XML document
761            fd = open(filename, 'w')
762            fd.write(doc.toprettyxml())
763            fd.close()
764        else:
765            fitstate.toXML(file=filename)
766       
767       
768if __name__ == "__main__":
769    state = PageState(parent=None)
770    state.toXML()
771 
Note: See TracBrowser for help on using the repository browser.