Changeset fd5ac0d in sasview for src/sas/fit


Ignore:
Timestamp:
Feb 13, 2015 5:26:52 AM (10 years ago)
Author:
krzywon
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
7a04dbb
Parents:
b9a5f0e
Message:

I have completed the removal of all SANS references.
I will build, run, and run all unit tests before pushing.

Location:
src/sas/fit
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • src/sas/fit/AbstractFitEngine.py

    r79492222 rfd5ac0d  
    6565class Model: 
    6666    """ 
    67     Fit wrapper for SANS models. 
    68     """ 
    69     def __init__(self, sans_model, sans_data=None, **kw): 
    70         """ 
    71         :param sans_model: the sas model to wrap using park interface 
    72  
    73         """ 
    74         self.model = sans_model 
    75         self.name = sans_model.name 
    76         self.data = sans_data 
     67    Fit wrapper for SAS models. 
     68    """ 
     69    def __init__(self, sas_model, sas_data=None, **kw): 
     70        """ 
     71        :param sas_model: the sas model to wrap using park interface 
     72 
     73        """ 
     74        self.model = sas_model 
     75        self.name = sas_model.name 
     76        self.data = sas_data 
    7777 
    7878    def get_params(self, fitparams): 
    … …  
    128128class FitData1D(Data1D): 
    129129    """ 
    130         Wrapper class  for SANS data 
     130        Wrapper class  for SAS data 
    131131        FitData1D inherits from DataLoader.data_info.Data1D. Implements 
    132132        a way to get residuals from data. 
    … …  
    155155        Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy) 
    156156        self.num_points = len(x) 
    157         self.sans_data = data 
     157        self.sas_data = data 
    158158        self.smearer = smearer 
    159159        self._first_unsmeared_bin = None 
    … …  
    265265class FitData2D(Data2D): 
    266266    """ 
    267         Wrapper class  for SANS data 
    268     """ 
    269     def __init__(self, sans_data2d, data=None, err_data=None): 
     267        Wrapper class  for SAS data 
     268    """ 
     269    def __init__(self, sas_data2d, data=None, err_data=None): 
    270270        Data2D.__init__(self, data=data, err_data=err_data) 
    271271        # Data can be initialized with a sas plottable or with vectors. 
    … …  
    278278        self.radius = 0 
    279279        self.res_err_data = [] 
    280         self.sans_data = sans_data2d 
    281         self.set_data(sans_data2d) 
    282  
    283     def set_data(self, sans_data2d, qmin=None, qmax=None): 
     280        self.sas_data = sas_data2d 
     281        self.set_data(sas_data2d) 
     282 
     283    def set_data(self, sas_data2d, qmin=None, qmax=None): 
    284284        """ 
    285285            Determine the correct qx_data and qy_data within range to fit 
    286286        """ 
    287         self.data = sans_data2d.data 
    288         self.err_data = sans_data2d.err_data 
    289         self.qx_data = sans_data2d.qx_data 
    290         self.qy_data = sans_data2d.qy_data 
    291         self.mask = sans_data2d.mask 
    292  
    293         x_max = max(math.fabs(sans_data2d.xmin), math.fabs(sans_data2d.xmax)) 
    294         y_max = max(math.fabs(sans_data2d.ymin), math.fabs(sans_data2d.ymax)) 
     287        self.data = sas_data2d.data 
     288        self.err_data = sas_data2d.err_data 
     289        self.qx_data = sas_data2d.qx_data 
     290        self.qy_data = sas_data2d.qy_data 
     291        self.mask = sas_data2d.mask 
     292 
     293        x_max = max(math.fabs(sas_data2d.xmin), math.fabs(sas_data2d.xmax)) 
     294        y_max = max(math.fabs(sas_data2d.ymin), math.fabs(sas_data2d.ymax)) 
    295295         
    296296        ## fitting range 
    … …  
    453453        """ 
    454454        if data.__class__.__name__ == 'Data2D': 
    455             fitdata = FitData2D(sans_data2d=data, data=data.data, 
     455            fitdata = FitData2D(sas_data2d=data, data=data.data, 
    456456                                 err_data=data.err_data) 
    457457        else: 
    458458            fitdata = FitData1D(x=data.x, y=data.y, 
    459459                                 dx=data.dx, dy=data.dy, smearer=smearer) 
    460         fitdata.sans_data = data 
     460        fitdata.sas_data = data 
    461461        
    462462        fitdata.set_fit_range(qmin=qmin, qmax=qmax) 

  • src/sas/fit/BumpsFitting.py

    r79492222 rfd5ac0d  
    1212from bumps.fitproblem import FitProblem 
    1313 
    14 from sas import FitEngine 
    15 from sas import FResult 
    16 from sas import compile_constraints 
     14from sas.fit.AbstractFitEngine import FitEngine 
     15from sas.fit.AbstractFitEngine import FResult 
     16from sas.fit.expression import compile_constraints 
    1717 
    1818class Progress(object): 
    … …  
    9191# The disadvantage of this technique is that we need to copy every parameter 
    9292# back into the model each time the function is evaluated.  We could instead 
    93 # define reference parameters for each sans parameter, but then we would not 
     93# define reference parameters for each sas parameter, but then we would not 
    9494# be able to express constraints using python expressions in the usual way 
    9595# from bumps, and would instead need to use string expressions. 

  • src/sas/fit/ParkFitting.py

    r79492222 rfd5ac0d  
    33 
    44""" 
    5 ParkFitting module contains SansParameter,Model,Data 
     5ParkFitting module contains SasParameter,Model,Data 
    66FitArrange, ParkFit,Parameter classes.All listed classes work together 
    77to perform a simple fit with park optimizer. 
    … …  
    2525from sas.fit.AbstractFitEngine import FResult 
    2626 
    27 class SansParameter(park.Parameter): 
    28     """ 
    29     SANS model parameters for use in the PARK fitting service. 
     27class SasParameter(park.Parameter): 
     28    """ 
     29    SAS model parameters for use in the PARK fitting service. 
    3030    The parameter attribute value is redirected to the underlying 
    31     parameter value in the SANS model. 
     31    parameter value in the SAS model. 
    3232    """ 
    3333    def __init__(self, name, model, data): 
    … …  
    100100class ParkModel(park.Model): 
    101101    """ 
    102     PARK wrapper for SANS models. 
    103     """ 
    104     def __init__(self, sans_model, sans_data=None, **kw): 
    105         """ 
    106         :param sans_model: the sas model to wrap using park interface 
     102    PARK wrapper for SAS models. 
     103    """ 
     104    def __init__(self, sas_model, sas_data=None, **kw): 
     105        """ 
     106        :param sas_model: the sas model to wrap using park interface 
    107107 
    108108        """ 
    109109        park.Model.__init__(self, **kw) 
    110         self.model = sans_model 
    111         self.name = sans_model.name 
    112         self.data = sans_data 
     110        self.model = sas_model 
     111        self.name = sas_model.name 
     112        self.data = sas_data 
    113113        #list of parameters names 
    114         self.sansp = sans_model.getParamList() 
     114        self.sasp = sas_model.getParamList() 
    115115        #list of park parameter 
    116         self.parkp = [SansParameter(p, sans_model, sans_data) for p in self.sansp] 
     116        self.parkp = [SasParameter(p, sas_model, sas_data) for p in self.sasp] 
    117117        #list of parameter set 
    118         self.parameterset = park.ParameterSet(sans_model.name, pars=self.parkp) 
     118        self.parameterset = park.ParameterSet(sas_model.name, pars=self.parkp) 
    119119        self.pars = [] 
    120120 
    … …  
    176176 
    177177 
    178 class SansFitResult(fitresult.FitResult): 
     178class SasFitResult(fitresult.FitResult): 
    179179    def __init__(self, *args, **kwrds): 
    180180        fitresult.FitResult.__init__(self, *args, **kwrds) 
    … …  
    182182        self.inputs = [] 
    183183         
    184 class SansFitSimplex(FitSimplex): 
     184class SasFitSimplex(FitSimplex): 
    185185    """ 
    186186    Local minimizer using Nelder-Mead simplex algorithm. 
    … …  
    216216        # Need to make our own copy of the fit results so that the 
    217217        # values don't get stomped on by the next fit iteration. 
    218         fitpars = [SansFitParameter(pars[i].name,pars[i].range,v, pars[i].model, pars[i].data) 
     218        fitpars = [SasFitParameter(pars[i].name,pars[i].range,v, pars[i].model, pars[i].data) 
    219219                   for i,v in enumerate(result.x)] 
    220         res = SansFitResult(fitpars, result.calls, result.fx) 
     220        res = SasFitResult(fitpars, result.calls, result.fx) 
    221221        res.inputs = [(pars[i].model, pars[i].data) for i,v in enumerate(result.x)] 
    222222        # Compute the parameter uncertainties from the jacobian 
    … …  
    224224        return res 
    225225       
    226 class SansFitter(Fitter): 
     226class SasFitter(Fitter): 
    227227    """ 
    228228    """ 
    … …  
    243243        handler.done = False 
    244244        self.handler = handler 
    245         fitpars = [SansFitParameter(pars[i].name, pars[i].range, v, 
     245        fitpars = [SasFitParameter(pars[i].name, pars[i].range, v, 
    246246                                     pars[i].model, pars[i].data) 
    247247                   for i,v in enumerate(x0)] 
    … …  
    252252        self._fit(fitness, x0, bounds) 
    253253         
    254 class SansFitMC(SansFitter): 
     254class SasFitMC(SasFitter): 
    255255    """ 
    256256    Monte Carlo optimizer. 
    … …  
    258258    This implements `park.fit.Fitter`. 
    259259    """ 
    260     localfit = SansFitSimplex() 
     260    localfit = SasFitSimplex() 
    261261    start_points = 10 
    262262    def __init__(self, localfit, start_points=10): 
    … …  
    276276            raise ValueError, "Fit did not converge.\n" 
    277277         
    278 class SansPart(Part): 
     278class SasPart(Part): 
    279279    """ 
    280280    Part of a fitting assembly.  Part holds the model itself and 
    … …  
    318318        self.model, self.data = fitness[0], fitness[1] 
    319319 
    320 class SansFitParameter(FitParameter): 
     320class SasFitParameter(FitParameter): 
    321321    """ 
    322322    Fit result for an individual parameter. 
    … …  
    363363        self.parts = [] 
    364364        for m in models: 
    365             self.parts.append(SansPart(m)) 
     365            self.parts.append(SasPart(m)) 
    366366        self.curr_thread = curr_thread 
    367367        self.chisq = None 
    … …  
    390390        # Convert to fitparameter a object 
    391391         
    392         fitpars = [SansFitParameter(p.path,p.range,p.value, p.model, p.data) 
     392        fitpars = [SasFitParameter(p.path,p.range,p.value, p.model, p.data) 
    393393                   for p in self._fitparameters] 
    394394        #print "fitpars", fitpars 
    … …  
    399399        Extend result from the fit with the calculated parameters. 
    400400        """ 
    401         calcpars = [SansFitParameter(p.path,p.range,p.value, p.model, p.data) 
     401        calcpars = [SasFitParameter(p.path,p.range,p.value, p.model, p.data) 
    402402                    for p in self.parameterset.computed] 
    403403        result.parameters += calcpars 
    … …  
    493493    def create_assembly(self, curr_thread, reset_flag=False): 
    494494        """ 
    495         Extract sansmodel and sansdata from  
     495        Extract sasmodel and sasdata from  
    496496        self.FitArrangelist ={Uid:FitArrange} 
    497497        Create parkmodel and park data ,form a list couple of parkmodel  
    … …  
    562562        """ 
    563563        self.create_assembly(curr_thread=curr_thread, reset_flag=reset_flag) 
    564         localfit = SansFitSimplex() 
     564        localfit = SasFitSimplex() 
    565565        localfit.ftol = ftol 
    566566        localfit.xtol = 1e-6 
    567567 
    568568        # See `park.fitresult.FitHandler` for details. 
    569         fitter = SansFitMC(localfit=localfit, start_points=1) 
     569        fitter = SasFitMC(localfit=localfit, start_points=1) 
    570570        if handler == None: 
    571571            handler = fitresult.ConsoleUpdate(improvement_delta=0.1) 
    … …  
    584584        for m in self.problem.parts: 
    585585            residuals, theory = m.fitness.residuals() 
    586             small_result = FResult(model=m.model, data=m.data.sans_data) 
     586            small_result = FResult(model=m.model, data=m.data.sas_data) 
    587587            small_result.fitter_id = self.fitter_id 
    588588            small_result.theory = theory 

  • src/sas/fit/ScipyFitting.py

    r79492222 rfd5ac0d  
    1414_SMALLVALUE = 1.0e-10 
    1515 
    16 class SansAssembly: 
    17     """ 
    18     Sans Assembly class a class wrapper to be call in optimizer.leastsq method 
     16class SasAssembly: 
     17    """ 
     18    Sas Assembly class a class wrapper to be call in optimizer.leastsq method 
    1919    """ 
    2020    def __init__(self, paramlist, model=None, data=None, fitresult=None, 
    … …  
    212212        if handler is not None: 
    213213            handler.set_result(result=result) 
    214         functor = SansAssembly(paramlist=pars, 
     214        functor = SasAssembly(paramlist=pars, 
    215215                               model=model, 
    216216                               data=data, 
Note: See TracChangeset for help on using the changeset viewer.