-                      ra1b8fee
+                      r50fcb09
                that will smear the theory data (slit smearing or resolution
                smearing) when set.
             The proper way to set the smearing object would be to
             do the following: ::
                 from sas.sascalc.data_util.qsmearing import smear_selection
+                from sas.sascalc.fit.qsmearing import smear_selection
                 smearer = smear_selection(some_data)
                 fitdata1d = FitData1D( x= [1,3,..,],
 …
                                         dx=None,
                                         dy=[1,2...], smearer= smearer)
             :Note: that some_data _HAS_ to be of
                 class DataLoader.data_info.Data1D
                 Setting it back to None will turn smearing off.
         """
         Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy)
 …
         ## Max Q-value
         self.qmax = max(self.x)
         # Range used for input to smearing
         self._qmin_unsmeared = self.qmin
 …
         self.idx_unsmeared = (self.x >= self._qmin_unsmeared) \
                             & (self.x <= self._qmax_unsmeared)
     def set_fit_range(self, qmin=None, qmax=None):
         """ to set the fit range"""
 …
         self._qmin_unsmeared = self.qmin
         self._qmax_unsmeared = self.qmax
         self._first_unsmeared_bin = 0
         self._last_unsmeared_bin = len(self.x) - 1
         if self.smearer is not None:
             self._first_unsmeared_bin, self._last_unsmeared_bin = \
 …
             self._qmin_unsmeared = self.x[self._first_unsmeared_bin]
             self._qmax_unsmeared = self.x[self._last_unsmeared_bin]
         # Identify the bin range for the unsmeared and smeared spaces
         self.idx = (self.x >= self.qmin) & (self.x <= self.qmax)
 …
         """
             Compute residuals.
             If self.smearer has been set, use if to smear
             the data before computing chi squared.
             :param fn: function that return model value
             :return: residuals
         """
 …
         fx = np.zeros(len(self.x))
         fx[self.idx_unsmeared] = fn(self.x[self.idx_unsmeared])
         ## Smear theory data
         if self.smearer is not None:
 …
             raise RuntimeError, msg
         return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx], fx[self.idx]
     def residuals_deriv(self, model, pars=[]):
         """
             :return: residuals derivatives .
             :note: in this case just return empty array
+            :note: in this case just return empty array
         """
         return []
 …
         x_max = max(math.fabs(sas_data2d.xmin), math.fabs(sas_data2d.xmax))
         y_max = max(math.fabs(sas_data2d.ymin), math.fabs(sas_data2d.ymax))
         ## fitting range
         if qmin is None:
 …
             self.res_err_data = copy.deepcopy(self.err_data)
         #self.res_err_data[self.res_err_data==0]=1
         self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2)
         # Note: mask = True: for MASK while mask = False for NOT to mask
         self.idx = ((self.qmin <= self.radius) &\
 …
         return res, gn
     def residuals_deriv(self, model, pars=[]):
         """
         :return: residuals derivatives .
         :note: in this case just return empty array
         """
         return []
 class FitAbort(Exception):
     """
 …
         self.fit_arrange_dict = {}
         self.fitter_id = None
     def set_model(self, model, id, pars=[], constraints=[], data=None):
         """
         set a model on a given  in the fit engine.
         :param model: sas.models type
+        :param model: sas.models type
         :param id: is the key of the fitArrange dictionary where model is saved as a value
         :param pars: the list of parameters to fit
         :param constraints: list of
+        :param pars: the list of parameters to fit
+        :param constraints: list of
             tuple (name of parameter, value of parameters)
             the value of parameter must be a string to constraint 2 different
             parameters.
             Example:
+            Example:
             we want to fit 2 model M1 and M2 both have parameters A and B.
             constraints can be ``constraints = [(M1.A, M2.B+2), (M1.B= M2.A *5),...,]``
         :note: pars must contains only name of existing model's parameters
         """
         if not pars:
 …
         in a FitArrange object and adds that object in a dictionary
         with key id.
         :param data: data added
         :param id: unique key corresponding to a fitArrange object with data
 …
                                  dx=data.dx, dy=data.dy, smearer=smearer)
         fitdata.sas_data = data
         fitdata.set_fit_range(qmin=qmin, qmax=qmax)
         #A fitArrange is already created but contains model only at id
 …
             fitproblem.add_data(fitdata)
             self.fit_arrange_dict[id] = fitproblem
     def get_model(self, id):
         """
         :param id: id is key in the dictionary containing the model to return
         :return:  a model at this id or None if no FitArrange element was
             created with this id
 …
         else:
             return None
     def remove_fit_problem(self, id):
         """remove   fitarrange in id"""
         if id in self.fit_arrange_dict:
             del self.fit_arrange_dict[id]
     def select_problem_for_fit(self, id, value):
         """
         select a couple of model and data at the id position in dictionary
         and set in self.selected value to value
         :param value: the value to allow fitting.
                 can only have the value one or zero
 …
         if id in self.fit_arrange_dict:
             self.fit_arrange_dict[id].set_to_fit(value)
     def get_problem_to_fit(self, id):
         """
         return the self.selected value of the fit problem of id
         :param id: the id of the problem
         """
         if id in self.fit_arrange_dict:
             self.fit_arrange_dict[id].get_to_fit()
 class FitArrange:
     def __init__(self):
 …
         to perform the Fit.FitArrange must contain exactly one model
         and at least one data for the fit to be performed.
         model: the model selected by the user
         Ldata: a list of data what the user wants to fit
         """
         self.model = None
 …
         """
         set_model save a copy of the model
         :param model: the model being set
         """
         self.model = model
     def add_data(self, data):
         """
         add_data fill a self.data_list with data to fit
         :param data: Data to add in the list
         """
         if not data in self.data_list:
             self.data_list.append(data)
     def get_model(self):
         """
 …
         """
         return self.model
     def get_data(self):
         """
 …
         """
         return self.data_list[0]
     def remove_data(self, data):
         """
         Remove one element from the list
         :param data: Data to remove from data_list
         """
         if data in self.data_list:
             self.data_list.remove(data)
     def set_to_fit(self, value=0):
         """
         set self.selected to 0 or 1  for other values raise an exception
         :param value: integer between 0 or 1
         """
         self.selected = value
     def get_to_fit(self):
         """
 …
         if self.model is not None and self.data is not None:
             self.inputs = [(self.model, self.data)]
     def set_model(self, model):
         """
         """
         self.model = model
     def set_fitness(self, fitness):
         """
         """
         self.fitness = fitness
     def __str__(self):
         """
 …
         msg = [msg1, msg3] + msg2
         return "\n".join(msg)
     def print_summary(self):
         """

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

SasView

Changeset 50fcb09 in sasview for src/sas/sascalc/pr/fit

Legend:

src/sas/sascalc/pr/fit/AbstractFitEngine.py

Download in other formats: