Changeset 786685e for src – SasView

src/sans/dataloader/readers/cansas_constants.py

-                      r9e2bc6c
+                      rac5b69d
 the cansas_reader.py file to read in any version of the cansas format.
 """
+class cansasConstants:
+    ns = ''
+class CansasConstants:
+    """
+    The base class to define where all of the data is to be saved by
+    cansas_reader.py.
+    """
+    names = ''
     format = ''
     def __init__(self):
         self.ns = self.CANSAS_NS
+        self.names = self.CANSAS_NS
         self.format = self.CANSAS_FORMAT
     def _iterate_namespace(self, namespace):
+    def iterate_namespace(self, namespace):
         """
         Method to iterate through a cansas constants tree based on a list of
 …
         """
         # The current level to look through in cansas_constants.
         return_me = currentLevel()
+        return_me = CurrentLevel()
         return_me.current_level = self.CANSAS_FORMAT.get("SASentry")
         # Defaults for variable and datatype
 …
         return_me.ns_optional = True
         for name in namespace:
+            if name != "SASentry":
+                return_me.current_level = \
+                        return_me.current_level.get("children").get(name, "")
+                if return_me.current_level == "":
+            try:
+                if name != "SASentry":
                     return_me.current_level = \
+                            return_me.current_level.get("<any>", "")
+                cl_variable = return_me.current_level.get("variable", "")
+                cl_datatype = return_me.current_level.get("storeas", "")
+                cl_units_optional = \
+                            return_me.current_level.get("units_required", "")
+                # Where are how to store the variable for the given namespace
+                # CANSAS_CONSTANTS tree is hierarchical, so is no value, inherit
+                return_me.ns_variable = cl_variable if cl_variable != "" else \
+                                    return_me.ns_variable
+                return_me.ns_datatype = cl_datatype if cl_datatype != "" else \
+                                    return_me.ns_datatype
+                return_me.ns_optional = cl_units_optional if \
+                                    cl_units_optional != return_me.ns_optional \
+                                    else return_me.ns_optional
+                            return_me.current_level.get("children").get(name, "")
+                    if return_me.current_level == "":
+                        return_me.current_level = \
+                                return_me.current_level.get("<any>", "")
+                    cl_variable = return_me.current_level.get("variable", "")
+                    cl_datatype = return_me.current_level.get("storeas", "")
+                    cl_units_optional = \
+                                return_me.current_level.get("units_required", "")
+                    # Where are how to store the variable for the given namespace
+                    # CANSAS_CONSTANTS tree is hierarchical, so is no value, inherit
+                    return_me.ns_variable = cl_variable if cl_variable != "" else \
+                                        return_me.ns_variable
+                    return_me.ns_datatype = cl_datatype if cl_datatype != "" else \
+                                        return_me.ns_datatype
+                    return_me.ns_optional = cl_units_optional if \
+                                        cl_units_optional != return_me.ns_optional \
+                                        else return_me.ns_optional
+            except AttributeError:
+                return_me.ns_variable = "{0}.meta_data[\"{2}\"] = \"{1}\""
+                return_me.ns_datatype = "content"
+                return_me.ns_optional = True
         return return_me
 …
+                           }
     SASINSTR_SRC = {
+                    "attributes" : {"name" : {"variable" : "{0}.source.name = \"{1}\""}},
+                    "attributes" : {"name" : {"variable" : \
+                                              "{0}.source.name = \"{1}\""}},
                     "variable" : None,
                     "children" : {
+                                  "radiation" : {"variable" : "{0}.source.radiation = \"{1}\""},
+                                  "radiation" : {"variable" : \
+                                            "{0}.source.radiation = \"{1}\""},
                                   "beam_size" : SASINSTR_SRC_BEAMSIZE,
                                   "beam_shape" : {"variable" : \
 …
                         "unit" : "pixel_size_unit",
                         "attributes" : {
+                                        "unit" : "{0}.pixel_size_unit = \"{1}\"",
+                                        "unit" : \
+                                            "{0}.pixel_size_unit = \"{1}\"",
                                         "storeas" : "content"
+                                        }
 …
                         "unit" : "pixel_size_unit",
                         "attributes" : {
+                                        "unit" : "{0}.pixel_size_unit = \"{1}\"",
+                                        "unit" : \
+                                            "{0}.pixel_size_unit = \"{1}\"",
                                         "storeas" : "content"
+                                        }
 …
                         "unit" : "pixel_size_unit",
                         "attributes" : {
+                                        "unit" : "{0}.pixel_size_unit = \"{1}\"",
+                                        "unit" : \
+                                            "{0}.pixel_size_unit = \"{1}\"",
                                         "storeas" : "content"
+                                        }
 …
+                     }
+class currentLevel:
+class CurrentLevel:
+    """
+    A helper class to hold information on where you are in the constants tree
+    """
     current_level = ''
 …
     def __init__(self):
         self.current_level = ''
+        self.current_level = {}
         self.ns_variable = ''
         self.ns_datatype = "content"

src/sans/dataloader/readers/cansas_reader.py

-                      r2e3b055
+                      rbb1b892
 import sys
 import datetime
+import inspect
+# For saving individual sections of data
 from sans.dataloader.data_info import Data1D
 from sans.dataloader.data_info import Collimation
 …
 from sans.dataloader.data_info import Process
 from sans.dataloader.data_info import Aperture
+# Both imports used. Do not remove either.
+from xml.dom.minidom import parseString
 import sans.dataloader.readers.xml_reader as xml_reader
+from sans.dataloader.readers.cansas_constants import cansasConstants
+from sans.dataloader.readers.xml_reader import XMLreader
+from sans.dataloader.readers.cansas_constants import CansasConstants
 _ZERO = 1e-16
 …
     HAS_CONVERTER = False
 constants = cansasConstants()
 CANSAS_FORMAT = constants.format
 CANSAS_NS = constants.ns
+CONSTANTS = CansasConstants()
+CANSAS_FORMAT = CONSTANTS.format
+CANSAS_NS = CONSTANTS.names
 ALLOW_ALL = True
+# minidom used in functions called by outside classes
+import xml.dom.minidom
+# DO NOT REMOVE
+# Called by outside packages:
+#    sans.perspectives.invariant.invariant_state
+#    sans.perspectives.fitting.pagestate
 def get_content(location, node):
     """
 …
     :return: Element, or None
     """
+    nodes = node.xpath(location, namespaces={'ns': CANSAS_NS})
+    nodes = node.xpath(location,
+                       namespaces={'ns': CANSAS_NS.get("1.0").get("ns")})
     if len(nodes) > 0:
 …
+def get_float(location, node):
+    """
+    Get the content of a node as a float
+    :param location: xpath location
+    :param node: node to start at
+    """
+    nodes = node.xpath(location, namespaces={'ns': CANSAS_NS})
+    value = None
+    attr = {}
+    if len(nodes) > 0:
+        try:
+            value = float(nodes[0].text)
+        except:
+            # Could not pass, skip and return None
+            msg = "cansas_reader.get_float: could not "
+            msg += " convert '%s' to float" % nodes[0].text
+            logging.error(msg)
+        if nodes[0].get('unit') is not None:
+            attr['unit'] = nodes[0].get('unit')
+    return value, attr
+# This is called by sans.perspectives.fitting.pagestate.py
+# Do not remove
+# DO NOT REMOVE
+# Called by outside packages:
+#    sans.perspectives.fitting.pagestate
 def write_node(doc, parent, name, value, attr={}):
     """
 …
 class Reader():
+class Reader(XMLreader):
     """
     Class to load cansas 1D XML files
 …
     ##CanSAS version - defaults to version 1.0
     cansas_version = "1.0"
+    ##Data reader
+    # TODO: make the reader extend the XMLreader class?
+    reader = xml_reader.XMLreader()
+    logging = []
     errors = []
     type_name = "canSAS"
     ## Wildcards
     type = ["XML files (*.xml)|*.xml"]
+    type = ["XML files (*.xml)|*.xml", "SasView Save Files (*.svs)|*.svs"]
     ## List of allowed extensions
     ext = ['.xml', '.XML']
+    ext = ['.xml', '.XML', '.svs', '.SVS']
     ## Flag to bypass extension check
 …
         self.errors = []
     def is_cansas(self):
+    def is_cansas(self, ext="xml"):
         """
         Checks to see if the xml file is a CanSAS file
         """
         if self.reader.validateXML():
+        if self.validate_xml():
             name = "{http://www.w3.org/2001/XMLSchema-instance}schemaLocation"
             value = self.reader.xmlroot.get(name)
             if (CANSAS_NS.get(self.cansas_version).get("ns") == \
                     value.rsplit(" ")[0]):
+            value = self.xmlroot.get(name)
+            if CANSAS_NS.get(self.cansas_version).get("ns") == \
+                    value.rsplit(" ")[0]:
                 return True
+        if ext == "svs":
+            return True
         return False
 …
         """
         # X - Q value; Y - Intensity (Abs)
         x = numpy.empty(0)
         y = numpy.empty(0)
         dx = numpy.empty(0)
         dy = numpy.empty(0)
+        x_vals = numpy.empty(0)
+        y_vals = numpy.empty(0)
+        dx_vals = numpy.empty(0)
+        dy_vals = numpy.empty(0)
         dxl = numpy.empty(0)
         dxw = numpy.empty(0)
 …
         output = []
         # ns - Namespace hierarchy for current xml object
         ns = []
+        ns_list = []
         # Check that the file exists
 …
             basename = os.path.basename(xml)
             _, extension = os.path.splitext(basename)
             # If the fiel type is not allowed, return nothing
+            # If the file type is not allowed, return nothing
             if extension in self.ext or self.allow_all:
+                # Get the file location of
                 base_name = xml_reader.__file__
                 base_name = base_name.replace("\\","/")
 …
                 # Load in xml file and get the cansas version from the header
                 self.reader.setXMLFile(xml)
                 root = self.reader.xmlroot
+                self.set_xml_file(xml)
+                root = self.xmlroot
                 if root is None:
                     root = {}
 …
                 # Link a schema to the XML file.
                 self.reader.setSchema(schema_path)
+                self.set_schema(schema_path)
                 # Try to load the file, but raise an error if unable to.
                 # Check the file matches the XML schema
                 try:
                     if self.is_cansas():
+                    if self.is_cansas(extension):
                         # Get each SASentry from XML file and add it to a list.
                         entry_list = root.xpath('/ns:SASroot/ns:SASentry',
                                 namespaces={'ns': cansas_defaults.get("ns")})
                         ns.append("SASentry")
+                        ns_list.append("SASentry")
                         # If multiple files, modify the name for each is unique
 …
                         # Parse each SASentry item
                         for entry in entry_list:
+                            # Define a new Data1D object with zeroes for x and y
+                            data1d = Data1D(x,y,dx,dy)
+                            # Define a new Data1D object with zeroes for
+                            # x_vals and y_vals
+                            data1d = Data1D(x_vals, y_vals, dx_vals, dy_vals)
                             data1d.dxl = dxl
                             data1d.dxw = dxw
 …
                             # Get all preprocessing events and encoding
                             self.reader.setProcessingInstructions()
+                            self.set_processing_instructions()
                             data1d.meta_data[PREPROCESS] = \
                                     self.reader.processingInstructions
+                                    self.processing_instructions
                             # Parse the XML file
                             return_value, extras = \
                                 self._parse_entry(entry, ns, data1d)
+                                self._parse_entry(entry, ns_list, data1d)
                             del extras[:]
 …
                             output.append(return_value)
                     else:
                         value = self.reader.findInvalidXML()
+                        value = self.find_invalid_xml()
                         output.append("Invalid XML at: {0}".format(value))
                 except:
                     # If the file does not match the schema, raise this error
                     raise RuntimeError, "%s cannot be read \increment" % xml
+                    raise RuntimeError, "%s cannot be read" % xml
                 return output
         # Return a list of parsed entries that dataloader can manage
         return None
     def _create_unique_key(self, dictionary, name, i = 0):
+    def _create_unique_key(self, dictionary, name, numb = 0):
         """
         Create a unique key value for any dictionary to prevent overwriting
 …
         :param dictionary: A dictionary with any number of entries
         :param name: The index of the item to be added to dictionary
         :param i: The number to be appended to the name, starts at 0
+        :param numb: The number to be appended to the name, starts at 0
         """
         if dictionary.get(name) is not None:
             i += 1
+            numb += 1
             name = name.split("_")[0]
             name += "_{0}".format(i)
             name = self._create_unique_key(dictionary, name, i)
+            name += "_{0}".format(numb)
+            name = self._create_unique_key(dictionary, name, numb)
         return name
 …
         :param new_current_level: cansas_constants level as returned by
             _iterate_namespace
+            iterate_namespace
         :param attr: The attributes of the node
         :param data1d: Where the values will be saved
 …
                             return
                         except:
+                            err_msg = "CanSAS reader: could not convert the units"
+                            err_msg = \
+                                "CanSAS reader: could not convert the units"
                             self.errors.append(err_msg)
                             return
 …
         return node_value, value_unit
     def _parse_entry(self, dom, ns, data1d, extras = []):
+    def _parse_entry(self, dom, names=["SASentry"], data1d=None, extras=[]):
         """
         Parse a SASEntry - new recursive method for parsing the dom of
 …
             and extra nodes to be read in simultaneously.
         :param dom: dom object with a namespace base of ns
         :param ns: A list of element names that lead up to the dom object
+        :param dom: dom object with a namespace base of names
+        :param names: A list of element names that lead up to the dom object
         :param data1d: The data1d object that will be modified
         :param extras: Any values that should go into meta_data when data1d
             is not a Data1D object
         """
         # A portion of every namespace entry
+        if data1d == None:
+            x_vals = numpy.empty(0)
+            y_vals = numpy.empty(0)
+            dx_vals = numpy.empty(0)
+            dy_vals = numpy.empty(0)
+            dxl = numpy.empty(0)
+            dxw = numpy.empty(0)
+            data1d = Data1D(x_vals, y_vals, dx_vals, dy_vals)
+            data1d.dxl = dxl
+            data1d.dxw = dxw
         base_ns = "{0}{1}{2}".format("{", \
                             CANSAS_NS.get(self.cansas_version).get("ns"), "}")
 …
         for node in dom:
             try:
                 # Get the element name and set the current ns level
+                # Get the element name and set the current names level
                 tagname = node.tag.replace(base_ns, "")
                 tagname_original = tagname
+                ns.append(tagname)
+                if tagname == "fitting_plug_in" or tagname == "pr_inversion" or\
+                    tagname == "invariant":
+                    continue
+                names.append(tagname)
                 attr = node.attrib
                 children = node.getchildren()
+                if len(children) == 0:
+                    children = None
                 save_data1d = data1d
 …
                 # Get where to store content
                 cs_values = constants._iterate_namespace(ns)
+                cs_values = CONSTANTS.iterate_namespace(names)
                 # If the element is a child element, recurse
                 if children is not None:
                     # Returned value is new Data1D object with all previous and
                     # new values in it.
+                    data1d, extras = self._parse_entry(node, ns, data1d, extras)
+                    data1d, extras = self._parse_entry(node,
+                                                       names, data1d, extras)
                 #Get the information from the node
 …
                             pass
             except TypeError:
+            except TypeError as e:
                 pass
             except Exception as e:
 …
                 else:
                     save_data1d = data1d
+                data1d = save_data1d
+                # Remove tagname from ns to restore original base
+                ns.remove(tagname_original)
+                if tagname_original == "fitting_plug_in" or \
+                    tagname_original == "invariant" or \
+                    tagname_original == "pr_inversion":
+                    pass
+                else:
+                    data1d = save_data1d
+                    # Remove tagname from names to restore original base
+                    names.remove(tagname_original)
         return data1d, extras
     def _to_xml_doc(self, datainfo):
         """
 …
         :param datainfo: Data1D object
         """
         if not issubclass(datainfo.__class__, Data1D):
             raise RuntimeError, "The cansas writer expects a Data1D instance"
         # Get PIs and create root element
+        pis = self.reader.return_processing_instructions()
+        doc = self.reader.create_tree(pis[0])
+        i = 1
+        for i in range(1,len(pis) - 1):
+            doc = self.reader.append(pis[i], doc)
+        pis = self.return_processing_instructions()
+        if len(pis) > 0:
+            pi_tree = self.create_tree(pis[0])
+            i = 1
+            for i in range(1,len(pis) - 1):
+                pi_tree = self.append(pis[i], pi_tree)
+            pi_string = self.to_string(pi_tree)
+        else:
+            pi_string = ""
         # Define namespaces and create SASroot object
 …
         else:
             url = "http://svn.smallangles.net/svn/canSAS/1dwg/trunk/"
         schemaLocation = "{0} {1}cansas1d.xsd".format(ns, url)
         attrib = {"{" + xsi + "}schemaLocation" : schemaLocation,
+        schema_location = "{0} {1}cansas1d.xsd".format(ns, url)
+        attrib = {"{" + xsi + "}schemaLocation" : schema_location,
                   "version" : version}
         nsmap = {'xsi' : xsi, None: ns}
         main_node = self.reader.create_element("{" + ns + "}SASroot", \
+        main_node = self.create_element("{" + ns + "}SASroot", \
                                                attrib = attrib, \
                                                nsmap = nsmap)
         # Create ElementTree, append SASroot and apply processing instructions
+        base_string = self.reader.toString(doc) + \
+                    self.reader.toString(main_node)
+        base_element = self.reader.create_element_from_string(base_string)
+        doc = self.reader.create_tree(base_element)
+        base_string = pi_string + self.to_string(main_node)
+        base_element = self.create_element_from_string(base_string)
+        doc = self.create_tree(base_element)
         # Create SASentry Element
         entry_node = self.reader.create_element("SASentry")
+        entry_node = self.create_element("SASentry")
         root = doc.getroot()
         root.append(entry_node)
 …
         # Data info
         node = self.reader.create_element("SASdata")
         self.reader.append(node, entry_node)
+        node = self.create_element("SASdata")
+        self.append(node, entry_node)
         for i in range(len(datainfo.x)):
             pt = self.reader.create_element("Idata")
+            pt = self.create_element("Idata")
             node.append(pt)
             self.write_node(pt, "Q", datainfo.x[i], {'unit': datainfo.x_unit})
 …
                 self.write_node(pt, "dQl", datainfo.dxl[i],
                             {'unit': datainfo.x_unit})
         # Transmission Spectrum Info
         for i in range(len(datainfo.trans_spectrum)):
             spectrum = datainfo.trans_spectrum[i]
             node = self.reader.create_element("SAStransmission_spectrum",
+            node = self.create_element("SAStransmission_spectrum",
                                               {"name" : spectrum.name})
             self.reader.append(node, entry_node)
+            self.append(node, entry_node)
             if isinstance(spectrum.timestamp, datetime.datetime):
                 node.setAttribute("timestamp", spectrum.timestamp)
             for i in range(len(spectrum.wavelength)):
                 pt = self.reader.create_element("Tdata")
+                pt = self.create_element("Tdata")
                 node.append(pt)
                 self.write_node(pt, "Lambda", spectrum.wavelength[i],
 …
         # Sample info
         sample = self.reader.create_element("SASsample")
+        sample = self.create_element("SASsample")
         if datainfo.sample.name is not None:
             self.reader.write_attribute(sample,
+            self.write_attribute(sample,
                                         "name",
                                         str(datainfo.sample.name))
         self.reader.append(sample, entry_node)
+        self.append(sample, entry_node)
         self.write_node(sample, "ID", str(datainfo.sample.ID))
         self.write_node(sample, "thickness", datainfo.sample.thickness,
 …
                    {"unit": datainfo.sample.temperature_unit})
         pos = self.reader.create_element("position")
+        pos = self.create_element("position")
         written = self.write_node(pos,
                                   "x",
 …
                                        {"unit": datainfo.sample.position_unit})
         if written == True:
             self.reader.append(pos, sample)
         ori = self.reader.create_element("orientation")
+            self.append(pos, sample)
+        ori = self.create_element("orientation")
         written = self.write_node(ori, "roll",
                                   datainfo.sample.orientation.x,
 …
                                     {"unit": datainfo.sample.orientation_unit})
         if written == True:
             self.reader.append(ori, sample)
+            self.append(ori, sample)
         for item in datainfo.sample.details:
 …
         # Instrument info
         instr = self.reader.create_element("SASinstrument")
         self.reader.append(instr, entry_node)
+        instr = self.create_element("SASinstrument")
+        self.append(instr, entry_node)
         self.write_node(instr, "name", datainfo.instrument)
         #   Source
         source = self.reader.create_element("SASsource")
+        source = self.create_element("SASsource")
         if datainfo.source.name is not None:
             self.reader.write_attribute(source,
+            self.write_attribute(source,
                                         "name",
                                         str(datainfo.source.name))
         self.reader.append(source, instr)
+        self.append(source, instr)
         if datainfo.source.radiation == None or datainfo.source.radiation == '':
             datainfo.source.radiation = "neutron"
         self.write_node(source, "radiation", datainfo.source.radiation)
         size = self.reader.create_element("beam_size")
+        size = self.create_element("beam_size")
         if datainfo.source.beam_size_name is not None:
             self.reader.write_attribute(size,
+            self.write_attribute(size,
                                         "name",
                                         str(datainfo.source.beam_size_name))
 …
                                        {"unit": datainfo.source.beam_size_unit})
         if written == True:
             self.reader.append(size, source)
+            self.append(size, source)
         self.write_node(source, "beam_shape", datainfo.source.beam_shape)
 …
             datainfo.collimation.append(coll)
         for item in datainfo.collimation:
             coll = self.reader.create_element("SAScollimation")
+            coll = self.create_element("SAScollimation")
             if item.name is not None:
                 self.reader.write_attribute(coll, "name", str(item.name))
             self.reader.append(coll, instr)
+                self.write_attribute(coll, "name", str(item.name))
+            self.append(coll, instr)
             self.write_node(coll, "length", item.length,
 …
             for apert in item.aperture:
                 ap = self.reader.create_element("aperture")
+                ap = self.create_element("aperture")
                 if apert.name is not None:
                     self.reader.write_attribute(ap, "name", str(apert.name))
+                    self.write_attribute(ap, "name", str(apert.name))
                 if apert.type is not None:
                     self.reader.write_attribute(ap, "type", str(apert.type))
                 self.reader.append(ap, coll)
                 size = self.reader.create_element("size")
+                    self.write_attribute(ap, "type", str(apert.type))
+                self.append(ap, coll)
+                size = self.create_element("size")
                 if apert.size_name is not None:
                     self.reader.write_attribute(size,
+                    self.write_attribute(size,
                                                 "name",
                                                 str(apert.size_name))
 …
                                                {"unit": apert.size_unit})
                 if written == True:
                     self.reader.append(size, ap)
+                    self.append(size, ap)
                 self.write_node(ap, "distance", apert.distance,
 …
         for item in datainfo.detector:
             det = self.reader.create_element("SASdetector")
+            det = self.create_element("SASdetector")
             written = self.write_node(det, "name", item.name)
             written = written | self.write_node(det, "SDD", item.distance,
                                            {"unit": item.distance_unit})
             if written == True:
                 self.reader.append(det, instr)
+                self.append(det, instr)
             off = self.reader.create_element("offset")
+            off = self.create_element("offset")
             written = self.write_node(off, "x", item.offset.x,
                                  {"unit": item.offset_unit})
 …
                                            {"unit": item.offset_unit})
             if written == True:
                 self.reader.append(off, det)
             ori = self.reader.create_element("orientation")
+                self.append(off, det)
+            ori = self.create_element("orientation")
             written = self.write_node(ori, "roll", item.orientation.x,
                                  {"unit": item.orientation_unit})
 …
                                            {"unit": item.orientation_unit})
             if written == True:
                 self.reader.append(ori, det)
+                self.append(ori, det)
             center = self.reader.create_element("beam_center")
+            center = self.create_element("beam_center")
             written = self.write_node(center, "x", item.beam_center.x,
                                  {"unit": item.beam_center_unit})
 …
                                            {"unit": item.beam_center_unit})
             if written == True:
                 self.reader.append(center, det)
             pix = self.reader.create_element("pixel_size")
+                self.append(center, det)
+            pix = self.create_element("pixel_size")
             written = self.write_node(pix, "x", item.pixel_size.x,
                                  {"unit": item.pixel_size_unit})
 …
                                            {"unit": item.slit_length_unit})
             if written == True:
                 self.reader.append(pix, det)
+                self.append(pix, det)
         # Processes info
         for item in datainfo.process:
             node = self.reader.create_element("SASprocess")
             self.reader.append(node, entry_node)
+            node = self.create_element("SASprocess")
+            self.append(node, entry_node)
             self.write_node(node, "name", item.name)
 …
         # Note info
         if len(datainfo.notes) == 0:
             node = self.reader.create_element("SASnote")
             self.reader.append(node, entry_node)
+            node = self.create_element("SASnote")
+            self.append(node, entry_node)
         else:
             for item in datainfo.notes:
                 node = self.reader.create_element("SASnote")
                 self.reader.write_text(node, item)
                 self.reader.append(node, entry_node)
+                node = self.create_element("SASnote")
+                self.write_text(node, item)
+                self.append(node, entry_node)
         # Return the document, and the SASentry node associated with
+        # the data we just wrote
+        #      the data we just wrote
+        # If the calling function was not the cansas reader, return a minidom
+        #      object rather than an lxml object.
+        frm = inspect.stack()[1]
+        mod_name = frm[1].replace("\\", "/").replace(".pyc", "")
+        mod_name = mod_name.replace(".py", "")
+        mod = mod_name.split("/readers/")
+        mod_name = mod[1]
+        if mod_name != "cansas_reader":
+            string = self.to_string(doc, pp=False)
+            doc = parseString(string)
+            node_name = entry_node.tag
+            node_list = doc.getElementsByTagName(node_name)
+            entry_node = node_list.item(0)
         return doc, entry_node
     def write_node(self, parent, name, value, attr={}):
+    def write_node(self, parent, name, value, attr=None):
         """
         :param doc: document DOM
 …
         """
         if value is not None:
             parent = self.reader.ebuilder(parent, name, value, attr)
+            parent = self.ebuilder(parent, name, value, attr)
             return True
         return False
 …
         # Write the file
         fd = open(filename, 'w')
         if self.reader.encoding == None:
             self.reader.encoding = "UTF-8"
         doc.write(fd, encoding=self.reader.encoding,
+        if self.encoding == None:
+            self.encoding = "UTF-8"
+        doc.write(fd, encoding=self.encoding,
                   pretty_print=True, xml_declaration=True)
         fd.close()
+    # DO NOT REMOVE - used in saving and loading panel states.
+    def _store_float(self, location, node, variable, storage, optional=True):
+        """
+        Get the content of a xpath location and store
+        the result. Check that the units are compatible
+        with the destination. The value is expected to
+        be a float.
+        The xpath location might or might not exist.
+        If it does not exist, nothing is done
+        :param location: xpath location to fetch
+        :param node: node to read the data from
+        :param variable: name of the data member to store it in [string]
+        :param storage: data object that has the 'variable' data member
+        :param optional: if True, no exception will be raised
+            if unit conversion can't be done
+        :raise ValueError: raised when the units are not recognized
+        """
+        entry = get_content(location, node)
+        try:
+            value = float(entry.text)
+        except:
+            value = None
+        if value is not None:
+            # If the entry has units, check to see that they are
+            # compatible with what we currently have in the data object
+            units = entry.get('unit')
+            if units is not None:
+                toks = variable.split('.')
+                local_unit = None
+                exec "local_unit = storage.%s_unit" % toks[0]
+                if local_unit != None and units.lower() != local_unit.lower():
+                    if HAS_CONVERTER == True:
+                        try:
+                            conv = Converter(units)
+                            exec "storage.%s = %g" % (variable,
+                                           conv(value, units=local_unit))
+                        except:
+                            exc_type, exc_value, exc_traceback = sys.exc_info()
+                            err_mess = "CanSAS reader: could not convert"
+                            err_mess += " %s unit [%s]; expecting [%s]\n  %s" \
+                                % (variable, units, local_unit, exc_value)
+                            self.errors.append(err_mess)
+                            if optional:
+                                logging.info(err_mess)
+                            else:
+                                raise ValueError, err_mess
+                    else:
+                        err_mess = "CanSAS reader: unrecognized %s unit [%s];"\
+                        % (variable, units)
+                        err_mess += " expecting [%s]" % local_unit
+                        self.errors.append(err_mess)
+                        if optional:
+                            logging.info(err_mess)
+                        else:
+                            raise ValueError, err_mess
+                else:
+                    exec "storage.%s = value" % variable
+            else:
+                exec "storage.%s = value" % variable
+    # DO NOT REMOVE - used in saving and loading panel states.
+    def _store_content(self, location, node, variable, storage):
+        """
+        Get the content of a xpath location and store
+        the result. The value is treated as a string.
+        The xpath location might or might not exist.
+        If it does not exist, nothing is done
+        :param location: xpath location to fetch
+        :param node: node to read the data from
+        :param variable: name of the data member to store it in [string]
+        :param storage: data object that has the 'variable' data member
+        :return: return a list of errors
+        """
+        entry = get_content(location, node)
+        if entry is not None and entry.text is not None:
+            exec "storage.%s = entry.text.strip()" % variable

src/sans/dataloader/readers/xml_reader.py

-                      r2e3b055
+                      rac5b69d
 from lxml import etree
 from lxml.builder import E
+parser = etree.ETCompatXMLParser(remove_comments=True, remove_pis=False)
+PARSER = etree.ETCompatXMLParser(remove_comments=True, remove_pis=False)
 class XMLreader():
+    """
+    Generic XML read and write class. Mostly helper functions.
+    Makes reading/writing XML a bit easier than calling lxml libraries directly.
+    :Dependencies:
+        This class requires lxml 2.3 or higher.
+    """
     xml = None
 …
     schemadoc = None
     encoding = None
     processingInstructions = None
+    processing_instructions = None
     def __init__(self, xml = None, schema = None, root = None):
         self.xml = xml
         self.schema = schema
         self.processingInstructions = {}
+        self.processing_instructions = {}
         if xml is not None:
             self.setXMLFile(xml, root)
+            self.set_xml_file(xml, root)
         else:
             self.xmldoc = None
             self.xmlroot = None
         if schema is not None:
             self.setSchema(schema)
+            self.set_schema(schema)
         else:
             self.schemadoc = None
 …
         Read in an XML file into memory and return an lxml dictionary
         """
         if self.validateXML():
             self.xmldoc = etree.parse(self.xml, parser = parser)
+        if self.validate_xml():
+            self.xmldoc = etree.parse(self.xml, parser = PARSER)
         else:
             raise etree.ValidationError(self, self.findInvalidXML())
+            raise etree.XMLSchemaValidateError(self, self.find_invalid_xml())
         return self.xmldoc
     def setXMLFile(self, xml, root = None):
+    def set_xml_file(self, xml, root = None):
         """
         Set the XML file and parse
 …
         try:
             self.xml = xml
             self.xmldoc = etree.parse(self.xml, parser = parser)
+            self.xmldoc = etree.parse(self.xml, parser = PARSER)
             self.xmlroot = self.xmldoc.getroot()
         except Exception:
 …
             self.xmlroot = None
     def setSchema(self, schema):
+    def set_schema(self, schema):
         """
         Set the schema file and parse
 …
         try:
             self.schema = schema
             self.schemadoc = etree.parse(self.schema, parser = parser)
+            self.schemadoc = etree.parse(self.schema, parser = PARSER)
         except Exception:
             self.schema = None
             self.schemadoc = None
     def validateXML(self):
+    def validate_xml(self):
         """
         Checks to see if the XML file meets the schema
 …
         valid = True
         if self.schema is not None:
             self.parseSchemaAndDoc()
             schemaCheck = etree.XMLSchema(self.schemadoc)
             valid = schemaCheck.validate(self.xmldoc)
+            self.parse_schema_and_doc()
+            schema_check = etree.XMLSchema(self.schemadoc)
+            valid = schema_check.validate(self.xmldoc)
         return valid
     def findInvalidXML(self):
+    def find_invalid_xml(self):
         """
         Finds the first offending element that should not be present in XML file
         """
         firstError = ""
         self.parseSchemaAndDoc()
+        first_error = ""
+        self.parse_schema_and_doc()
         schema = etree.XMLSchema(self.schemadoc)
         try:
             firstError = schema.assertValid(self.xmldoc)
+            first_error = schema.assertValid(self.xmldoc)
         except etree.DocumentInvalid as e:
             firstError = str(e)
         return firstError
     def parseSchemaAndDoc(self):
+            first_error = str(e)
+        return first_error
+    def parse_schema_and_doc(self):
         """
         Creates a dictionary of the parsed schema and xml files.
         """
         self.setXMLFile(self.xml)
         self.setSchema(self.schema)
     def toString(self, elem, pp=False, encoding=None):
+        self.set_xml_file(self.xml)
+        self.set_schema(self.schema)
+    def to_string(self, elem, pp=False, encoding=None):
         """
         Converts an etree element into a string
 …
         return dic
     def setProcessingInstructions(self):
+    def set_processing_instructions(self):
         """
         Take out all processing instructions and create a dictionary from them
 …
         """
         dic = {}
         pi = self.xmlroot.getprevious()
         while pi is not None:
             pi_string = self.toString(pi)
+        proc_instr = self.xmlroot.getprevious()
+        while proc_instr is not None:
+            pi_string = self.to_string(proc_instr)
             if "?>\n<?" in pi_string:
                 pi_string = pi_string.split("?>\n<?")
 …
                 for item in pi_string:
                     dic = self.break_processing_instructions(item, dic)
             pi = pi.getprevious()
+            proc_instr = proc_instr.getprevious()
         if 'xml' in dic:
             self.setEncoding(dic['xml'])
+            self.set_encoding(dic['xml'])
             del dic['xml']
         self.processingInstructions = dic
     def setEncoding(self, attr_str):
+        self.processing_instructions = dic
+    def set_encoding(self, attr_str):
         """
         Find the encoding in the xml declaration and save it as a string
 …
         self.encoding = None
     def _create_unique_key(self, dictionary, name, i = 0):
+    def _create_unique_key(self, dictionary, name, numb = 0):
         """
         Create a unique key value for any dictionary to prevent overwriting
 …
         :param dictionary: A dictionary with any number of entries
         :param name: The index of the item to be added to dictionary
         :param i: The number to be appended to the name, starts at 0
+        :param numb: The number to be appended to the name, starts at 0
         """
         if dictionary.get(name) is not None:
             i += 1
+            numb += 1
             name = name.split("_")[0]
             name += "_{0}".format(i)
             name = self._create_unique_key(dictionary, name, i)
+            name += "_{0}".format(numb)
+            name = self._create_unique_key(dictionary, name, numb)
         return name
 …
         return etree.ElementTree(root)
     def create_element_from_string(self, s):
+    def create_element_from_string(self, xml_string):
         """
         Create an element from an XML string
         :param s: A string of xml
         """
         return etree.fromstring(s)
     def create_element(self, name, attrib={}, nsmap=None):
+        :param xml_string: A string of xml
+        """
+        return etree.fromstring(xml_string)
+    def create_element(self, name, attrib=None, nsmap=None):
         """
         Create an XML element for writing to file
 …
         :param name: The name of the element to be created
         """
+        if attrib == None:
+            attrib = {}
         return etree.Element(name, attrib, nsmap)
 …
         """
         pi_list = []
+        for key in self.processingInstructions:
+            value = self.processingInstructions.get(key)
+            pi = etree.ProcessingInstruction(key, value)
+            pi_list.append(pi)
+        if self.processing_instructions is not None:
+            for key in self.processing_instructions:
+                value = self.processing_instructions.get(key)
+                pi_item = etree.ProcessingInstruction(key, value)
+                pi_list.append(pi_item)
         return pi_list
 …
         return tree
+    def ebuilder(self, parent, elementname, text=None, attrib={}):
+    def ebuilder(self, parent, elementname, text=None, attrib=None):
+        """
+        Use lxml E builder class with arbitrary inputs.
+        :param parnet: The parent element to append a child to
+        :param elementname: The name of the child in string form
+        :param text: The element text
+        :param attrib: A dictionary of attribute names to attribute values
+        """
         text = str(text)
+        if attrib == None:
+            attrib = {}
         elem = E(elementname, attrib, text)
         parent = parent.append(elem)

src/sans/guiframe/gui_manager.py

-                      r98816c43
+                      ra3b635b
         # Append item from plugin under menu file if necessary
         self._populate_file_menu()
         if not wx.VERSION_STRING >= '3.0.0.0':
             self.SetMenuBar(self._menubar)
 …
         if config._do_aboutbox:
             self._help_menu.AppendSeparator()
+            id = wx.NewId()
+            self._help_menu.Append(id, '&About', 'Software information')
+            wx.EVT_MENU(self, id, self._onAbout)
+            self._help_menu.Append(wx.ID_ABOUT, '&About', 'Software information')
+            wx.EVT_MENU(self, wx.ID_ABOUT, self._onAbout)
         # Checking for updates
 …
                 self._file_menu.AppendSeparator()
-    def _add_menu_file(self):
-        """
-        add menu file
-        """
-        # File menu
-        self._file_menu = wx.Menu()
         style1 = self.__gui_style & GUIFRAME.MULTIPLE_APPLICATIONS
         if OPEN_SAVE_MENU:
 …
                         'Save state of the current active analysis panel')
             wx.EVT_MENU(self, id, self._on_save_application)
+        if not sys.platform =='darwin':
             self._file_menu.AppendSeparator()
+        id = wx.NewId()
+        self._file_menu.Append(id, '&Quit', 'Exit')
+        wx.EVT_MENU(self, id, self.Close)
+            id = wx.NewId()
+            self._file_menu.Append(id, '&Quit', 'Exit')
+            wx.EVT_MENU(self, id, self.Close)
+    def _add_menu_file(self):
+        """
+        add menu file
+        """
+        # File menu
+        self._file_menu = wx.Menu()
         # Add sub menus
         self._menubar.Append(self._file_menu, '&File')
 …
                 if temp is not None:
                     doc = temp
             # Write the XML document
             extens = APPLICATION_STATE_EXTENSION
 …
         except:
             msg = "Error occurred while saving: "
             msg += "To save, at leat one application panel "
+            msg += "To save, at least one application panel "
             msg += "should have a data set.."
             wx.PostEvent(self, StatusEvent(status=msg))

src/sans/perspectives/fitting/pagestate.py

-                      reddb6ec
+                      rac5b69d
 import xml.dom.minidom
+from xml.dom.minidom import parseString
 from lxml import etree
 …
             # We are appending to an existing document
             newdoc = doc
+            top_element = newdoc.createElement(FITTING_NODE_NAME)
+            try:
+                top_element = newdoc.createElement(FITTING_NODE_NAME)
+            except:
+                string = etree.tostring(doc, pretty_print=True)
+                newdoc = parseString(string)
+                top_element = newdoc.createElement(FITTING_NODE_NAME)
             if entry_node is None:
                 newdoc.documentElement.appendChild(top_element)
             else:
+                entry_node.appendChild(top_element)
+                try:
+                    entry_node.appendChild(top_element)
+                except:
+                    node_name = entry_node.tag
+                    node_list = newdoc.getElementsByTagName(node_name)
+                    entry_node = node_list.item(0)
+                    entry_node.appendChild(top_element)
         attr = newdoc.createAttribute("version")
         attr.nodeValue = '1.0'
 …
         for item in list_of_state_parameters:
             element = newdoc.createElement(item[0])
             com = "self._toXML_helper(list=self.%s,"
+            com = "self._toXML_helper(thelist=self.%s,"
             com += " element=element, newdoc=newdoc)"
             exec com % item[1]
 …
             return None
         else:
             return newdoc.toprettyxml()
+            return newdoc
     def _fromXML_helper(self, node, list):
 …
                 state = PageState()
                 state.fromXML(node=nodes[0])
         except:
             logging.info("XML document does not contain fitting information.\n %s" % sys.exc_value)
 …
         return state
     def _parse_entry(self, dom):
+    def _parse_save_state_entry(self, dom):
         """
         Parse a SASentry
 …
         node = dom.xpath('ns:data_class', namespaces={'ns': CANSAS_NS})
         if not node or node[0].text.lstrip().rstrip() != "Data2D":
+            return CansasReader._parse_entry(self, dom)
+            return_value, _ = self._parse_entry(dom)
+            numpy.trim_zeros(return_value.x)
+            numpy.trim_zeros(return_value.y)
+            numpy.trim_zeros(return_value.dy)
+            size_dx = return_value.dx.size
+            size_dxl = return_value.dxl.size
+            size_dxw = return_value.dxw.size
+            if size_dxl == 0 and size_dxw == 0:
+                return_value.dxl = None
+                return_value.dxw = None
+                numpy.trim_zeros(return_value.dx)
+            elif size_dx == 0:
+                return_value.dx = None
+                size_dx = size_dxl
+                numpy.trim_zeros(return_value.dxl)
+                numpy.trim_zeros(return_value.dxw)
+            return return_value, _
         #Parse 2D
 …
                     for entry in entry_list:
                         try:
                             sas_entry = self._parse_entry(entry)
+                            sas_entry, _ = self._parse_save_state_entry(entry)
                         except:
                             raise
 …
         # Sanity check
         if self.cansas == True:
             # Add fitting information to the XML document
             doc = self.write_toXML(datainfo, fitstate)
             # Write the XML document
-            fd = open(filename, 'w')
-            fd.write(doc.toprettyxml())
-            fd.close()
         else:
+            fitstate.toXML(file=filename)
+            doc = fitstate.toXML(file=filename)
+        # Save the document no matter the type
+        fd = open(filename, 'w')
+        fd.write(doc.toprettyxml())
+        fd.close()
     def write_toXML(self, datainfo=None, state=None):
 …
                 state.data.run = [str(state.data.name)]
                 state.data.run_name[0] = state.data.name
             if issubclass(state.data.__class__,
                           sans.dataloader.data_info.Data1D):
 …
         if state is not None:
             state.toXML(doc=doc, file=data.filename, entry_node=sasentry)
+            doc = state.toXML(doc=doc, file=data.filename, entry_node=sasentry)
         return doc

src/sans/perspectives/invariant/invariant_panel.py

-                      r5777106
+                      r92a2ecd
             if new_doc is not None:
                 if doc is not None and hasattr(doc, "firstChild"):
+                    child = new_doc.firstChild.firstChild
+                    doc.firstChild.appendChild(child)
+                    child = new_doc.getElementsByTagName("SASentry")
+                    for item in child:
+                        doc.firstChild.appendChild(item)
                 else:
                     doc = new_doc

src/sans/perspectives/invariant/invariant_state.py

-                      r51f14603
+                      r92a2ecd
         : param entry_node: XML node within the XML document at which we will append the data [optional]
         """
+        # TODO: Get this to work
         from xml.dom.minidom import getDOMImplementation
         import time
 …
             else:
                 entry_node.appendChild(top_element)
         attr = newdoc.createAttribute("version")
         attr.nodeValue = '1.0'
 …
             return None
         else:
             return newdoc.toprettyxml()
+            return newdoc
     def fromXML(self, file=None, node=None):
 …
                 for entry in entry_list:
                     sas_entry = self._parse_entry(entry)
+                    sas_entry, _ = self._parse_entry(entry)
                     invstate = self._parse_state(entry)
 …
         # Add the invariant information to the XML document
         if state is not None:
             state.toXML(datainfo.name,doc=doc, entry_node=sasentry)
+            doc = state.toXML(datainfo.name,doc=doc, entry_node=sasentry)
         return doc

src/sans/perspectives/pr/inversion_panel.py

-                      r5777106
+                      r92a2ecd
             if new_doc is not None:
                 if doc is not None and hasattr(doc, "firstChild"):
+                    child = new_doc.firstChild.firstChild
+                    doc.firstChild.appendChild(child)
+                    child = new_doc.getElementsByTagName("SASentry")
+                    for item in child:
+                        doc.firstChild.appendChild(item)
                 else:
                     doc = new_doc

src/sans/perspectives/pr/inversion_state.py

-                      r5777106
+                      r92a2ecd
         """
+        #TODO: Get this to work
         from xml.dom.minidom import getDOMImplementation
 …
             return None
         else:
             return newdoc.toprettyxml()
+            return newdoc
     def fromXML(self, file=None, node=None):
 …
                 for entry in entry_list:
                     sas_entry = self._parse_entry(entry)
+                    sas_entry, _ = self._parse_entry(entry)
                     prstate = self._parse_prstate(entry)
                     #prstate could be None when .svs file is loaded
 …
         # Sanity check
         if self.cansas == True:
             doc =self.write_toXML(datainfo, prstate)
+            doc = self.write_toXML(datainfo, prstate)
             # Write the XML document
             fd = open(filename, 'w')
 …
         # Create basic XML document
         doc, sasentry = self._to_xml_doc(datainfo)
         # Add the invariant information to the XML document
         if state is not None:
             state.toXML(doc=doc, entry_node=sasentry)
+            doc = state.toXML(doc=doc, entry_node=sasentry)
         return doc

src/sans/fit/AbstractFitEngine.py

-                      r6c00702
+                      r8d074d9
 #import logging
 import sys
+import math
 import numpy
+import math
+import park
 from sans.dataloader.data_info import Data1D
 from sans.dataloader.data_info import Data2D
+_SMALLVALUE = 1.0e-10
+class SansParameter(park.Parameter):
+    """
+    SANS model parameters for use in the PARK fitting service.
+    The parameter attribute value is redirected to the underlying
+    parameter value in the SANS model.
+    """
+    def __init__(self, name, model, data):
+        """
+            :param name: the name of the model parameter
+            :param model: the sans model to wrap as a park model
+        """
+        park.Parameter.__init__(self, name)
+        self._model, self._name = model, name
+        self.data = data
+        self.model = model
+        #set the value for the parameter of the given name
+        self.set(model.getParam(name))
+    def _getvalue(self):
+        """
+        override the _getvalue of park parameter
+        :return value the parameter associates with self.name
+        """
+        return self._model.getParam(self.name)
+    def _setvalue(self, value):
+        """
+        override the _setvalue pf park parameter
+        :param value: the value to set on a given parameter
+        """
+        self._model.setParam(self.name, value)
+    value = property(_getvalue, _setvalue)
+    def _getrange(self):
+        """
+        Override _getrange of park parameter
+        return the range of parameter
+        """
+        #if not  self.name in self._model.getDispParamList():
+        lo, hi = self._model.details[self.name][1:3]
+        if lo is None: lo = -numpy.inf
+        if hi is None: hi = numpy.inf
+        if lo > hi:
+            raise ValueError, "wrong fit range for parameters"
+        return lo, hi
+    def get_name(self):
+        """
+        """
+        return self._getname()
+    def _setrange(self, r):
+        """
+        override _setrange of park parameter
+        :param r: the value of the range to set
+        """
+        self._model.details[self.name][1:3] = r
+    range = property(_getrange, _setrange)
+class Model(park.Model):
+    """
+    PARK wrapper for SANS models.
+_SMALLVALUE = 1.0e-10
+# Note: duplicated from park
+class FitHandler(object):
+    """
+    Abstract interface for fit thread handler.
+    The methods in this class are called by the optimizer as the fit
+    progresses.
+    Note that it is up to the optimizer to call the fit handler correctly,
+    reporting all status changes and maintaining the 'done' flag.
+    """
+    done = False
+    """True when the fit job is complete"""
+    result = None
+    """The current best result of the fit"""
+    def improvement(self):
+        """
+        Called when a result is observed which is better than previous
+        results from the fit.
+        result is a FitResult object, with parameters, #calls and fitness.
+        """
+    def error(self, msg):
+        """
+        Model had an error; print traceback
+        """
+    def progress(self, current, expected):
+        """
+        Called each cycle of the fit, reporting the current and the
+        expected amount of work.   The meaning of these values is
+        optimizer dependent, but they can be converted into a percent
+        complete using (100*current)//expected.
+        Progress is updated each iteration of the fit, whatever that
+        means for the particular optimization algorithm.  It is called
+        after any calls to improvement for the iteration so that the
+        update handler can control I/O bandwidth by suppressing
+        intermediate improvements until the fit is complete.
+        """
+    def finalize(self):
+        """
+        Fit is complete; best results are reported
+        """
+    def abort(self):
+        """
+        Fit was aborted.
+        """
+    # TODO: not sure how these are used, but they are needed for running the fit
+    def update_fit(self, last=False): pass
+    def set_result(self, result=None): self.result = result
+class Model:
+    """
+    Fit wrapper for SANS models.
     """
     def __init__(self, sans_model, sans_data=None, **kw):
         """
         :param sans_model: the sans model to wrap using park interface
+        """
+        park.Model.__init__(self, **kw)
+        """
         self.model = sans_model
         self.name = sans_model.name
         self.data = sans_data
+        #list of parameters names
+        self.sansp = sans_model.getParamList()
+        #list of park parameter
+        self.parkp = [SansParameter(p, sans_model, sans_data) for p in self.sansp]
+        #list of parameter set
+        self.parameterset = park.ParameterSet(sans_model.name, pars=self.parkp)
+        self.pars = []
     def get_params(self, fitparams):
         """
         return a list of value of paramter to fit
         :param fitparams: list of paramaters name to fit
+        """
+        list_params = []
+        self.pars = []
+        self.pars = fitparams
+        for item in fitparams:
+            for element in self.parkp:
+                if element.name == str(item):
+                    list_params.append(element.value)
+        return list_params
+        """
+        return [self.model.getParam(k) for k in fitparams]
     def set_params(self, paramlist, params):
         """
         Set value for parameters to fit
         :param params: list of value for parameters to fit
+        """
+        try:
+            for i in range(len(self.parkp)):
+                for j in range(len(paramlist)):
+                    if self.parkp[i].name == paramlist[j]:
+                        self.parkp[i].value = params[j]
+                        self.model.setParam(self.parkp[i].name, params[j])
+        except:
+            raise
+        """
+        for k,v in zip(paramlist, params):
+            self.model.setParam(k,v)
+    def set(self, **kw):
+        self.set_params(*zip(*kw.items()))
     def eval(self, x):
         """
             Override eval method of park model.
             :param x: the x value used to compute a function
         """
 …
         except:
             raise
     def eval_derivs(self, x, pars=[]):
         """
 …
         instead of calling eval.
         """
+        return []
+        raise NotImplementedError('no derivatives available')
+    def __call__(self, x):
+        return self.eval(x)
 class FitData1D(Data1D):
     """
 …
         """
         Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy)
+        self.num_points = len(x)
         self.sans_data = data
         self.smearer = smearer
 …
         """
         return self.qmin, self.qmax
+    def size(self):
+        """
+        Number of measurement points in data set after masking, etc.
+        """
+        return len(self.x)
     def residuals(self, fn):
         """
 …
     def __init__(self, sans_data2d, data=None, err_data=None):
         Data2D.__init__(self, data=data, err_data=err_data)
+        """
+            Data can be initital with a data (sans plottable)
+            or with vectors.
+        """
+        # Data can be initialized with a sans plottable or with vectors.
         self.res_err_image = []
+        self.num_points = 0 # will be set by set_data
         self.idx = []
         self.qmin = None
 …
         self.idx = (self.idx) & (self.mask)
         self.idx = (self.idx) & (numpy.isfinite(self.data))
+        self.num_points = numpy.sum(self.idx)
     def set_smearer(self, smearer):
 …
         """
         return self.qmin, self.qmax
+    def size(self):
+        """
+        Number of measurement points in data set after masking, etc.
+        """
+        return numpy.sum(self.idx)
     def residuals(self, fn):
         """
 …
+class SansAssembly:
+    """
+    Sans Assembly class a class wrapper to be call in optimizer.leastsq method
+    """
+    def __init__(self, paramlist, model=None, data=None, fitresult=None,
+                 handler=None, curr_thread=None, msg_q=None):
+        """
+        :param Model: the model wrapper fro sans -model
+        :param Data: the data wrapper for sans data
+        """
+        self.model = model
+        self.data = data
+        self.paramlist = paramlist
+        self.msg_q = msg_q
+        self.curr_thread = curr_thread
+        self.handler = handler
+        self.fitresult = fitresult
+        self.res = []
+        self.true_res = []
+        self.func_name = "Functor"
+        self.theory = None
+    def chisq(self):
+        """
+        Calculates chi^2
+        :param params: list of parameter values
+        :return: chi^2
+        """
+        total = 0
+        for item in self.true_res:
+            total += item * item
+        if len(self.true_res) == 0:
+            return None
+        return total / len(self.true_res)
+    def __call__(self, params):
+        """
+            Compute residuals
+            :param params: value of parameters to fit
+        """
+        #import thread
+        self.model.set_params(self.paramlist, params)
+        #print "params", params
+        self.true_res, theory = self.data.residuals(self.model.eval)
+        self.theory = copy.deepcopy(theory)
+        # check parameters range
+        if self.check_param_range():
+            # if the param value is outside of the bound
+            # just silent return res = inf
+            return self.res
+        self.res = self.true_res
+        if self.fitresult is not None:
+            self.fitresult.set_model(model=self.model)
+            self.fitresult.residuals = self.true_res
+            self.fitresult.iterations += 1
+            self.fitresult.theory = theory
+            #fitness = self.chisq(params=params)
+            fitness = self.chisq()
+            self.fitresult.pvec = params
+            self.fitresult.set_fitness(fitness=fitness)
+            if self.msg_q is not None:
+                self.msg_q.put(self.fitresult)
+            if self.handler is not None:
+                self.handler.set_result(result=self.fitresult)
+                self.handler.update_fit()
+            if self.curr_thread != None:
+                try:
+                    self.curr_thread.isquit()
+                except:
+                    #msg = "Fitting: Terminated...       Note: Forcing to stop "
+                    #msg += "fitting may cause a 'Functor error message' "
+                    #msg += "being recorded in the log file....."
+                    #self.handler.stop(msg)
+                    raise
+        return self.res
+    def check_param_range(self):
+        """
+        Check the lower and upper bound of the parameter value
+        and set res to the inf if the value is outside of the
+        range
+        :limitation: the initial values must be within range.
+        """
+        #time.sleep(0.01)
+        is_outofbound = False
+        # loop through the fit parameters
+        for p in self.model.parameterset:
+            param_name = p.get_name()
+            if param_name in self.paramlist:
+                # if the range was defined, check the range
+                if numpy.isfinite(p.range[0]):
+                    if p.value == 0:
+                        # This value works on Scipy
+                        # Do not change numbers below
+                        value = _SMALLVALUE
+                    else:
+                        value = p.value
+                    # For leastsq, it needs a bit step back from the boundary
+                    val = p.range[0] - value * _SMALLVALUE
+                    if p.value < val:
+                        self.res *= 1e+6
+                        is_outofbound = True
+                        break
+                if numpy.isfinite(p.range[1]):
+                    # This value works on Scipy
+                    # Do not change numbers below
+                    if p.value == 0:
+                        value = _SMALLVALUE
+                    else:
+                        value = p.value
+                    # For leastsq, it needs a bit step back from the boundary
+                    val = p.range[1] + value * _SMALLVALUE
+                    if p.value > val:
+                        self.res *= 1e+6
+                        is_outofbound = True
+                        break
+        return is_outofbound
 class FitEngine:
     def __init__(self):
 …
         """
+        if model == None:
+            raise ValueError, "AbstractFitEngine: Need to set model to fit"
+        new_model = model
+        if not pars:
+            raise ValueError("no fitting parameters")
+        if model is None:
+            raise ValueError("no model to fit")
         if not issubclass(model.__class__, Model):
+            new_model = Model(model, data)
+        if len(constraints) > 0:
+            for constraint in constraints:
+                name, value = constraint
+                try:
+                    new_model.parameterset[str(name)].set(str(value))
+                except:
+                    msg = "Fit Engine: Error occurs when setting the constraint"
+                    msg += " %s for parameter %s " % (value, name)
+                    raise ValueError, msg
+        if len(pars) > 0:
+            temp = []
+            for item in pars:
+                if item in new_model.model.getParamList():
+                    temp.append(item)
+                    self.param_list.append(item)
+                else:
+                    msg = "wrong parameter %s used " % str(item)
+                    msg += "to set model %s. Choose " % str(new_model.model.name)
+                    msg += "parameter name within %s" % \
+                                str(new_model.model.getParamList())
+                    raise ValueError, msg
+            #A fitArrange is already created but contains data_list only at id
+            if self.fit_arrange_dict.has_key(id):
+                self.fit_arrange_dict[id].set_model(new_model)
+                self.fit_arrange_dict[id].pars = pars
+            else:
+            #no fitArrange object has been create with this id
+                fitproblem = FitArrange()
+                fitproblem.set_model(new_model)
+                fitproblem.pars = pars
+                self.fit_arrange_dict[id] = fitproblem
+                vals = []
+                for name in pars:
+                    vals.append(new_model.model.getParam(name))
+                self.fit_arrange_dict[id].vals = vals
+        else:
+            raise ValueError, "park_integration:missing parameters"
+            model = Model(model, data)
+        sasmodel = model.model
+        available_parameters = sasmodel.getParamList()
+        for p in pars:
+            if p not in available_parameters:
+                raise ValueError("parameter %s not available in model %s; use one of [%s] instead"
+                                 %(p, sasmodel.name, ", ".join(available_parameters)))
+        if id not in self.fit_arrange_dict:
+            self.fit_arrange_dict[id] = FitArrange()
+        self.fit_arrange_dict[id].set_model(model)
+        self.fit_arrange_dict[id].pars = pars
+        self.fit_arrange_dict[id].vals = [sasmodel.getParam(name) for name in pars]
+        self.fit_arrange_dict[id].constraints = constraints
+        self.param_list.extend(pars)
     def set_data(self, data, id, smearer=None, qmin=None, qmax=None):
         """
 …
         self.vals = []
         self.selected = 0
     def set_model(self, model):
         """
 …
         """
         return self.selected
-IS_MAC = True
-if sys.platform.count("win32") > 0:
-    IS_MAC = False
 class FResult(object):
 …
     def __init__(self, model=None, param_list=None, data=None):
         self.calls = None
-        self.pars = []
         self.fitness = None
         self.chisqr = None
 …
         self.residuals = []
         self.index = []
-        self.parameters = None
-        self.is_mac = IS_MAC
         self.model = model
         self.data = data
 …
         if self.pvec == None and self.model is None and self.param_list is None:
             return "No results"
+        n = len(self.model.parameterset)
+        result_param = zip(xrange(n), self.model.parameterset)
+        msg1 = ["[Iteration #: %s ]" % self.iterations]
+        msg3 = ["=== goodness of fit: %s ===" % (str(self.fitness))]
+        if not self.is_mac:
+            msg2 = ["P%-3d  %s......|.....%s" % \
+                (p[0], p[1], p[1].value)\
+                  for p in result_param if p[1].name in self.param_list]
+            msg = msg1 + msg3 + msg2
+        else:
+            msg = msg1 + msg3
+        msg = "\n".join(msg)
+        return msg
+        sasmodel = self.model.model
+        pars = enumerate(sasmodel.getParamList())
+        msg1 = "[Iteration #: %s ]" % self.iterations
+        msg3 = "=== goodness of fit: %s ===" % (str(self.fitness))
+        msg2 = ["P%-3d  %s......|.....%s" % (i, v, sasmodel.getParam(v))
+                for i,v in pars if v in self.param_list]
+        msg = [msg1, msg3] + msg2
+        return "\n".join(msg)
     def print_summary(self):
         """
         """
         print self
+        print str(self)

src/sans/fit/Fitting.py

-                      r5777106
+                      re3efa6b3
 from sans.fit.ScipyFitting import ScipyFit
 from sans.fit.ParkFitting import ParkFit
+from sans.fit.BumpsFitting import BumpsFit
+ENGINES={
+    'scipy': ScipyFit,
+    'park': ParkFit,
+    'bumps': BumpsFit,
+}
 class Fit(object):
 …
     """
     def __init__(self, engine='scipy'):
+    def __init__(self, engine='scipy', *args, **kw):
         """
         """
 …
         self._engine = None
         self.fitter_id = None
         self.set_engine(engine)
+        self.set_engine(engine, *args, **kw)
     def __setattr__(self, name, value):
 …
             self.__dict__[name] = value
     def set_engine(self, word):
+    def set_engine(self, word, *args, **kw):
         """
         Select the type of Fit
 …
         """
+        if word == "scipy":
+            self._engine = ScipyFit()
+        elif word == "park":
+            self._engine = ParkFit()
+        else:
+            raise ValueError, "enter the keyword scipy or park"
+        try:
+            self._engine = ENGINES[word](*args, **kw)
+        except KeyError, exc:
+            raise KeyError("fit engine should be one of scipy, park or bumps")
     def fit(self, msg_q=None, q=None, handler=None,

src/sans/fit/Loader.py

-                      r5777106
+                      r6fe5100
     This class is loading values from given file or value giving by the user
     """
     def __init__(self, x=None, y=None, dx=None, dy=None):
+        raise NotImplementedError("a code search shows that this code is not active, and you are not seeing this message")
         # variable to store loaded values
         self.x = x

src/sans/fit/ParkFitting.py

-                      r9d6d5ba
+                      r8d074d9
 from sans.fit.AbstractFitEngine import FitEngine
 from sans.fit.AbstractFitEngine import FResult
+class SansParameter(park.Parameter):
+    """
+    SANS model parameters for use in the PARK fitting service.
+    The parameter attribute value is redirected to the underlying
+    parameter value in the SANS model.
+    """
+    def __init__(self, name, model, data):
+        """
+            :param name: the name of the model parameter
+            :param model: the sans model to wrap as a park model
+        """
+        park.Parameter.__init__(self, name)
+        #self._model, self._name = model, name
+        self.data = data
+        self.model = model
+        #set the value for the parameter of the given name
+        self.set(model.getParam(name))
+        # TODO: model is missing parameter ranges for dispersion parameters
+        if name not in model.details:
+            #print "setting details for",name
+            model.details[name] = ["", None, None]
+    def _getvalue(self):
+        """
+        override the _getvalue of park parameter
+        :return value the parameter associates with self.name
+        """
+        return self.model.getParam(self.name)
+    def _setvalue(self, value):
+        """
+        override the _setvalue pf park parameter
+        :param value: the value to set on a given parameter
+        """
+        self.model.setParam(self.name, value)
+    value = property(_getvalue, _setvalue)
+    def _getrange(self):
+        """
+        Override _getrange of park parameter
+        return the range of parameter
+        """
+        #if not  self.name in self._model.getDispParamList():
+        lo, hi = self.model.details[self.name][1:3]
+        if lo is None: lo = -numpy.inf
+        if hi is None: hi = numpy.inf
+        if lo > hi:
+            raise ValueError, "wrong fit range for parameters"
+        return lo, hi
+    def get_name(self):
+        """
+        """
+        return self._getname()
+    def _setrange(self, r):
+        """
+        override _setrange of park parameter
+        :param r: the value of the range to set
+        """
+        self.model.details[self.name][1:3] = r
+    range = property(_getrange, _setrange)
+class ParkModel(park.Model):
+    """
+    PARK wrapper for SANS models.
+    """
+    def __init__(self, sans_model, sans_data=None, **kw):
+        """
+        :param sans_model: the sans model to wrap using park interface
+        """
+        park.Model.__init__(self, **kw)
+        self.model = sans_model
+        self.name = sans_model.name
+        self.data = sans_data
+        #list of parameters names
+        self.sansp = sans_model.getParamList()
+        #list of park parameter
+        self.parkp = [SansParameter(p, sans_model, sans_data) for p in self.sansp]
+        #list of parameter set
+        self.parameterset = park.ParameterSet(sans_model.name, pars=self.parkp)
+        self.pars = []
+    def get_params(self, fitparams):
+        """
+        return a list of value of paramter to fit
+        :param fitparams: list of paramaters name to fit
+        """
+        list_params = []
+        self.pars = fitparams
+        for item in fitparams:
+            for element in self.parkp:
+                if element.name == str(item):
+                    list_params.append(element.value)
+        return list_params
+    def set_params(self, paramlist, params):
+        """
+        Set value for parameters to fit
+        :param params: list of value for parameters to fit
+        """
+        try:
+            for i in range(len(self.parkp)):
+                for j in range(len(paramlist)):
+                    if self.parkp[i].name == paramlist[j]:
+                        self.parkp[i].value = params[j]
+                        self.model.setParam(self.parkp[i].name, params[j])
+        except:
+            raise
+    def eval(self, x):
+        """
+            Override eval method of park model.
+            :param x: the x value used to compute a function
+        """
+        try:
+            return self.model.evalDistribution(x)
+        except:
+            raise
+    def eval_derivs(self, x, pars=[]):
+        """
+        Evaluate the model and derivatives wrt pars at x.
+        pars is a list of the names of the parameters for which derivatives
+        are desired.
+        This method needs to be specialized in the model to evaluate the
+        model function.  Alternatively, the model can implement is own
+        version of residuals which calculates the residuals directly
+        instead of calling eval.
+        """
+        return []
 class SansFitResult(fitresult.FitResult):
     def __init__(self, *args, **kwrds):
 …
         return fitpars
     def all_results(self, result):
+    def extend_results_with_calculated_parameters(self, result):
         """
         Extend result from the fit with the calculated parameters.
 …
                 # dividing residuals by N in order to be consistent with Scipy
                 m.chisq = numpy.sum(m.residuals**2/N)
                 resid.append(m.weight*m.residuals/math.sqrt(N))
+                resid.append(m.weight*m.residuals)
         self.residuals = numpy.hstack(resid)
         N = len(self.residuals)
         self.degrees_of_freedom = N-k if N>k else 1
         self.chisq = numpy.sum(self.residuals**2)
         return self.chisq
+        return self.chisq/self.degrees_of_freedom
 class ParkFit(FitEngine):
 …
             if fproblem.get_to_fit() == 1:
                 fitproblems.append(fproblem)
         if len(fitproblems) == 0:
+        if len(fitproblems) == 0:
             raise RuntimeError, "No Assembly scheduled for Park fitting."
-            return
         for item in fitproblems:
+            parkmodel = item.get_model()
+            model = item.get_model()
+            parkmodel = ParkModel(model.model, model.data)
+            parkmodel.pars = item.pars
             if reset_flag:
                 # reset the initial value; useful for batch
 …
                     ind = item.pars.index(name)
                     parkmodel.model.setParam(name, item.vals[ind])
+            # set the constraints into the model
+            for p,v in item.constraints:
+                parkmodel.parameterset[str(p)].set(str(v))
             for p in parkmodel.parameterset:
                 ## does not allow status change for constraint parameters
                 if p.status != 'computed':
                     if p.get_name()in item.pars:
+                    if p.get_name() in item.pars:
                         ## make parameters selected for
                         #fit will be between boundaries
 …
     def fit(self, msg_q=None,
             q=None, handler=None, curr_thread=None,
                                         ftol=1.49012e-8, reset_flag=False):
+            ftol=1.49012e-8, reset_flag=False):
         """
         Performs fit with park.fit module.It can  perform fit with one model
 …
         localfit = SansFitSimplex()
         localfit.ftol = ftol
+        localfit.xtol = 1e-6
         # See `park.fitresult.FitHandler` for details.
         fitter = SansFitMC(localfit=localfit, start_points=1)
 …
         try:
             result = fit.fit(self.problem, fitter=fitter, handler=handler)
             self.problem.all_results(result)
+            self.problem.extend_results_with_calculated_parameters(result)
         except LinAlgError:
             raise ValueError, "SVD did not converge"
+        if result is None:
+            raise RuntimeError("park did not return a fit result")
         for m in self.problem.parts:
 …
             small_result.theory = theory
             small_result.residuals = residuals
+            small_result.pvec = []
+            small_result.cov = []
+            small_result.stderr = []
+            small_result.param_list = []
+            small_result.residuals = m.residuals
+            if result is not None:
+                for p in result.parameters:
+                    if p.data.name == small_result.data.name and \
+                            p.model.name == small_result.model.name:
+                        small_result.index = m.data.idx
+                        small_result.fitness = result.fitness
+                        small_result.pvec.append(p.value)
+                        small_result.stderr.append(p.stderr)
+                        name_split = p.name.split('.')
+                        name = name_split[1].strip()
+                        if len(name_split) > 2:
+                            name += '.' + name_split[2].strip()
+                        small_result.param_list.append(name)
+            small_result.index = m.data.idx
+            small_result.fitness = result.fitness
+            # Extract the parameters that are part of this model; make sure
+            # they match the fitted parameters for this model, and place them
+            # in the same order as they occur in the model.
+            pars = {}
+            for p in result.parameters:
+                #if p.data.name == small_result.data.name and
+                if p.model.name == small_result.model.name:
+                    model_name, par_name = p.name.split('.', 1)
+                    pars[par_name] = (p.value, p.stderr)
+            #assert len(pars.keys()) == len(m.model.pars)
+            v,dv = zip(*[pars[p] for p in m.model.pars])
+            small_result.pvec = v
+            small_result.stderr = dv
+            small_result.param_list = m.model.pars
+            # normalize chisq by degrees of freedom
+            dof = len(small_result.residuals)-len(small_result.pvec)
+            small_result.fitness = numpy.sum(residuals**2)/dof
             result_list.append(small_result)
         if q != None:

src/sans/fit/ScipyFitting.py

-                      r5777106
+                      r8d074d9
 """
 ScipyFitting module contains FitArrange , ScipyFit,
 …
 simple fit with scipy optimizer.
 """
+import sys
+import copy
 import numpy
-import sys
 from sans.fit.AbstractFitEngine import FitEngine
+from sans.fit.AbstractFitEngine import SansAssembly
+from sans.fit.AbstractFitEngine import FitAbort
+from sans.fit.AbstractFitEngine import Model
+from sans.fit.AbstractFitEngine import FResult
+from sans.fit.AbstractFitEngine import FResult
+class SansAssembly:
+    """
+    Sans Assembly class a class wrapper to be call in optimizer.leastsq method
+    """
+    def __init__(self, paramlist, model=None, data=None, fitresult=None,
+                 handler=None, curr_thread=None, msg_q=None):
+        """
+        :param Model: the model wrapper fro sans -model
+        :param Data: the data wrapper for sans data
+        """
+        self.model = model
+        self.data = data
+        self.paramlist = paramlist
+        self.msg_q = msg_q
+        self.curr_thread = curr_thread
+        self.handler = handler
+        self.fitresult = fitresult
+        self.res = []
+        self.true_res = []
+        self.func_name = "Functor"
+        self.theory = None
+    def chisq(self):
+        """
+        Calculates chi^2
+        :param params: list of parameter values
+        :return: chi^2
+        """
+        total = 0
+        for item in self.true_res:
+            total += item * item
+        if len(self.true_res) == 0:
+            return None
+        return total / (len(self.true_res) - len(self.paramlist))
+    def __call__(self, params):
+        """
+            Compute residuals
+            :param params: value of parameters to fit
+        """
+        #import thread
+        self.model.set_params(self.paramlist, params)
+        #print "params", params
+        self.true_res, theory = self.data.residuals(self.model.eval)
+        self.theory = copy.deepcopy(theory)
+        # check parameters range
+        if self.check_param_range():
+            # if the param value is outside of the bound
+            # just silent return res = inf
+            return self.res
+        self.res = self.true_res
+        if self.fitresult is not None:
+            self.fitresult.set_model(model=self.model)
+            self.fitresult.residuals = self.true_res
+            self.fitresult.iterations += 1
+            self.fitresult.theory = theory
+            #fitness = self.chisq(params=params)
+            fitness = self.chisq()
+            self.fitresult.pvec = params
+            self.fitresult.set_fitness(fitness=fitness)
+            if self.msg_q is not None:
+                self.msg_q.put(self.fitresult)
+            if self.handler is not None:
+                self.handler.set_result(result=self.fitresult)
+                self.handler.update_fit()
+            if self.curr_thread != None:
+                try:
+                    self.curr_thread.isquit()
+                except:
+                    #msg = "Fitting: Terminated...       Note: Forcing to stop "
+                    #msg += "fitting may cause a 'Functor error message' "
+                    #msg += "being recorded in the log file....."
+                    #self.handler.stop(msg)
+                    raise
+        return self.res
+    def check_param_range(self):
+        """
+        Check the lower and upper bound of the parameter value
+        and set res to the inf if the value is outside of the
+        range
+        :limitation: the initial values must be within range.
+        """
+        #time.sleep(0.01)
+        is_outofbound = False
+        # loop through the fit parameters
+        model = self.model.model
+        for p in self.paramlist:
+            value = model.getParam(p)
+            low,high = model.details[p][1:3]
+            if low is not None and numpy.isfinite(low):
+                if p.value == 0:
+                    # This value works on Scipy
+                    # Do not change numbers below
+                    value = _SMALLVALUE
+                # For leastsq, it needs a bit step back from the boundary
+                val = low - value * _SMALLVALUE
+                if value < val:
+                    self.res *= 1e+6
+                    is_outofbound = True
+                    break
+            if high is not None and numpy.isfinite(high):
+                # This value works on Scipy
+                # Do not change numbers below
+                if value == 0:
+                    value = _SMALLVALUE
+                # For leastsq, it needs a bit step back from the boundary
+                val = high + value * _SMALLVALUE
+                if value > val:
+                    self.res *= 1e+6
+                    is_outofbound = True
+                    break
+        return is_outofbound
 class ScipyFit(FitEngine):
 …
         """
         FitEngine.__init__(self)
-        self.fit_arrange_dict = {}
-        self.param_list = []
         self.curr_thread = None
     #def fit(self, *args, **kw):
 …
             msg = "Scipy can't fit more than a single fit problem at a time."
             raise RuntimeError, msg
+            return
+        elif len(fitproblem) == 0 :
+        elif len(fitproblem) == 0 :
             raise RuntimeError, "No Assembly scheduled for Scipy fitting."
-            return
         model = fitproblem[0].get_model()
         if reset_flag:
 …
         # Check the initial value if it is within range
         self._check_param_range(model)
+        _check_param_range(model.model, self.param_list)
+        result = FResult(model=model, data=data, param_list=self.param_list)
+        result.pars = fitproblem[0].pars
+        result = FResult(model=model.model, data=data, param_list=self.param_list)
         result.fitter_id = self.fitter_id
         if handler is not None:
             handler.set_result(result=result)
+        functor = SansAssembly(paramlist=self.param_list,
+                               model=model,
+                               data=data,
+                               handler=handler,
+                               fitresult=result,
+                               curr_thread=curr_thread,
+                               msg_q=msg_q)
         try:
             # This import must be here; otherwise it will be confused when more
 …
             from scipy import optimize
-            functor = SansAssembly(paramlist=self.param_list,
-                                   model=model,
-                                   data=data,
-                                    handler=handler,
-                                    fitresult=result,
-                                     curr_thread=curr_thread,
-                                     msg_q=msg_q)
             out, cov_x, _, mesg, success = optimize.leastsq(functor,
                                             model.get_params(self.param_list),
                                                     ftol=ftol,
                                                     full_output=1)
+                                            ftol=ftol,
+                                            full_output=1)
         except:
             if hasattr(sys, 'last_type') and sys.last_type == KeyboardInterrupt:
 …
+    def _check_param_range(self, model):
+        """
+        Check parameter range and set the initial value inside
+        if it is out of range.
+        : model: park model object
+        """
+        is_outofbound = False
+        # loop through parameterset
+        for p in model.parameterset:
+            param_name = p.get_name()
+            # proceed only if the parameter name is in the list of fitting
+            if param_name in self.param_list:
+                # if the range was defined, check the range
+                if numpy.isfinite(p.range[0]):
+                    if p.value <= p.range[0]:
+                        # 10 % backing up from the border if not zero
+                        # for Scipy engine to work properly.
+                        shift = self._get_zero_shift(p.range[0])
+                        new_value = p.range[0] + shift
+                        p.value =  new_value
+                        is_outofbound = True
+                if numpy.isfinite(p.range[1]):
+                    if p.value >= p.range[1]:
+                        shift = self._get_zero_shift(p.range[1])
+                        # 10 % backing up from the border if not zero
+                        # for Scipy engine to work properly.
+                        new_value = p.range[1] - shift
+                        # Check one more time if the new value goes below
+                        # the low bound, If so, re-evaluate the value
+                        # with the mean of the range.
+                        if numpy.isfinite(p.range[0]):
+                            if new_value < p.range[0]:
+                                new_value = (p.range[0] + p.range[1]) / 2.0
+                        # Todo:
+                        # Need to think about when both min and max are same.
+                        p.value =  new_value
+                        is_outofbound = True
+        return is_outofbound
+    def _get_zero_shift(self, range):
+        """
+        Get 10% shift of the param value = 0 based on the range value
+        : param range: min or max value of the bounds
+        """
+        if range == 0:
+            shift = 0.1
+        else:
+            shift = 0.1 * range
+        return shift
+def _check_param_range(model, param_list):
+    """
+    Check parameter range and set the initial value inside
+    if it is out of range.
+    : model: park model object
+    """
+    # loop through parameterset
+    for p in param_list:
+        value = model.getParam(p)
+        low,high = model.details.setdefault(p,["",None,None])[1:3]
+        # if the range was defined, check the range
+        if low is not None and value <= low:
+            value = low + _get_zero_shift(low)
+        if high is not None and value > high:
+            value = high - _get_zero_shift(high)
+            # Check one more time if the new value goes below
+            # the low bound, If so, re-evaluate the value
+            # with the mean of the range.
+            if low is not None and value < low:
+                value = 0.5 * (low+high)
+        model.setParam(p, value)
+def _get_zero_shift(limit):
+    """
+    Get 10% shift of the param value = 0 based on the range value
+    : param range: min or max value of the bounds
+    """
+    return 0.1 * (limit if limit != 0.0 else 1.0)
 #def profile(fn, *args, **kw):

src/sans/fit/init.py

r5777106	r6fe5100
	1	from .AbstractFitEngine import FitHandler

src/sans/perspectives/fitting/basepage.py

-                      r116e1a7
+                      r5bf0331
             infor = "warning"
         else:
             msg = "Error was occured "
             msg += ": No valid parameter values to paste from the clipboard..."
+            msg = "Error occured: "
+            msg += "No valid parameter values to paste from the clipboard..."
             infor = "error"
             wx.PostEvent(self._manager.parent,
 …
                 else:
                     tcrtl.SetBackgroundColour("pink")
                     msg = "Model Error:wrong value entered: %s" % sys.exc_value
+                    msg = "Model Error: wrong value entered: %s" % sys.exc_value
                     wx.PostEvent(self.parent, StatusEvent(status=msg))
                     return
             except:
                 tcrtl.SetBackgroundColour("pink")
                 msg = "Model Error:wrong value entered: %s" % sys.exc_value
+                msg = "Model Error: wrong value entered: %s" % sys.exc_value
                 wx.PostEvent(self.parent, StatusEvent(status=msg))
                 return
 …
                         #is_modified = True
                 else:
                     msg = "Cannot Plot :No npts in that Qrange!!!  "
+                    msg = "Cannot plot: No points in Q range!!!  "
                     wx.PostEvent(self.parent, StatusEvent(status=msg))
         else:
             tcrtl.SetBackgroundColour("pink")
             msg = "Model Error:wrong value entered!!!"
+            msg = "Model Error: wrong value entered!!!"
             wx.PostEvent(self.parent, StatusEvent(status=msg))
         self.save_current_state()
 …
                 else:
                     tcrtl.SetBackgroundColour("pink")
                     msg = "Model Error:wrong value entered: %s" % sys.exc_value
+                    msg = "Model Error: wrong value entered: %s" % sys.exc_value
                     wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
                     return
             except:
                 tcrtl.SetBackgroundColour("pink")
                 msg = "Model Error:wrong value entered: %s" % sys.exc_value
+                msg = "Model Error: wrong value entered: %s" % sys.exc_value
                 wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
                 return
 …
                         is_modified = True
                 else:
                     msg = "Cannot Plot :No npts in that Qrange!!!  "
+                    msg = "Cannot Plot: No points in Q range!!!  "
                     wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
         else:
             tcrtl.SetBackgroundColour("pink")
             msg = "Model Error:wrong value entered!!!"
+            msg = "Model Error: wrong value entered!!!"
             wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
         self.save_current_state()
 …
                 self.qmax.SetBackgroundColour("pink")
                 self.qmax.Refresh()
                 msg = "Npts of Data Error :"
                 msg += "No or too little npts of %s." % data.name
+                msg = "Data Error: "
+                msg += "Too few points in %s." % data.name
                 wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
                 self.fitrange = False
 …
                 self.qmax.SetBackgroundColour("pink")
                 self.qmax.Refresh()
                 msg = "Npts of Data Error :"
                 msg += "No or too little npts of %s." % data.name
+                msg = "Data Error: "
+                msg += "Too few points in %s." % data.name
                 wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
                 self.fitrange = False
 …
                         except:
                             msg = "Wrong Fit parameter range entered "
+                            msg = "Wrong fit parameter range entered"
                             wx.PostEvent(self._manager.parent,
                                          StatusEvent(status=msg))

src/sans/perspectives/fitting/console.py

-                      r5777106
+                      r644ca73
 import time
 import wx
+import park
+from park.fitresult import FitHandler
+from sans.fit import FitHandler
 class ConsoleUpdate(FitHandler):
 …
         Print result object
         """
         msg = " \n %s \n" % self.result.__str__()
+        msg = " \n %s \n" % str(self.result)
         wx.PostEvent(self.parent, StatusEvent(status=msg))
 …
         self.fit_duration += self.elapsed_time
         str_time = time.strftime("%a, %d %b %Y %H:%M:%S ", time.localtime(t1))
         UPDATE_INTERVAL = 0.5
+        UPDATE_INTERVAL = 5.0
         u_flag = False
         if self.fit_duration >= UPDATE_INTERVAL:

src/sans/perspectives/fitting/fit_thread.py

-                      ra855fec
+                      re3efa6b3
     def __init__(self,
                   fn,
                   page_id,
                    handler,
                     batch_outputs,
                     batch_inputs=None,
                   pars=None,
+                 fn,
+                 page_id,
+                 handler,
+                 batch_outputs,
+                 batch_inputs=None,
+                 pars=None,
                  completefn = None,
                  updatefn   = None,
 …
                  ftol       = None,
                  reset_flag = False):
+        CalcThread.__init__(self,completefn,
+        CalcThread.__init__(self,
+                 completefn,
                  updatefn,
                  yieldtime,
 …
                 list_map_get_attr.append(map_getattr)
             #from multiprocessing import Pool
             inputs = zip(list_map_get_attr,self.fitter, list_fit_function,
                           list_q, list_q, list_handler,list_curr_thread,list_ftol,
+            inputs = zip(list_map_get_attr, self.fitter, list_fit_function,
+                         list_q, list_q, list_handler,list_curr_thread,list_ftol,
                          list_reset_flag)
             result =  map(map_apply, inputs)
 …
             self.complete(result=result,
                           batch_inputs=self.batch_inputs,
                            batch_outputs=self.batch_outputs,
+                          batch_outputs=self.batch_outputs,
                           page_id=self.page_id,
                           pars = self.pars,

src/sans/perspectives/fitting/fitpage.py

-                      rd44648e
+                      r4e9f227
                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
         if self.engine_type == "park":
+        if self.engine_type in ("park","bumps"):
             self.text_disp_max.Show(True)
             self.text_disp_min.Show(True)
 …
                                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
                         if self.engine_type == "park":
+                        if self.engine_type in ("park","bumps"):
                             ctl3.Show(True)
                             ctl4.Show(True)
 …
             return
         if len(self._manager.fit_thread_list) > 0 and\
                     self._manager._fit_engine != "park" and\
                     self._manager.sim_page != None and \
                     self._manager.sim_page.uid == self.uid:
+        if (len(self._manager.fit_thread_list) > 0
+                and self._manager._fit_engine not in ("park","bumps")
+                and self._manager.sim_page != None
+                and self._manager.sim_page.uid == self.uid):
             msg = "The FitEnging will be set to 'ParkMC'\n"
             msg += " to fit with more than one data set..."
 …
         if chisqr != None and numpy.isfinite(chisqr):
             #format chi2
             if self.engine_type == "park":
+            if self.engine_type in ("park","bumps"):
                 npt_fit = float(self.get_npts2fit())
             chi2 = format_number(chisqr, True)

src/sans/perspectives/fitting/fitproblem.py

r5777106	r5bf0331
454	454	return self.itervalues()
455	455
456		def set_result(self, result, fid):
	456	def set_result(self, result, fid):
457	457	"""
458	458	"""

src/sans/perspectives/fitting/fitting.py

-                      r767514a
+                      r4e9f227
 from .fitproblem import FitProblemDictionary
 from .fitpanel import FitPanel
+from .resultpanel import ResultPanel, PlotResultEvent
 from .fit_thread import FitThread
 from .pagestate import Reader
 …
         self.scipy_id = wx.NewId()
         self.park_id = wx.NewId()
+        self.bumps_id = wx.NewId()
         self.menu1 = None
         self.new_model_frame = None
 …
         wx.EVT_MENU(owner, self.park_id, self._onset_engine_park)
+        bumps_help = "Bumps: fitting and uncertainty analysis. More in Help window...."
+        self.menu1.AppendCheckItem(self.bumps_id, "Bumps fit",
+                                   bumps_help)
+        wx.EVT_MENU(owner, self.bumps_id, self._onset_engine_bumps)
         self.menu1.FindItemById(self.scipy_id).Check(True)
         self.menu1.FindItemById(self.park_id).Check(False)
+        self.menu1.FindItemById(self.bumps_id).Check(False)
         self.menu1.AppendSeparator()
         self.id_tol = wx.NewId()
 …
                                    ftol_help)
         wx.EVT_MENU(owner, self.id_tol, self.show_ftol_dialog)
+        self.id_bumps_options = wx.NewId()
+        bopts_help = "Bumps fitting options"
+        self.menu1.Append(self.id_bumps_options, 'Bumps &Options', bopts_help)
+        wx.EVT_MENU(owner, self.id_bumps_options, self.on_bumps_options)
+        self.bumps_options_menu = self.menu1.FindItemById(self.id_bumps_options)
+        self.bumps_options_menu.Enable(True)
+        self.id_result_panel = wx.NewId()
+        self.menu1.Append(self.id_result_panel, "Fit Results", "Show fit results panel")
+        wx.EVT_MENU(owner, self.id_result_panel, lambda ev: self.result_frame.Show())
         self.menu1.AppendSeparator()
 …
         self.perspective = []
         self.perspective.append(self.fit_panel.window_name)
+        self.result_frame = MDIFrame(self.parent, None, ResultPanel.window_caption, (220, 200))
+        self.result_panel = ResultPanel(parent=self.result_frame, manager=self)
+        self.perspective.append(self.result_panel.window_name)
         #index number to create random model name
 …
         #Send the fitting panel to guiframe
         self.mypanels.append(self.fit_panel)
+        self.mypanels.append(self.result_panel)
         return self.mypanels
 …
                          StatusEvent(status=msg, info='warning'))
         dialog.Destroy()
+    def on_bumps_options(self, event=None):
+        from bumps.gui.fit_dialog import OpenFitOptions
+        OpenFitOptions()
     def stop_fit(self, uid):
 …
         self._gui_engine = self._return_engine_type()
         self.fitproblem_count = fitproblem_count
         if self._fit_engine == "park":
+        if self._fit_engine in ("park","bumps"):
             engineType = "Simultaneous Fit"
         else:
 …
             #simulatanous fit only one engine need to be created
             ## if simultaneous fit change automatically the engine to park
+            self._on_change_engine(engine='park')
+            if self._fit_engine not in ("park","bumps"):
+                self._on_change_engine(engine='park')
             sim_fitter = Fit(self._fit_engine)
             sim_fitter.fitter_id = self.sim_page.uid
 …
         self.fitproblem_count = fitproblem_count
         if self._fit_engine == "park":
+        if self._fit_engine in ("park","bumps"):
             engineType = "Simultaneous Fit"
         else:
 …
         wx.PostEvent(self.parent, StatusEvent(status=msg, info="info",
                                                       type="stop"))
+        wx.PostEvent(self.result_panel, PlotResultEvent(result=result))
         # reset fit_engine if changed by simul_fit
         if self._fit_engine != self._gui_engine:
 …
         self._on_change_engine('scipy')
+    def _onset_engine_bumps(self, event):
+        """
+        set engine to bumps
+        """
+        self._on_change_engine('bumps')
     def _on_slicer_event(self, event):
         """
 …
             self.menu1.FindItemById(self.park_id).Check(True)
             self.menu1.FindItemById(self.scipy_id).Check(False)
+            self.menu1.FindItemById(self.bumps_id).Check(False)
+        elif engine == "scipy":
+            self.menu1.FindItemById(self.park_id).Check(False)
+            self.menu1.FindItemById(self.scipy_id).Check(True)
+            self.menu1.FindItemById(self.bumps_id).Check(False)
         else:
             self.menu1.FindItemById(self.park_id).Check(False)
+            self.menu1.FindItemById(self.scipy_id).Check(True)
+            self.menu1.FindItemById(self.scipy_id).Check(False)
+            self.menu1.FindItemById(self.bumps_id).Check(True)
         ## post a message to status bar
         msg = "Engine set to: %s" % self._fit_engine

src/sans/perspectives/fitting/simfitpage.py

-                      r5777106
+                      r4e9f227
         ## making sure all parameters content a constraint
         ## validity of the constraint expression is own by fit engine
         if self.parent._manager._fit_engine != "park" and flag:
+        if self.parent._manager._fit_engine not in ("park","bumps") and flag:
             msg = "The FitEnging will be set to 'Park' fit engine\n"
             msg += " for the simultaneous fit..."
 …
         box_description = wx.StaticBox(self, -1,"Easy Setup ")
         boxsizer = wx.StaticBoxSizer(box_description, wx.HORIZONTAL)
         sizer_constraint = wx.BoxSizer(wx.HORIZONTAL|wx.LEFT|wx.RIGHT|wx.EXPAND)
+        sizer_constraint = wx.BoxSizer(wx.HORIZONTAL)
         self.model_cbox_left = wx.ComboBox(self, -1, style=wx.CB_READONLY)
         self.model_cbox_left.Clear()

SasView

Changeset 786685e in sasview for src

Legend:

src/sans/dataloader/readers/cansas_constants.py

src/sans/dataloader/readers/cansas_reader.py

src/sans/dataloader/readers/xml_reader.py

src/sans/guiframe/gui_manager.py

src/sans/perspectives/fitting/pagestate.py

src/sans/perspectives/invariant/invariant_panel.py

src/sans/perspectives/invariant/invariant_state.py

src/sans/perspectives/pr/inversion_panel.py

src/sans/perspectives/pr/inversion_state.py

src/sans/fit/AbstractFitEngine.py

src/sans/fit/Fitting.py

src/sans/fit/Loader.py

src/sans/fit/ParkFitting.py

src/sans/fit/ScipyFitting.py

src/sans/fit/init.py

src/sans/perspectives/fitting/basepage.py

src/sans/perspectives/fitting/console.py

src/sans/perspectives/fitting/fit_thread.py

src/sans/perspectives/fitting/fitpage.py

src/sans/perspectives/fitting/fitproblem.py

src/sans/perspectives/fitting/fitting.py

src/sans/perspectives/fitting/simfitpage.py

Download in other formats: