Changeset 8b74155d – SasView

park-1.2.1/park/expression.py

-                      r3570545
+                      re3efa6b3
 """%("\n    ".join(exprs),"\n    ".join(code))
     #print "Function:",function
+    #print "Function:",functiondef
     exec functiondef in globals,locals
     retfn = locals['eval_expressions']
 …
     # Check symbol rename
     assert substitute(expr,{'a.b.x':'Q'}) == 'Q + sin(4*pi*a.c) + Q/a.b'
+    assert substitute(expr,{'a.b':'Q'}) == 'a.b.x + sin(4*pi*a.c) + a.b.x/Q'
 …
     for expr in ['G4.cage', 'M0.cage', 'M1.G1 + *2',
                  'piddle',
                  'import sys; print "p0wned"',
+                 '5; import sys; print "p0wned"',
                  '__import__("sys").argv']:
         try:

park-1.2.1/park/fitresult.py

-                      r3570545
+                      r95d58d3
         improvements.
         """
+        #import traceback; traceback.print_stack()
         self.progress_time = time.time()
         self.progress_percent = 0
 …
     def __str__(self):
+        #import traceback; traceback.print_stack()
         if self.parameters == None: return "No results"
         L = ["P%-3d %s"%(n+1,p.summarize()) for n,p in enumerate(self.parameters)]

park-1.2.1/park/parameter.py

-                      r3570545
+                      rfb7180c
 __all__ = ['Parameter', 'ParameterSet']
+import math
 import numpy
 import expression
 …
         """
         range = ['.']*10
         lo,hi = p.range
         portion = (p.value-lo)/(hi-lo)
+        lo,hi = self.range
+        portion = (self.value-lo)/(hi-lo)
         if portion < 0: portion = 0.
         elif portion >= 1: portion = 0.99999999
 …
         range[bar] = '|'
         range = "".join(range)
         return "%25s %s %g in [%g,%g]"  % (p.name,range,p.value,lo,hi)
+        return "%25s %s %g in [%g,%g]"  % (self.name,range,self.value,lo,hi)
     def isfitted(self): return self.status == 'fitted'
 …
         for p in self:
             if parts[1] == p.name:
                 if len(pars) == 2:
+                if len(parts) == 2:
                     return p
                 elif isinstance(p, ParameterSet):
                     return p._byname(parts[1:])
+                else:
+                    raise
         return None
 …
         parts = name.split('.')
         if parts[0] == self.name:
             p =  _byname(self, name.split('.'))
+            p =  self._byname(name.split('.'))
             if p: return p
         raise KeyError("parameter %s not in parameter set"%name)

run.py

-                      rbbd97e5
+                      rf8940db
 Usage:
+./run.py [args]
+./run.py [(module|script) args...]
+Without arguments run.py runs sasview.  With arguments, run.py will run
+the given module or script.
 """
 …
 import sys
 import imp
-from glob import glob
 from contextlib import contextmanager
 from os.path import abspath, dirname, join as joinpath
 …
     return mod
 def import_dll(modname):
+def import_dll(modname, build_path):
     """Import a DLL from the build directory"""
+    import sysconfig
+    ext = sysconfig.get_config_var('SO')
     # build_path comes from context
     path = glob(joinpath(build_path, *modname.split('.'))+'.*')[0]
+    path = joinpath(build_path, *modname.split('.'))+ext
     #print "importing", modname, "from", path
     return imp.load_dynamic(modname, path)
 …
     # Make sure that we have a private version of mplconfig
     mplconfig = joinpath(abspath(dirname(__file__)), '.mplconfig')
     os.environ['MPLCONFIGDIR'] = mplconfig
     if not os.path.exists(mplconfig): os.mkdir(mplconfig)
+    #mplconfig = joinpath(abspath(dirname(__file__)), '.mplconfig')
+    #os.environ['MPLCONFIGDIR'] = mplconfig
+    #if not os.path.exists(mplconfig): os.mkdir(mplconfig)
     #import matplotlib
     #matplotlib.use('Agg')
 …
     try: import periodictable
     except: addpath(joinpath(root, '..','periodictable'))
+    try: import bumps
+    except: addpath(joinpath(root, '..','bumps'))
     # select wx version
 …
     sans.pr.core = import_package('sans.pr.core',
                                   joinpath(build_path, 'sans', 'pr', 'core'))
     #import_dll('park._modeling')
+    #import_dll('park._modeling', build_path)
     #park = import_package('park',os.path.join(build_path,'park'))
 …
 if __name__ == "__main__":
-    # start sasview
-    #import multiprocessing
-    #multiprocessing.freeze_support()
     prepare()
     from sans.sansview.sansview import SasView
     SasView()
+    from sans.sansview.sansview import run
+    run()

sansview/sansview.py

-                      re2271c5
+                      r1790664
 PLUGIN_MODEL_DIR = 'plugin_models'
 APP_NAME = 'SasView'
+def run():
+    sys.path.append(os.path.join("..","..",".."))
+    from multiprocessing import freeze_support
+    freeze_support()
+    sasview = SasView()
 class SasViewApp(gui_manager.ViewApp):
     """
 …
         # modules. We load the fitting module here
         # to ensure a complete Windows executable build.
         # Fitting perspective
         try:
 …
             logging.error("Fitting problems: " + str(inst))
             logging.error("%s: could not find Fitting plug-in module"% APP_NAME)
             logging.error(sys.exc_value)
+            logging.error(sys.exc_value)
         # P(r) perspective
         try:
 …
         self.gui.clean_plugin_models(PLUGIN_MODEL_DIR)
         # Start the main loop
+        self.gui.MainLoop()
+        self.gui.MainLoop()
+if __name__ == "__main__":
+def run():
     from multiprocessing import freeze_support
     freeze_support()
+    #Process(target=SasView).start()
+    sasview = SasView()
+    if len(sys.argv) > 1:
+        ## Run sasview as an interactive python interpreter
+        #if sys.argv[1] == "-i":
+        #    sys.argv = ["ipython", "--pylab"]
+        #    from IPython import start_ipython
+        #    sys.exit(start_ipython())
+        thing_to_run = sys.argv[1]
+        sys.argv = sys.argv[1:]
+        import runpy
+        if os.path.exists(thing_to_run):
+            runpy.run_path(thing_to_run, run_name="__main__")
+        else:
+            runpy.run_module(thing_to_run, run_name="__main__")
+    else:
+        SasView()
+if __name__ == "__main__":
+    run()

sansview/setup_exe.py

r27b7acc	r6fe5100
319	319	'reportlab.platypus',
320	320	])
	321	packages.append('IPython')
321	322	includes = ['site']
322	323

setup.py

-                      r968aa6e
+                      r8b74155d
 enable_openmp = True
+enable_openmp = True
 if sys.platform =='darwin':
 …
 #            'wxPython>=2.8.11', 'pil',
 #            'periodictable>=1.3.0', 'scipy>=0.7.2']
+required = ['lxml','periodictable>=1.3.1','pyparsing<2.0.0']
+required = ['lxml', 'periodictable>=1.3.1', 'pyparsing<2.0.0'
+        'bumps', 'numdifftools']
 if os.name=='nt':

src/sans/fit/AbstractFitEngine.py

-                      r6c00702
+                      rbf5e985
 #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):
 …
         Base class for scipy and park fit engine
         """
-        #List of parameter names to fit
-        self.param_list = []
         #Dictionnary of fitArrange element (fit problems)
         self.fit_arrange_dict = {}
 …
         """
+        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
     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
+                      r1792311
 """
 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
+_SMALLVALUE = 1.0e-10
+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()
+        pars = fitproblem[0].pars
         if reset_flag:
             # reset the initial value; useful for batch
 …
         # Check the initial value if it is within range
         self._check_param_range(model)
+        _check_param_range(model.model, pars)
+        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=pars)
         result.fitter_id = self.fitter_id
         if handler is not None:
             handler.set_result(result=result)
+        functor = SansAssembly(paramlist=pars,
+                               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)
+                                            model.get_params(pars),
+                                            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, pars):
+    """
+    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 pars:
+        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/guiframe/gui_statusbar.py

r8001331	r0e29289
211	211	"""
212	212	"""
213		wxStatusB.SetStatusText(self, text, number)
	213	wxStatusB.SetStatusText(self, text.split('\n',1)[0], number)
214	214	self.list_msg.append(text)
215	215	self.status_color.SetBackgroundColour(GREEN)

src/sans/perspectives/fitting/basepage.py

-                      r116e1a7
+                      rbf5e985
         self.num_points = None
         ## default fitengine type
         self.engine_type = 'scipy'
+        self.engine_type = 'bumps'
         ## smear default
         self.current_smearer = None
 …
             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))
 …
             self.qmin.SetValue(str(self.qmin_x))
             self.qmax.SetValue(str(self.qmax_x))
             self.set_npts2fit()
+            self.show_npts2fit()
             # At this point, some button and variables satatus (disabled?)
             # should be checked such as color that should be reset to
 …
         to fit if implemented
         """
     def set_npts2fit(self):
+    def show_npts2fit(self):
         """
         setValue Npts for fitting if implemented

src/sans/perspectives/fitting/console.py

-                      r5777106
+                      r35086c3
 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))
 …
     def update_fit(self, msg="", last=False):
+    def update_fit(self, last=False):
         """
         """
 …
         self.update_duration = t1
         self.fit_duration += self.elapsed_time
         str_time = time.strftime("%a, %d %b %Y %H:%M:%S ", time.localtime(t1))
         UPDATE_INTERVAL = 0.5
+        str_time = time.strftime("%Y-%m-%d %H:%M:%S ", time.localtime(t1))
+        UPDATE_INTERVAL = 5.0
         u_flag = False
         if self.fit_duration >= UPDATE_INTERVAL:
             self.fit_duration = 0
             u_flag = True
+        if not last:
+            msg += "Fit Updates ... %s \n" % str_time
+        else:
+            msg += "Final updates ........."
+        msg = str_time
         if u_flag or last:
             if self.result is not None:
 …
                 msg +=  str(self.result)
                 msg += "\n"
-                if not last:
-                    msg += "About %s s elapsed......... \n" % \
-                                            str (UPDATE_INTERVAL)
             else:
                 msg += "No result available\n"

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
+                      rbf5e985
                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
+        if self.engine_type == "park":
+            self.text_disp_max.Show(True)
+            self.text_disp_min.Show(True)
+        self.text_disp_max.Show(True)
+        self.text_disp_min.Show(True)
         for item in self.model.dispersion.keys():
 …
                                           wx.EXPAND | wx.ADJUST_MINSIZE, 0)
+                        if self.engine_type == "park":
+                            ctl3.Show(True)
+                            ctl4.Show(True)
+                        ctl3.Show(True)
+                        ctl4.Show(True)
                     elif p == "npts":
 …
             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 check_float(tcrtl):
             flag = self._onparamEnter_helper()
             self.set_npts2fit()
+            self.show_npts2fit()
             if self.fitrange:
                 temp_smearer = None
 …
                     #self.data.mask = index_data
                     #self.Npts_fit.SetValue(str(len(self.data.mask)))
                     self.set_npts2fit()
+                    self.show_npts2fit()
             else:
                 index_data = ((self.qmin_x <= self.data.x) & \
 …
             # try re draw the model plot if it exists
             self._draw_model()
             self.set_npts2fit()
+            self.show_npts2fit()
         elif self.model == None:
             self.panel.MakeModal(False)
             event.Skip()
             self.set_npts2fit()
+            self.show_npts2fit()
             msg = "No model is found on updating MASK in the model plot... "
             wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
 …
         return npts2fit
     def set_npts2fit(self):
+    def show_npts2fit(self):
         """
         setValue Npts for fitting
 …
         return self.tcChi.GetValue()
-    def get_param_list(self):
-        """
-        :return self.param_toFit: list containing  references to TextCtrl
-            checked.Theses TextCtrl will allow reference to parameters to fit.
-        :raise: if return an empty list of parameter fit will nnote work
-            properly so raise ValueError,"missing parameter to fit"
-        """
-        if self.param_toFit != []:
-            return self.param_toFit
-        else:
-            msg = "missing parameters to fit"
-            wx.MessageBox(msg, 'warning')
-            return False
     def onsetValues(self, chisqr, p_name, out, cov):
         """
 …
         if chisqr != None and numpy.isfinite(chisqr):
             #format chi2
-            if self.engine_type == "park":
-                npt_fit = float(self.get_npts2fit())
             chi2 = format_number(chisqr, True)
             self.tcChi.SetValue(chi2)

src/sans/perspectives/fitting/fitpanel.py

rb6a181b	reff93b8
64	64	self.sim_page = None
65	65	self.batch_page = None
66		self.fit_engine_type = "~~scipy~~"
	66	self.fit_engine_type = "bumps"
67	67	## get the state of a page
68	68	self.Bind(basepage.EVT_PAGE_INFO, self._onGetstate)

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

-                      r9afebe1
+                      ra9807efa
 from .fitproblem import FitProblemDictionary
 from .fitpanel import FitPanel
+from .resultpanel import ResultPanel, PlotResultEvent
 from .fit_thread import FitThread
 from .pagestate import Reader
 …
 from sans.perspectives.calculator.model_editor import EditorWindow
 from sans.guiframe.gui_manager import MDIFrame
+# TODO: remove globals from interface to bumps options!
+# Default bumps to use the levenberg-marquardt optimizer
+import bumps.fitters
+bumps.fitters.FIT_DEFAULT = 'lm'
 MAX_NBR_DATA = 4
 …
         # Start with a good default
         self.elapsed = 0.022
-        # the type of optimizer selected, park or scipy
-        self.fitter = None
         self.fit_panel = None
-        #let fit ready
-        self.fitproblem_count = None
         #Flag to let the plug-in know that it is running stand alone
         self.standalone = True
 …
         self.closed_page_dict = {}
         ## Fit engine
         self._fit_engine = 'scipy'
+        self._fit_engine = 'bumps'
         self._gui_engine = None
         ## Relative error desired in the sum of squares (float); scipy only
 …
         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)
+        self.menu1.FindItemById(self.scipy_id).Check(True)
+        self.menu1.FindItemById(self.park_id).Check(False)
+        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(self._fit_engine=="scipy")
+        self.menu1.FindItemById(self.park_id).Check(self._fit_engine=="park")
+        self.menu1.FindItemById(self.bumps_id).Check(self._fit_engine=="bumps")
         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):
 …
         :param uid: id related to the panel currently calling this fit function.
         """
+        flag = True
+        ##  count the number of fitproblem schedule to fit
+        fitproblem_count = 0
+        for value in self.page_finder.values():
+            if value.get_scheduled() == 1:
+                fitproblem_count += 1
+        self._gui_engine = self._return_engine_type()
+        self.fitproblem_count = fitproblem_count
+        if self._fit_engine == "park":
+            engineType = "Simultaneous Fit"
+        if uid is None: raise RuntimeError("no page to fit") # Should never happen
+        # Remember the user selected fit engine before the fit.  Simultaneous
+        # fitting may change the selected engine, so it needs to be restored
+        # when the fit is complete.
+        self._gui_engine = self._fit_engine
+        sim_page_uid = getattr(self.sim_page, 'uid', None)
+        batch_page_uid = getattr(self.batch_page, 'uid', None)
+        if uid == sim_page_uid:
+            fit_type = 'simultaneous'
+        elif uid == batch_page_uid:
+            fit_type = 'combined_batch'
         else:
+            engineType = "Single Fit"
+            fit_type = 'single'
+        # if constrained fit, don't use scipy leastsq directly
+        if fit_type == 'simultaneous':
+            if self._fit_engine not in ("park","bumps"):
+                self._on_change_engine(engine='bumps')
         fitter_list = []
         sim_fitter = None
+        is_single_fit = True
+        batch_on = False
+        if self.sim_page is not None and self.sim_page.uid == uid:
+        if fit_type == 'simultaneous':
             #simulatanous fit only one engine need to be created
-            ## if simultaneous fit change automatically the engine to park
-            self._on_change_engine(engine='park')
             sim_fitter = Fit(self._fit_engine)
             sim_fitter.fitter_id = self.sim_page.uid
             fitter_list.append(sim_fitter)
+            is_single_fit = False
+            batch_on = self.sim_page.batch_on
+        self.fitproblem_count = fitproblem_count
+        if self._fit_engine == "park":
+            engineType = "Simultaneous Fit"
+        else:
+            engineType = "Single Fit"
         self.current_pg = None
         list_page_id = []
         fit_id = 0
+        batch_inputs = {}
+        batch_outputs = {}
+        for page_id, value in self.page_finder.iteritems():
+        for page_id, page_info in self.page_finder.iteritems():
             # For simulfit (uid give with None), do for-loop
             # if uid is specified (singlefit), do it only on the page.
+            if engineType == "Single Fit":
+                #combine more than 1 batch page on single mode
+                if self.batch_page is None or self.batch_page.uid != uid:
+                    if page_id != uid:
+                        continue
+            if page_id in (sim_page_uid, batch_page_uid): continue
+            if fit_type == "single" and page_id != uid: continue
             try:
+                if value.get_scheduled() == 1:
+                    value.nbr_residuals_computed = 0
+                    #Get list of parameters name to fit
+                    pars = []
+                    templist = []
+                if page_info.get_scheduled() == 1:
+                    page_info.nbr_residuals_computed = 0
                     page = self.fit_panel.get_page_by_id(page_id)
                     self.set_fit_weight(uid=page.uid,
                                      flag=page.get_weight_flag(),
                                      is2d=page._is_2D())
+                    templist = page.get_param_list()
+                    flag = page._update_paramv_on_fit()
+                    if not flag:
+                    if not page.param_toFit:
+                        msg = "No fitting parameters for %s"%page.window_caption
+                        wx.PostEvent(page.parent.parent,
+                                     StatusEvent(status=msg, info="error",
+                                                 type="stop"))
+                        return False
+                    if not page._update_paramv_on_fit():
                         msg = "Fitting range or parameter values are"
                         msg += " invalid in %s" % \
 …
                                      StatusEvent(status=msg, info="error",
                                      type="stop"))
+                        return flag
+                    for element in templist:
+                        name = str(element[1])
+                        pars.append(name)
+                    fitproblem_list = value.values()
+                        return False
+                    pars = [str(element[1]) for element in page.param_toFit]
+                    fitproblem_list = page_info.values()
                     for fitproblem in  fitproblem_list:
                         if sim_fitter is None:
                             fitter = Fit(self._fit_engine)
                             fitter.fitter_id = page_id
-                            self._fit_helper(fitproblem=fitproblem,
-                                             pars=pars,
-                                             fitter=fitter,
-                                             fit_id=fit_id,
-                                             batch_inputs=batch_inputs,
-                                             batch_outputs=batch_outputs)
                             fitter_list.append(fitter)
                         else:
                             fitter = sim_fitter
                             self._fit_helper(fitproblem=fitproblem,
+                        self._add_problem_to_fit(fitproblem=fitproblem,
                                              pars=pars,
                                              fitter=fitter,
+                                             fit_id=fit_id,
+                                             batch_inputs=batch_inputs,
+                                             batch_outputs=batch_outputs)
+                                             fit_id=fit_id)
                         fit_id += 1
                     list_page_id.append(page_id)
+                    current_page_id = page_id
+                    value.clear_model_param()
+                    page_info.clear_model_param()
             except KeyboardInterrupt:
-                flag = True
                 msg = "Fitting terminated"
                 wx.PostEvent(self.parent, StatusEvent(status=msg, info="info",
                                                       type="stop"))
                 return flag
+                return True
             except:
+                flag = False
+                msg = "%s error: %s" % (engineType, sys.exc_value)
+                msg = "Fitting error: %s" % str(sys.exc_value)
                 wx.PostEvent(self.parent, StatusEvent(status=msg, info="error",
                                                       type="stop"))
                 return flag
+                return False
         ## If a thread is already started, stop it
         #if self.calc_fit!= None and self.calc_fit.isrunning():
 …
                                 improvement_delta=0.1)
         self._mac_sleep(0.2)
+        ## perform single fit
+        try:
+        # batch fit
+        batch_inputs = {}
+        batch_outputs = {}
+        if fit_type == "simultaneous":
+            page = self.sim_page
+        elif fit_type == "combined_batch":
+            page = self.batch_page
+        else:
             page = self.fit_panel.get_page_by_id(uid)
+            batch_on = page.batch_on
+        except:
+            try:
+                #if the id cannot be found then  we deal with a self.sim_page
+                #or a self.batch_page
+                if self.sim_page is not None and uid == self.sim_page.uid:
+                    batch_on = self.sim_page.batch_on
+                if self.batch_page is not None and uid == self.batch_page.uid:
+                    batch_on = self.batch_page.batch_on
+            except:
+                batch_on = False
+        # batch fit
+        if batch_on:
+        if page.batch_on:
             calc_fit = FitThread(handler=handler,
                                  fn=fitter_list,
 …
                                  reset_flag=self.batch_reset_flag)
         else:
-            # single fit: not batch and not simul fit
-            if not is_single_fit:
-                current_page_id = self.sim_page.uid
             ## Perform more than 1 fit at the time
             calc_fit = FitThread(handler=handler,
 …
                                     completefn=self._fit_completed,
                                     ftol=self.ftol)
+        self.fit_thread_list[current_page_id] = calc_fit
+        #self.fit_thread_list[current_page_id] = calc_fit
+        self.fit_thread_list[uid] = calc_fit
         calc_fit.queue()
+        calc_fit.ready(2.5)
         msg = "Fitting is in progress..."
         wx.PostEvent(self.parent, StatusEvent(status=msg, type="progress"))
+        self.ready_fit(calc_fit=calc_fit)
+        return flag
+    def ready_fit(self, calc_fit):
+        """
+        Ready for another fit
+        """
+        if self.fitproblem_count != None and self.fitproblem_count > 1:
+            calc_fit.ready(2.5)
+        else:
+            time.sleep(0.4)
+        return True
     def remove_plot(self, uid, fid=None, theory=False):
         """
 …
                 self.page_finder[uid].schedule_tofit(value)
+    def _fit_helper(self, fitproblem, pars, fitter, fit_id,
+                    batch_inputs, batch_outputs):
+    def _add_problem_to_fit(self, fitproblem, pars, fitter, fit_id):
         """
         Create and set fit engine with series of data and model
 …
         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):
         """
 …
                 break
-    def _return_engine_type(self):
-        """
-        return the current type of engine
-        """
-        return self._fit_engine
     def _on_change_engine(self, engine='park'):
         """
 …
             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
+                      rbf5e985
                 self.Layout()
                 break
+        self._onAdd_constraint(None)
+        #self._onAdd_constraint(None)
     def onFit(self, event):
 …
         ## 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()
 …
                     for fid in self.page_finder[id].iterkeys():
+                        self.page_finder[id].set_model_param(param,
+                                                        constraint, fid=fid)
+                        # wrap in param/constraint in str() to remove unicode
+                        self.page_finder[id].set_model_param(str(param),
+                                                        str(constraint), fid=fid)
                     break
         return True

test/park_integration/test/batch_fit.py

-                      r5777106
+                      re3efa6b3
-import math
-import numpy
 import copy
 import time
 …
 def classMapper(classInstance, classFunc, *args):
     """
 …
+class BatchScipyFit:
+class BatchFit:
     """
     test fit module
 …
             model.setParam('cyl_phi.npts', 3)
             model.setParam('cyl_theta.nsigmas', 10)
             """ for 2 data cyl_theta = 60.0 [deg] cyl_phi= 60.0 [deg]"""
+            # for 2 data cyl_theta = 60.0 [deg] cyl_phi= 60.0 [deg]
             fitter.set_model(model, i, self.param_to_fit,
                              self.list_of_constraints)
 …
             self.list_of_mapper.append(classMapper)
     def reset_value(self):
+    def reset_value(self, engine='scipy'):
         """
         Initialize inputs for the map function
 …
         self.list_of_constraints = []
         self.list_of_mapper = []
+        engine ="scipy"
         path = "testdata_line3.txt"
         self._reset_helper(path=path, engine=engine, npts=NPTS)
 …
     def test_map_fit(self):
+    def test_map_fit(self, n=0):
         """
+        """
+        results =  map(classMapper,self.list_of_fitter, self.list_of_function)
+        print len(results)
+        for result in results:
+            print result.fitness, result.stderr, result.pvec
+        """
+        if n > 0:
+            self._test_process_map_fit(n=n)
+        else:
+            results =  map(classMapper,self.list_of_fitter, self.list_of_function)
+            print len(results)
+            for result in results:
+                print result.fitness, result.stderr, result.pvec
     def test_process_map_fit(self, n=1):
 …
     """
     def setUp(self):
         self.test = BatchScipyFit(qmin=None, qmax=None)
+        self.test = BatchFit(qmin=None, qmax=None)
     def __test_fit1(self):
+    def test_fit1(self):
         """test fit with python built in map function---- full range of each data"""
         self.test.test_map_fit()
     def __test_fit2(self):
+    def test_fit2(self):
         """test fit with python built in map function---- common range for all data"""
         self.test.set_range(qmin=0.013, qmax=0.05)
         self.test.reset_value()
         self.test.test_map_fit()
+        raise Exception("fail")
     def test_fit3(self):
 …
         self.test.set_range(qmin=None, qmax=None)
         self.test.reset_value()
         self.test.test_process_map_fit(n=2)
+        self.test.test_map_fit(n=1)
     def test_fit4(self):
 …
         self.test.set_range(qmin=-1, qmax=10)
         self.test.reset_value()
         self.test.test_process_map_fit(n=1)
+        self.test.test_map_fit(n=3)

test/park_integration/test/utest_fit_cylinder.py

-                      rda5d8e8
+                      reff93b8
 from sans.dataloader.loader import Loader
+#@unittest.skip("")
 class TestSingleFit(unittest.TestCase):
     """ test single fitting """
 …
         fitter.set_model(self.model,1,self.pars1)
         fitter.select_problem_for_fit(id=1,value=1)
+        return  fitter.fit()
+        result1, = fitter.fit()
-    def test_scipy(self):
-        """ Simple cylinder model fit (scipy)  """
-        result1, = self._fit("scipy")
         self.assert_(result1)
         self.assertTrue(len(result1.pvec)>0 or len(result1.pvec)==0 )
         self.assertTrue(len(result1.stderr)> 0 or len(result1.stderr)==0)
         self.assertTrue( math.fabs(result1.pvec[0]-400.0)/3.0 < result1.stderr[0] )
         self.assertTrue( math.fabs(result1.pvec[1]-20.0)/3.0  < result1.stderr[1] )
         self.assertTrue( math.fabs(result1.pvec[2]-1.0)/3.0   < result1.stderr[2] )
         self.assertTrue( result1.fitness < 1.0 )
+    def test_scipy(self):
+        """ Simple cylinder model fit (scipy)  """
+        self._fit("scipy")
     def test_park(self):
         """ Simple cylinder model fit (park)  """
+        #raise NotImplementedError()
+        result1, = self._fit("park")
+        self.assert_(result1)
+        self.assertTrue(len(result1.pvec)>0 or len(result1.pvec)==0 )
+        self.assertTrue(len(result1.stderr)> 0 or len(result1.stderr)==0)
+        self.assertTrue( math.fabs(result1.pvec[0]-400.0)/3.0 < result1.stderr[0] )
+        self.assertTrue( math.fabs(result1.pvec[1]-20.0)/3.0  < result1.stderr[1] )
+        self.assertTrue( math.fabs(result1.pvec[2]-1.0)/3.0   < result1.stderr[2] )
+        self.assertTrue( result1.fitness < 1.0 )
+        self._fit("park")
+    def test_bumps(self):
+        """ Simple cylinder model fit (park)  """
+        self._fit("bumps")
 class TestSimultaneousFit(unittest.TestCase):
 …
         self.model1.set(scale= 1.0)
         self.model1.set(radius=18)
         self.model1.set(length=396)
+        self.model1.set(length=200)
         self.model1.set(sldCyl=3e-006, sldSolv=0.0)
         self.model1.set(background=0.0)
         cyl2  = CylinderModel()
         cyl2.name = "C2"
 …
         self.model2.set(scale= 1.0)
         self.model2.set(radius=37)
         self.model2.set(length='C1.length')
+        self.model2.set(length=300)
         self.model2.set(sldCyl=3e-006, sldSolv=0.0)
         self.model2.set(background=0.0)
+    def _fit(self, name="park"):
+    def test_constrained_bumps(self):
+        """ Simultaneous cylinder model fit (park)  """
+        self._run_fit(Fit('bumps'))
+    #@unittest.skip("")
+    def test_constrained_park(self):
+        """ Simultaneous cylinder model fit (park)  """
+        self._run_fit(Fit('park'))
+    def _run_fit(self, fitter):
+        result1, result2 = self._fit(fitter)
+        self.assert_(result1)
+        self.assertTrue(len(result1.pvec)>0)
+        self.assertTrue(len(result1.stderr)>0)
+        for n, v, dv in zip(result1.param_list, result1.pvec, result1.stderr):
+            print "%s M1.%s = %s +/- %s"%(fitter._engine.__class__.__name__,n,v,dv)
+            if n == "length":
+                self.assertTrue( math.fabs(v-400.0)/3.0 < dv )
+            elif n=='radius':
+                self.assertTrue( math.fabs(v-20.0)/3.0 < dv )
+            elif n=='scale':
+                self.assertTrue( math.fabs(v-1.0)/3.0 < dv )
+        for n, v, dv in zip(result2.param_list, result2.pvec, result2.stderr):
+            print "%s M2.%s = %s +/- %s"%(fitter._engine.__class__.__name__,n,v,dv)
+            if n=='radius':
+                self.assertTrue( math.fabs(v-40.0)/3.0 < dv )
+            elif n=='scale':
+                self.assertTrue( math.fabs(v-1.0)/3.0 < dv )
+    def _fit(self, fitter):
         """ return fit result """
-        fitter = Fit(name)
         fitter.set_data(self.data1,1)
         fitter.set_model(self.model1, 1, ['length','radius','scale'])
         fitter.set_data(self.data2,2)
+        fitter.set_model(self.model2, 2, ['radius','scale'])
+        fitter.set_model(self.model2, 2, ['length','radius','scale'],
+                         constraints=[("length","C1.length")])
         fitter.select_problem_for_fit(id=1,value=1)
         fitter.select_problem_for_fit(id=2,value=1)
         return fitter.fit()
+    def test_park2(self):
+        """ Simultaneous cylinder model fit (park)  """
+        raise NotImplementedError()
+        result1,= self._fit('park')
+        self.assert_(result1)
+        self.assertTrue(len(result1.pvec)>=0  )
+        self.assertTrue(len(result1.stderr)>= 0)
+        for par in result1.parameters:
+            if par.name=='C1.length':
+                print par.name, par.value
+                self.assertTrue( math.fabs(par.value-400.0)/3.0 < par.stderr )
+            elif par.name=='C1.radius':
+                print par.name, par.value
+                self.assertTrue( math.fabs(par.value-20.0)/3.0 < par.stderr )
+            elif par.name=='C2.radius':
+                print par.name, par.value
+                self.assertTrue( math.fabs(par.value-40.0)/3.0 < par.stderr )
+            elif par.name=='C1.scale':
+                print par.name, par.value
+                self.assertTrue( math.fabs(par.value-1.0)/3.0 < par.stderr )
+            elif par.name=='C2.scale':
+                print par.name, par.value
+                self.assertTrue( math.fabs(par.value-1.0)/3.0 < par.stderr )
 if __name__ == '__main__':

test/park_integration/test/utest_fit_line.py

-                      rda5d8e8
+                      re3efa6b3
 """
 import unittest
+from sans.fit.AbstractFitEngine import Model
+import math
+from sans.fit.AbstractFitEngine import Model, FitHandler
 from sans.dataloader.loader import Loader
 from sans.fit.Fitting import Fit
 …
 from sans.models.Constant import Constant
-import math
 class testFitModule(unittest.TestCase):
     """ test fitting """
     def test1(self):
         """ Fit 1 data (testdata_line.txt)and 1 model(lineModel) """
+        #load data
+    def test_bad_pars(self):
+        fitter = Fit('bumps')
         data = Loader().load("testdata_line.txt")
         data.name = data.filename
+        #Importing the Fit module
+        fitter = Fit('scipy')
+        fitter.set_data(data,1)
+        model1  = LineModel()
+        model1.name = "M1"
+        model = Model(model1, data)
+        pars1= ['param1','param2']
+        try:
+            fitter.set_model(model,1,pars1)
+        except ValueError,exc:
+            #print "ValueError was correctly raised: "+str(msg)
+            assert str(exc).startswith('parameter param1')
+        else:
+            raise AssertionError("No error raised for scipy fitting with wrong parameters name to fit")
+    def fit_single(self, fitter_name, isdream=False):
+        fitter = Fit(fitter_name)
+        data = Loader().load("testdata_line.txt")
+        data.name = data.filename
+        fitter.set_data(data,1)
         # Receives the type of model for the fitting
         model1  = LineModel()
 …
         model = Model(model1,data)
         #fit with scipy test
+        pars1= ['param1','param2']
+        fitter.set_data(data,1)
+        try:fitter.set_model(model,1,pars1)
+        except ValueError,exc:
+            #print "ValueError was correctly raised: "+str(msg)
+            assert str(exc).startswith('wrong parameter')
+        else: raise AssertionError("No error raised for scipy fitting with wrong parameters name to fit")
         pars1= ['A','B']
         fitter.set_model(model,1,pars1)
         fitter.select_problem_for_fit(id=1,value=1)
+        result1, = fitter.fit()
+        self.assertTrue( math.fabs(result1.pvec[0]-4)/3 <= result1.stderr[0] )
+        self.assertTrue( math.fabs(result1.pvec[1]-2.5)/3 <= result1.stderr[1])
+        self.assertTrue( result1.fitness/len(data.x) < 2 )
+        #fit with park test
+        fitter = Fit('park')
+        fitter.set_data(data,1)
+        fitter.set_model(model,1,pars1)
+        fitter.select_problem_for_fit(id=1,value=1)
+        result2, = fitter.fit()
+        self.assert_(result2)
+        self.assertTrue( math.fabs(result2.pvec[0]-4)/3 <= result2.stderr[0] )
+        self.assertTrue( math.fabs(result2.pvec[1]-2.5)/3 <= result2.stderr[1] )
+        self.assertTrue( result2.fitness/len(data.x) < 2)
+        # compare fit result result for scipy and park
+        self.assertAlmostEquals( result1.pvec[0], result2.pvec[0] )
+        self.assertAlmostEquals( result1.pvec[1],result2.pvec[1] )
+        self.assertAlmostEquals( result1.stderr[0],result2.stderr[0] )
+        self.assertAlmostEquals( result1.stderr[1],result2.stderr[1] )
+        self.assertAlmostEquals( result1.fitness,
+                                 result2.fitness/len(data.x),1 )
+        result1, = fitter.fit(handler=FitHandler())
+        # The target values were generated from the following statements
+        p,s,fx = result1.pvec, result1.stderr, result1.fitness
+        #print "p0,p1,s0,s1,fx = %g, %g, %g, %g, %g"%(p[0],p[1],s[0],s[1],fx)
+        p0,p1,s0,s1,fx_ = 3.68353, 2.61004, 0.336186, 0.105244, 1.20189
+        if isdream:
+            # Dream is not a minimizer: just check that the fit is within
+            # uncertainty
+            self.assertTrue( abs(p[0]-p0) <= s0 )
+            self.assertTrue( abs(p[1]-p1) <= s1 )
+        else:
+            self.assertTrue( abs(p[0]-p0) <= 1e-5 )
+            self.assertTrue( abs(p[1]-p1) <= 1e-5 )
+            self.assertTrue( abs(fx-fx_) <= 1e-5 )
+    def fit_bumps(self, alg, **opts):
+        #Importing the Fit module
+        from bumps import fitters
+        fitters.FIT_DEFAULT = alg
+        fitters.FIT_OPTIONS[alg].options.update(opts)
+        fitters.FIT_OPTIONS[alg].options.update(monitors=[])
+        #print "fitting",alg,opts
+        #kprint "options",fitters.FIT_OPTIONS[alg].__dict__
+        self.fit_single('bumps', isdream=(alg=='dream'))
+    def test_bumps_de(self):
+        self.fit_bumps('de')
+    def test_bumps_dream(self):
+        self.fit_bumps('dream', burn=500, steps=100)
+    def test_bumps_amoeba(self):
+        self.fit_bumps('amoeba')
+    def test_bumps_newton(self):
+        self.fit_bumps('newton')
+    def test_bumps_lm(self):
+        self.fit_bumps('lm')
+    def test_scipy(self):
+        #print "fitting scipy"
+        self.fit_single('scipy')
+    def test_park(self):
+        #print "fitting park"
+        self.fit_single('park')
     def test2(self):
 …
         fitter.select_problem_for_fit(id=2,value=0)
         try: result1, = fitter.fit()
+        try: result1, = fitter.fit(handler=FitHandler())
         except RuntimeError,msg:
            assert str(msg)=="No Assembly scheduled for Scipy fitting."
 …
         fitter.select_problem_for_fit(id=1,value=1)
         fitter.select_problem_for_fit(id=2,value=1)
         try: result1, = fitter.fit()
+        try: result1, = fitter.fit(handler=FitHandler())
         except RuntimeError,msg:
            assert str(msg)=="Scipy can't fit more than a single fit problem at a time."
         else: raise AssertionError,"No error raised for scipy fitting with more than 2 models"
         #fit with park test
         fitter = Fit('park')
 …
         fitter.select_problem_for_fit(id=1,value=1)
         fitter.select_problem_for_fit(id=2,value=1)
         R1,R2 = fitter.fit()
+        R1,R2 = fitter.fit(handler=FitHandler())
         self.assertTrue( math.fabs(R1.pvec[0]-4)/3 <= R1.stderr[0] )
 …
         fitter.select_problem_for_fit(id=2,value=1)
         R1,R2 = fitter.fit()
+        R1,R2 = fitter.fit(handler=FitHandler())
         self.assertTrue( math.fabs(R1.pvec[0]-4.0)/3. <= R1.stderr[0])
         self.assertTrue( math.fabs(R1.pvec[1]-2.5)/3. <= R1.stderr[1])
 …
         fitter.select_problem_for_fit(id=1,value=1)
+        result1, = fitter.fit()
+        result1, = fitter.fit(handler=FitHandler())
+        #print(result1)
         self.assert_(result1)
 …
         self.assertTrue( math.fabs(result1.pvec[1]-2.5)/3 <= result1.stderr[1])
         self.assertTrue( result1.fitness/len(data1.x) < 2 )
         #fit with park test
         fitter = Fit('park')
 …
         fitter.set_data(data2,1,qmin=1,qmax=10)
         fitter.select_problem_for_fit(id=1,value=1)
         result2, = fitter.fit()
+        result2, = fitter.fit(handler=FitHandler())
         self.assert_(result2)
 …
         self.assertAlmostEquals( result1.stderr[1],result2.stderr[1] )
         self.assertTrue( result2.fitness/(len(data2.x)+len(data1.x)) < 2 )
+if __name__ == "__main__":
+    unittest.main()

test/park_integration/test/utest_fit_smeared.py

-                      r6c00702
+                      re3efa6b3
 import unittest
 import math
 import numpy
 from sans.fit.AbstractFitEngine import Model
 …
         out=Loader().load("cyl_400_20.txt")
         # This data file has not error, add them
         out.dy = out.y
+        #out.dy = out.y
         fitter = Fit('scipy')
 …
         # Receives the type of model for the fitting
         model1  = CylinderModel()
+        model1.setParam('sldCyl', 3.0e-6)
+        model1.setParam('sldSolv', 0.0)
+        model1.setParam("scale", 1.0)
+        model1.setParam("radius",18)
+        model1.setParam("length", 397)
+        model1.setParam("sldCyl",3e-006 )
+        model1.setParam("sldSolv",0.0 )
+        model1.setParam("background", 0.0)
         model = Model(model1)
-        model.set(scale=1e-10)
         pars1 =['length','radius','scale']
         fitter.set_model(model,1,pars1)
 …
         fitter.select_problem_for_fit(id=1,value=1)
         result1, = fitter.fit()
+        #print "result1",result1
         self.assert_(result1)
         self.assertTrue(len(result1.pvec)>0 or len(result1.pvec)==0 )
         self.assertTrue(len(result1.stderr)> 0 or len(result1.stderr)==0)
+        self.assertTrue(len(result1.pvec) > 0)
+        self.assertTrue(len(result1.stderr) > 0)
         self.assertTrue( math.fabs(result1.pvec[0]-400.0)/3.0 < result1.stderr[0] )
         self.assertTrue( math.fabs(result1.pvec[1]-20.0)/3.0  < result1.stderr[1] )
         self.assertTrue( math.fabs(result1.pvec[2]-9.0e-12)/3.0   < result1.stderr[2] )
+        self.assertTrue( math.fabs(result1.pvec[2]-1)/3.0   < result1.stderr[2] )
         self.assertTrue( result1.fitness < 1.0 )
+    def test_park_dispersion(self):
+        """
+            Cylinder fit with dispersion
+        """
+        self._dispersion(fitter = Fit('park'))
+    def test_bumps_dispersion(self):
+        """
+            Cylinder fit with dispersion
+        """
+        alg = 'lm'
+        from bumps import fitters
+        fitters.FIT_DEFAULT = alg
+        #fitters.FIT_OPTIONS[alg].options.update(opts)
+        fitters.FIT_OPTIONS[alg].options.update(monitors=[])
+        self._dispersion(fitter = Fit('bumps'))
     def test_scipy_dispersion(self):
         """
             Cylinder fit with dispersion
         """
+        self._dispersion(fitter = Fit('scipy'))
+    def _dispersion(self, fitter):
         # Load data
         # This data is for a cylinder with
 …
             out.dy[i] = math.sqrt(out.y[i])
-        # Set up the fit
-        fitter = Fit('scipy')
         # Receives the type of model for the fitting
         model1  = CylinderModel()
+        model1.setParam('sldCyl', 3.0e-6)
+        model1.setParam('sldSolv', 0.0)
+        model1.setParam("scale", 10.0)
+        model1.setParam("radius",18)
+        model1.setParam("length", 397)
+        model1.setParam("sldCyl",3e-006 )
+        model1.setParam("sldSolv",0.0 )
+        model1.setParam("background", 0.0)
         # Dispersion parameters
         model1.dispersion['radius']['width'] = 0.001
         model1.dispersion['radius']['npts'] = 50
+        model1.dispersion['radius']['width'] = 0.25
+        model1.dispersion['radius']['npts'] = 50
         model = Model(model1)
         pars1 =['length','radius','scale','radius.width']
         fitter.set_data(out,1)
-        model.set(scale=1e-10)
         fitter.set_model(model,1,pars1)
         fitter.select_problem_for_fit(id=1,value=1)
+        result1, = fitter.fit()
+        #import time; T0 = time.time()
+        result1, = fitter.fit()
+        #print "time",time.time()-T0,fitter._engine.__class__.__name__
         self.assert_(result1)
+        self.assertTrue(len(result1.pvec)>0 or len(result1.pvec)==0 )
+        self.assertTrue(len(result1.stderr)> 0 or len(result1.stderr)==0)
+        self.assertTrue( math.fabs(result1.pvec[0]-400.0)/3.0 < result1.stderr[0] )
+        self.assertTrue( math.fabs(result1.pvec[1]-20.0)/3.0  < result1.stderr[1] )
+        self.assertTrue( math.fabs(result1.pvec[2]-1.0e-10)/3.0   < result1.stderr[2] )
+        self.assertTrue( math.fabs(result1.pvec[3]-5.0)/3.0   < result1.stderr[3] )
+        self.assertTrue(len(result1.pvec)>0)
+        self.assertTrue(len(result1.stderr)>0)
+        #print [z for z in zip(result1.param_list,result1.pvec,result1.stderr)]
+        self.assertTrue( math.fabs(result1.pvec[0]-399.8)/3.0 < result1.stderr[0] )
+        self.assertTrue( math.fabs(result1.pvec[1]-17.5)/3.0  < result1.stderr[1] )
+        self.assertTrue( math.fabs(result1.pvec[2]-11.1)/3.0   < result1.stderr[2] )
+        self.assertTrue( math.fabs(result1.pvec[3]-0.276)/3.0   < result1.stderr[3] )
         self.assertTrue( result1.fitness < 1.0 )
 …
     """
     def setUp(self):
-        print "TEST DONE WITHOUT PROPER OUTPUT CHECK:"
-        print "   ---> TEST NEEDS TO BE COMPLETED"
         data = Loader().load("latex_smeared.xml")
         self.data_res = data[0]
 …
         self.sphere = SphereModel()
+        self.sphere.setParam('background', 0)
         self.sphere.setParam('radius', 5000.0)
+        self.sphere.setParam('scale', 1.0e-13)
+        self.sphere.setParam('radius.npts', 30)
+        self.sphere.setParam('radius.width',500)
+        self.sphere.setParam('scale', 0.4)
+        self.sphere.setParam('sldSolv',0)
+        self.sphere.setParam('sldSph',1e-6)
+        #self.sphere.setParam('radius.npts', 30)
+        #self.sphere.setParam('radius.width',50)
     def test_reso(self):
 …
         fitter.set_data(self.data_res,1)
         fitter._engine.fit_arrange_dict[1].data_list[0].smearer = smear
+        print "smear ",smear
         # Model: maybe there's a better way to do this.
         # Ideally we should have to create a new model from our sans model.
         fitter.set_model(Model(self.sphere),1, ['radius','scale'])
+        fitter.set_model(Model(self.sphere),1, ['radius','scale', 'background'])
         # Why do we have to do this...?
         fitter.select_problem_for_fit(id=1,value=1)
         # Perform the fit (might take a while)
         result1, = fitter.fit()
+        # Replace this with proper test once we know what the
+        # result should be
+        print result1.pvec
+        print result1.stderr
+        #print "v",result1.pvec
+        #print "dv",result1.stderr
+        #print "chisq(v)",result1.fitness
+        self.assertTrue( math.fabs(result1.pvec[0]-5000) < 20 )
+        self.assertTrue( math.fabs(result1.pvec[1]-0.48) < 0.02 )
+        self.assertTrue( math.fabs(result1.pvec[2]-0.060)  < 0.002 )
     def test_slit(self):
         smear = smear_selection(self.data_slit)
         self.assertEqual(smear.__class__.__name__, 'SlitSmearer')
-        # Fit
         fitter = Fit('scipy')
 …
         result1, = fitter.fit()
         # Replace this with proper test once we know what the
         # result should be
         print result1.pvec
         print result1.stderr
+        #print "v",result1.pvec
+        #print "dv",result1.stderr
+        #print "chisq(v)",result1.fitness
+        self.assertTrue( math.fabs(result1.pvec[0]-2340) < 20 )
+        self.assertTrue( math.fabs(result1.pvec[1]-0.010) < 0.002 )
 if __name__ == '__main__':
     unittest.main()

test/park_integration/test/utest_park_scipy.py

-                      r6c00702
+                      re544c84
         self.assertTrue(len(result1.stderr)>= 0)
         print "results",list(zip(result1.pvec, result1.stderr))
         self.assertTrue( math.fabs(result1.pvec[0]-605)/3.0 <= result1.stderr[0] )
         self.assertTrue( math.fabs(result1.pvec[1]-20.0)/3.0  <= result1.stderr[1] )
         self.assertTrue( math.fabs(result1.pvec[2]-1)/3.0 <= result1.stderr[2] )
+        #print "results",list(zip(result1.pvec, result1.stderr))
+        self.assertTrue( math.fabs(result1.pvec[0]-612)/3.0 <= result1.stderr[0] )
+        self.assertTrue( math.fabs(result1.pvec[1]-20.3)/3.0  <= result1.stderr[1] )
+        self.assertTrue( math.fabs(result1.pvec[2]-25)/3.0 <= result1.stderr[2] )
         self.assertTrue( result1.fitness/len(data.x) < 1.0 )

test/park_integration/test/utest_small_test.py

-                      r5777106
+                      r76f132a
 import math
 from sans.fit.Fitting import Fit
 from DataLoader.loader import Loader
+from sans.dataloader.loader import Loader
 class testFitModule(unittest.TestCase):
 …
         from sans.models.CylinderModel import CylinderModel
         model  = CylinderModel()
+        model.setParam('contrast', 1)
+        model.setParam('sldCyl', 1)
+        model.setParam('sldSolv', 0)
         pars1 =['length','radius','scale']
         fitter.set_data(out,1)
         model.setParam('scale', 1e-10)
         fitter.set_model(model,1,pars1, constraints=())
+        fitter.select_problem_for_fit(Uid=1,value=1)
+        result1 = fitter.fit()
+        fitter.select_problem_for_fit(id=1,value=1)
+        result1, = fitter.fit()
+        #print result1
+        #print result1.__dict__
         self.assert_(result1)
         self.assertTrue(len(result1.pvec)>0 or len(result1.pvec)==0 )

test/run_one.py

-                      r95fb3e8
+                      r76f132a
 #!/usr/bin/env python
 import os
 import sys
 …
 run_py = joinpath(dirname(dirname(abspath(__file__))), 'run.py')
-#print run_py
 run = imp.load_source('sasview_run', run_py)
 run.prepare()
 #print "\n".join(sys.path)
 test_path,test_file = splitpath(sys.argv[1])
 print "test file",sys.argv[1]
+test_path,test_file = splitpath(abspath(sys.argv[1]))
+print "=== testing:",sys.argv[1]
 #print test_path, test_file
 sys.argv = [sys.argv[0]]
 …
 test = imp.load_source('tests',test_file)
 unittest.main(test, testRunner=xmlrunner.XMLTestRunner(output='logs'))

SasView

Changeset 8b74155d in sasview

Legend:

park-1.2.1/park/expression.py

park-1.2.1/park/fitresult.py

park-1.2.1/park/parameter.py

run.py

sansview/sansview.py

sansview/setup_exe.py

setup.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/guiframe/gui_statusbar.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/fitpanel.py

src/sans/perspectives/fitting/fitproblem.py

src/sans/perspectives/fitting/fitting.py

src/sans/perspectives/fitting/simfitpage.py

test/park_integration/test/batch_fit.py

test/park_integration/test/utest_fit_cylinder.py

test/park_integration/test/utest_fit_line.py

test/park_integration/test/utest_fit_smeared.py

test/park_integration/test/utest_park_scipy.py

test/park_integration/test/utest_small_test.py

test/run_one.py

Download in other formats: