-                      r985c88b
+                      r48882d1
+import park,numpy
+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):
+         self._model, self._name = model,name
+         self.set(model.getParam(name))
+    def _getvalue(self): return self._model.getParam(self.name)
+    def _setvalue(self,value):
+        self._model.setParam(self.name, value)
+    value = property(_getvalue,_setvalue)
+    def _getrange(self):
+        lo,hi = self._model.details[self.name][1:]
+        if lo is None: lo = -numpy.inf
+        if hi is None: hi = numpy.inf
+        return lo,hi
+    def _setrange(self,r):
+        self._model.details[self.name][1:] = r
+    range = property(_getrange,_setrange)
+class Model(object):
+    """
+        PARK wrapper for SANS models.
+    """
+    def __init__(self, sans_model):
+        self.model = sans_model
+        #print "ParkFitting:sans model",self.model
+        self.sansp = sans_model.getParamList()
+        #print "ParkFitting: sans model parameter list",sansp
+        self.parkp = [SansParameter(p,sans_model) for p in self.sansp]
+        #print "ParkFitting: park model parameter ",self.parkp
+        self.parameterset = park.ParameterSet(sans_model.name,pars=self.parkp)
+        self.pars=[]
+    def getParams(self,fitparams):
+        list=[]
+        self.pars=[]
+        self.pars=fitparams
+        for item in fitparams:
+            for element in self.parkp:
+                 if element.name ==str(item):
+                     list.append(element.value)
+        #print "abstractfitengine: getparams",list
+        return list
+    def setParams(self, params):
+        list=[]
+        for item in self.parkp:
+            list.append(item.name)
+        list.sort()
+        for i in range(len(params)):
+            #self.parkp[i].value = params[i]
+            #print "abstractfitengine: set-params",list[i],params[i]
+            self.model.setParam(list[i],params[i])
+    def eval(self,x):
+        #print "eval",self.parameterset[0].value,self.parameterset[1].value
+        return self.model.runXY(x)
+class Data(object):
+    """ Wrapper class  for SANS data """
+    def __init__(self,x=None,y=None,dy=None,dx=None,sans_data=None):
+        if  sans_data !=None:
+            self.x= sans_data.x
+            self.y= sans_data.y
+            self.dx= sans_data.dx
+            self.dy= sans_data.dy
+        elif (x!=None and y!=None and dy!=None):
+                self.x=x
+                self.y=y
+                self.dx=dx
+                self.dy=dy
+        else:
+            raise ValueError,\
+            "Data is missing x, y or dy, impossible to compute residuals later on"
+        self.qmin=None
+        self.qmax=None
+    def setFitRange(self,mini=None,maxi=None):
+        """ to set the fit range"""
+        self.qmin=mini
+        self.qmax=maxi
+    def getFitRange(self):
+         return self.qmin, self.qmax
+    def residuals(self, fn):
+        """ @param fn: function that return model value
+            @return residuals
+        """
+        x,y,dy = [numpy.asarray(v) for v in (self.x,self.y,self.dy)]
+        if self.qmin==None and self.qmax==None:
+            fx =[fn(v) for v in x]
+            return (y - fx)/dy
+        else:
+            idx = (x>=self.qmin) & (x <= self.qmax)
+            fx = [fn(item)for item in x[idx ]]
+            return (y[idx] - fx)/dy[idx]
+    def residuals_deriv(self, model, pars=[]):
+        """
+            @return residuals derivatives .
+            @note: in this case just return empty array
+        """
+        return []
+class sansAssembly:
+    def __init__(self,Model=None , Data=None):
+       self.model = Model
+       self.data  = Data
+       self.res=[]
+    def chisq(self, params):
+        """
+            Calculates chi^2
+            @param params: list of parameter values
+            @return: chi^2
+        """
+        sum = 0
+        for item in self.res:
+            sum += item*item
+        return sum
+    def __call__(self,params):
+        self.model.setParams(params)
+        self.res= self.data.residuals(self.model.eval)
+        return self.res
 class FitEngine:
     def __init__(self):
 …
             @param listdata: list of data
+            @return xtemp, ytemp,dytemp:  x,y,dy respectively of data all combined
+                if xi,yi,dyi of two or more data are the same the second appearance of xi,yi,
+                dyi is ignored in the concatenation.
+            @return Data:
             @raise: if listdata is empty  will return None
 …
             ytemp=[]
             dytemp=[]
+            self.mini=None
+            self.maxi=None
             for data in listdata:
+                mini,maxi=data.getFitRange()
+                if self.mini==None and self.maxi==None:
+                    self.mini=mini
+                    self.maxi=maxi
+                else:
+                    if mini < self.mini:
+                        self.mini=mini
+                    if self.maxi < maxi:
+                        self.maxi=maxi
                 for i in range(len(data.x)):
                     xtemp.append(data.x[i])
 …
                     else:
                         raise RuntimeError, "Fit._concatenateData: y-errors missing"
+            return xtemp, ytemp,dytemp
+            #return xtemp, ytemp,dytemp
+            data= Data(x=xtemp,y=ytemp,dy=dytemp)
+            data.setFitRange(self.mini, self.maxi)
+            return data
     def set_model(self,model,name,Uid,pars=[]):
-        """
-            Receive a dictionary of parameter and save it Parameter list
-            For scipy.fit use.
-            Set model in a FitArrange object and add that object in a dictionary
-            with key Uid.
-            @param model: model on with parameter values are set
-            @param name: model name
-            @param Uid: unique key corresponding to a fitArrange object with model
-            @param pars: dictionary of paramaters name and value
-            pars={parameter's name: parameter's value}
-        """
-        print "AbstractFitEngine:  fitting parmater",pars
         if len(pars) >0:
             self.parameters=[]
+            self.paramList = []
             if model==None:
                 raise ValueError, "AbstractFitEngine: Specify parameters to fit"
             else:
+                model.name=name
+                for param_name in pars:
+                    value=model.getParam(param_name)
+                    if value==None:
+                        raise ValueError ,"%s has not value set"%param_name
+                    param = Parameter(model,param_name,value)
+                    self.parameters.append(param)
+                    self.paramList.append(param_name)
+            print "AbstractFitEngine: self.paramList2", self.paramList
+                model.name = name
+                self.paramList=pars
             #A fitArrange is already created but contains dList only at Uid
             if self.fitArrangeList.has_key(Uid):
 …
             else:
             #no fitArrange object has been create with this Uid
                 fitproblem= FitArrange()
+                fitproblem = FitArrange()
                 fitproblem.set_model(model)
                 self.fitArrangeList[Uid]=fitproblem
+                self.fitArrangeList[Uid] = fitproblem
         else:
             raise ValueError, "park_integration:missing parameters"
+    def set_data(self,data,Uid):
+    def set_data(self,data,Uid,qmin=None,qmax=None):
         """ Receives plottable, creates a list of data to fit,set data
             in a FitArrange object and adds that object in a dictionary
 …
             @param Uid: unique key corresponding to a fitArrange object with data
             """
+        if qmin !=None and qmax !=None:
+            data.setFitRange(mini=qmin,maxi=qmax)
         #A fitArrange is already created but contains model only at Uid
         if self.fitArrangeList.has_key(Uid):
 …
             fitproblem= FitArrange()
             fitproblem.add_data(data)
             self.fitArrangeList[Uid]=fitproblem
+            self.fitArrangeList[Uid]=fitproblem
     def get_model(self,Uid):
         """
 …
         if self.fitArrangeList.has_key(Uid):
             del self.fitArrangeList[Uid]
+class Parameter:
+    """
+        Class to handle model parameters
+    """
+    def __init__(self, model, name, value=None):
+            self.model = model
+            self.name = name
+            if not value==None:
+                self.model.setParam(self.name, value)
+    def set(self, value):
+        """
+            Set the value of the parameter
+        """
+        self.model.setParam(self.name, value)
+    def __call__(self):
+        """
+            Return the current value of the parameter
+        """
+        return self.model.getParam(self.name)
 class FitArrange:

Note: See TracChangeset for help on using the changeset viewer.

SasView

Changeset 48882d1 in sasview for park_integration/AbstractFitEngine.py

Legend:

park_integration/AbstractFitEngine.py

Download in other formats: