Changeset fd5ac0d in sasview


Ignore:
Timestamp:
Feb 13, 2015 3:26:52 AM (9 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.

Files:
28 edited
3 moved

Legend:

Unmodified
Added
Removed

  • src/sas/calculator/sas_gen.py

    r79492222 rfd5ac0d  
    11""" 
    2 SANS generic computation and sld file readers 
     2SAS generic computation and sld file readers 
    33""" 
    44from sas.models.BaseComponent import BaseComponent 

  • src/sas/dataloader/readers/associations.py

    r79492222 rfd5ac0d  
    2222 
    2323## Format version for the XML settings file 
    24 VERSION = 'sansloader/1.0' 
     24VERSION = 'sasloader/1.0' 
    2525 
    2626 
    … …  
    5454         
    5555        # Read in the file extension associations 
    56         entry_list = root.xpath('/ns:SansLoader/ns:FileType', 
     56        entry_list = root.xpath('/ns:SasLoader/ns:FileType', 
    5757                                 namespaces={'ns': VERSION}) 
    5858 

  • src/sas/dataloader/readers/danse_reader.py

    r79492222 rfd5ac0d  
    3535    type_name = "DANSE" 
    3636    ## Wildcards 
    37     type = ["DANSE files (*.sas)|*.sas"] 
     37    type = ["DANSE files (*.sans)|*.sans"] 
    3838    ## Extension 
    39     ext  = ['.sas', '.SANS'] 
     39    ext  = ['.sans', '.SANS'] 
    4040         
    4141    def read(self, filename=None): 

  • src/sas/dataloader/readers/defaults.xml

    r79492222 rfd5ac0d  
    11<?xml version="1.0"?> 
    2 <SansLoader version="1.0" 
    3     xmlns="sansloader/1.0" 
     2<SasLoader version="1.0" 
     3    xmlns="sasloader/1.0" 
    44    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    55    > 
    … …  
    1818        <FileType extension='.nxs' reader='nexus_reader'/> 
    1919     
    20 </SansLoader> 
     20</SasLoader> 
    2121 

  • 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, 

  • src/sas/guiframe/CategoryInstaller.py

    r79492222 rfd5ac0d  
    3333        returns the dir where installed_models.txt should be 
    3434        """ 
    35 import sas.dataloader.readers 
     35        import sas.dataloader.readers 
    3636        return sas.dataloader.readers.get_data_path() 
    3737 
    … …  
    4141        returns the dir where models.py should be 
    4242        """ 
    43 import sas.perspectives.fitting.models 
     43        import sas.perspectives.fitting.models 
    4444        return sas.perspectives.fitting.models.get_model_python_path() 
    4545     
    … …  
    5252        # when deploying using py2app (it will be in Contents/Resources), or 
    5353        # py2exe (it will be in the exec dir). 
    54 import sas.sansview 
     54        import sas.sasview 
    5555        cat_file = "default_categories.json" 
    5656         
    5757        possible_cat_file_paths = [ 
    58             os.path.join(os.path.split(sas.sansview.__file__)[0], cat_file),           # Source 
     58            os.path.join(os.path.split(sas.sasview.__file__)[0], cat_file),           # Source 
    5959            os.path.join(os.path.dirname(sys.executable), '..', 'Resources', cat_file), # Mac 
    6060            os.path.join(os.path.dirname(sys.executable), cat_file)                     # Windows 
    … …  
    7070    def _get_home_dir(): 
    7171        """ 
    72         returns the users sansview config dir 
     72        returns the users sasview config dir 
    7373        """ 
    7474        return os.path.join(os.path.expanduser("~"), ".sasview") 

  • src/sas/guiframe/config.py

    r79492222 rfd5ac0d  
    1111__download_page__ = 'http://sourceforge.net/projects/sasview/files/' 
    1212__update_URL__ = ['svn.code.sf.net',  
    13                   '/p/sasview/code/trunk/sansview.latestversion'] 
     13                  '/p/sasview/code/trunk/sasview.latestversion'] 
    1414 
    1515 
    … …  
    6060_copyright = "(c) 2008, University of Tennessee" 
    6161#edit the lists below of file state your plugin can read 
    62 #for sansview this how you can edit these lists 
     62#for sasview this how you can edit these lists 
    6363#PLUGIN_STATE_EXTENSIONS = ['.prv','.fitv', '.inv'] 
    6464#APPLICATION_STATE_EXTENSION = '.svs' 
    … …  
    6666#                  'Fitting files (*.fitv)|*.fitv', 
    6767#                  'Invariant files (*.inv)|*.inv'] 
    68 #APPLICATION_WLIST = 'SansView files (*.svs)|*.svs' 
     68#APPLICATION_WLIST = 'SasView files (*.svs)|*.svs' 
    6969APPLICATION_WLIST = '' 
    7070APPLICATION_STATE_EXTENSION = None 

  • src/sas/guiframe/dummyapp.py

    r79492222 rfd5ac0d  
    101101                 "self._on_context_do_something"]]    
    102102 
    103 class SansView(): 
     103class SasView(): 
    104104     
    105105    def __init__(self): 
    … …  
    124124    from multiprocessing import freeze_support 
    125125    freeze_support() 
    126     sansview = SansView() 
     126    sasview = SasView() 

  • src/sas/models/DisperseModel.py

    r79492222 rfd5ac0d  
    33""" 
    44from sas.models.BaseComponent import BaseComponent 
    5 from sans_extension.c_models import Disperser 
     5from sas_extension.c_models import Disperser 
    66     
    77class DisperseModel(Disperser, BaseComponent): 

  • src/sas/models/__init__.py

    r79492222 rfd5ac0d  
    11""" 
    2     1D Modeling for SANS 
     2    1D Modeling for SAS 
    33""" 
    44#from sas.models import * 

  • src/sas/models/c_extension/Doxyfile

    r79492222 rfd5ac0d  
    44# Project related configuration options 
    55#--------------------------------------------------------------------------- 
    6 PROJECT_NAME           = sansmodeling 
     6PROJECT_NAME           = sasmodeling 
    77PROJECT_NUMBER         =  
    88OUTPUT_DIRECTORY       = ../doc 
    … …  
    114114EXCLUDE                = build \ 
    115115                         dist \ 
    116                          sans/models/test \ 
     116                         sas/models/test \ 
    117117                         libigor \ 
    118118                         igor_wrapper \ 
    119                          sans/models/prototypes 
     119                         sas/models/prototypes 
    120120EXCLUDE_SYMLINKS       = NO 
    121121EXCLUDE_PATTERNS       =  

  • src/sas/models/c_extension/c_models/c_models.cpp.template

    r79492222 rfd5ac0d  
    11/** c_models 
    22 * 
    3  * Module containing all SANS model extensions 
     3 * Module containing all SAS model extensions 
    44 * 
    55 * @author   M.Doucet / UTK 
    … …  
    77#include <Python.h> 
    88#include <parameters.hh> 
    9 #define PY_ARRAY_UNIQUE_SYMBOL PyArray_API_sans 
     9#define PY_ARRAY_UNIQUE_SYMBOL PyArray_API_sas 
    1010#include "arrayobject.h" 
    1111 
    … …  
    191191 
    192192  m = Py_InitModule3("c_models", module_methods, 
    193       "C extension module for SANS scattering models."); 
     193      "C extension module for SAS scattering models."); 
    194194  import_array(); 
    195195 

  • src/sas/models/c_extension/libigor/GaussWeights.c

    r79492222 rfd5ac0d  
    11/* 
    22 *  GaussWeights.c 
    3  *  SANSAnalysis 
     3 *  SASAnalysis 
    44 * 
    55 *  Created by Andrew Jackson on 4/23/07. 

  • src/sas/models/c_extension/libigor/GaussWeights.h

    r79492222 rfd5ac0d  
    33/* 
    44 *  GaussWeights.h 
    5  *  SANSAnalysis 
     5 *  SASAnalysis 
    66 * 
    77 *  Created by Andrew Jackson on 4/23/07. 

  • src/sas/models/c_extension/libigor/StandardHeaders.h

    r79492222 rfd5ac0d  
    11/* 
    22 *  StandardHeaders.h 
    3  *  SANSAnalysis 
     3 *  SASAnalysis 
    44 * 
    55 *  Created by Andrew Jackson on 4/23/07. 

  • src/sas/models/c_extension/libigor/libSASAnalysis.h

    r79492222 rfd5ac0d  
    11/* 
    2  *  libSANSAnalysis.h 
    3  *  SANSAnalysis 
     2 *  libSASAnalysis.h 
     3 *  SASAnalysis 
    44 * 
    55 *  Created by Andrew Jackson on 4/24/07. 

  • src/sas/models/c_extension/python_wrapper/WrapperGenerator.py

    r79492222 rfd5ac0d  
    1919         
    2020        where my_model must be replaced by the name of the 
    21         class that you want to import from sans.models. 
     21        class that you want to import from sas.models. 
    2222        (example: [PYTHONCLASS] = MyModel 
    23           will create a class MyModel in sans.models.MyModel. 
     23          will create a class MyModel in sas.models.MyModel. 
    2424          It will also create a class CMyModel in  
    25           sans_extension.c_models.) 
     25          sas_extension.c_models.) 
    2626           
    2727        Also in comments, each parameter of the params  

  • src/sas/models/c_extension/python_wrapper/classTemplate.txt

    r79492222 rfd5ac0d  
    2323 */ 
    2424#define NO_IMPORT_ARRAY 
    25 #define PY_ARRAY_UNIQUE_SYMBOL PyArray_API_sans 
     25#define PY_ARRAY_UNIQUE_SYMBOL PyArray_API_sas 
    2626  
    2727extern "C" { 

  • src/sas/models/c_extension/python_wrapper/modelTemplate.txt

    r79492222 rfd5ac0d  
    2424""" 
    2525 
    26 from sans.models.BaseComponent import BaseComponent 
    27 from sans.models.sans_extension.c_models import [CPYTHONCLASS] 
     26from sas.models.BaseComponent import BaseComponent 
     27from sas.models.sas_extension.c_models import [CPYTHONCLASS] 
    2828 
    2929def create_[PYTHONCLASS](): 

  • src/sas/models/c_extension/python_wrapper/wrapping.py

    r79492222 rfd5ac0d  
    2424 
    2525def write_c_models(model_list): 
    26     # simultaneously generates 'sansmodels/installed_models.txt' 
    27     # and 'sansmodels/src/c_models/c_models.cpp' 
     26    # simultaneously generates 'sasmodels/installed_models.txt' 
     27    # and 'sasmodels/src/c_models/c_models.cpp' 
    2828     
    2929 
    30     template_file = open(os.path.join("src", "sans", "models","c_extension","c_models","c_models.cpp.template"),"r") 
    31     write_file = open(os.path.join("src", "sans",  "models","c_extension","c_models","c_models.cpp"),"w") 
     30    template_file = open(os.path.join("src", "sas", "models","c_extension","c_models","c_models.cpp.template"),"r") 
     31    write_file = open(os.path.join("src", "sas",  "models","c_extension","c_models","c_models.cpp"),"w") 
    3232    buf = template_file.read() 
    3333    lines = buf.split('\n') 
    … …  
    6363if __name__ == '__main__': 
    6464    header_dir = os.path.join('..', 'include') 
    65     generate_wrappers(header_dir, output_dir="../sans/models/", c_wrapper_dir='.') 
     65    generate_wrappers(header_dir, output_dir="../sas/models/", c_wrapper_dir='.') 
    6666 
    6767 

  • src/sas/models/c_extension/release_notes.txt

    r79492222 rfd5ac0d  
    22============= 
    33 
    4 SANS Models version 0.4.3 
     4SAS Models version 0.4.3 
    55 
    66Package name: sans.models  

  • src/sas/models/dispersion_models.py

    r79492222 rfd5ac0d  
    2222 
    2323Usage: 
    24 These classes can be used to set the dispersion model of a SANS model 
     24These classes can be used to set the dispersion model of a SAS model 
    2525parameter: 
    2626 
    … …  
    4343     
    4444""" 
    45 import sans_extension.c_models as c_models  
     45import sas_extension.c_models as c_models  
    4646 
    4747 

  • src/sas/models/media/pd_help.html

    r79492222 rfd5ac0d  
    5656<p>This distribution is to be given 
    5757by users as a txt file where the array should be defined by two columns in the 
    58 order of x and f(x) values. The f(x) will be normalized by SansView during the 
     58order of x and f(x) values. The f(x) will be normalized by SasView during the 
    5959computation.</p> 
    6060 

  • src/sas/models/media/smear_computation.html

    r79492222 rfd5ac0d  
    2727 
    2828<p class=MsoNormal><span style='font-family:"Times New Roman","serif"'>The sit 
    29 smeared scattering intensity for SANS is defined by</span></p> 
     29smeared scattering intensity for SAS is defined by</span></p> 
    3030 
    3131<p class=MsoNormal><img  
    … …  
    155155number of iteration, say at least 10000 by 10000 for each element of the matrix 
    156156W, which will take minutes and minutes to finish the calculation for a set of 
    157 typical SANS data. An alternative way which is correct for slit width &lt;&lt; 
    158 slit hight, is used in the SANSView:  This method is a mixed method that 
     157typical SAS data. An alternative way which is correct for slit width &lt;&lt; 
     158slit hight, is used in the SASView:  This method is a mixed method that 
    159159combines the method 1) with the numerical integration for the slit width.</span></p> 
    160160 
    … …  
    272272 
    273273<p class=MsoNormal><span style='font-family:"Times New Roman","serif"'>Here, the 
    274 current version of the SANSVIEW uses the Eq. (11) for 2D smearing assuming that 
     274current version of the SASVIEW uses the Eq. (11) for 2D smearing assuming that 
    275275all the Gaussian weighting functions are aligned in the polar coordinate. </span></p> 
    276276<p> In the control panel, the higher accuracy indicates more and finer binnng points  

  • src/sas/models/qsmearing.py

    r79492222 rfd5ac0d  
    3434    :param model: sas.model instance 
    3535    """ 
    36     # Sanity check. If we are not dealing with a SANS Data1D 
     36    # Sanity check. If we are not dealing with a SAS Data1D 
    3737    # object, just return None 
    3838    if  data1D.__class__.__name__ not in ['Data1D', 'Theory1D']: 
    … …  
    343343class SlitSmearer(_SlitSmearer): 
    344344    """ 
    345     Adaptor for slit smearing class and SANS data 
     345    Adaptor for slit smearing class and SAS data 
    346346    """ 
    347347    def __init__(self, data1D, model = None): 
    … …  
    461461class QSmearer(_QSmearer): 
    462462    """ 
    463     Adaptor for Gaussian Q smearing class and SANS data 
     463    Adaptor for Gaussian Q smearing class and SAS data 
    464464    """ 
    465465    def __init__(self, data1D, model = None): 

  • src/sas/models/smearing_2d.py

    r79492222 rfd5ac0d  
    1919class Smearer2D: 
    2020    """ 
    21     Gaussian Q smearing class for SANS 2d data 
     21    Gaussian Q smearing class for SAS 2d data 
    2222    """ 
    2323      
    … …  
    152152        if self._engine == 'c' and self.coords == 'polar': 
    153153            try: 
    154 import sas.models.sas_extension.smearer2d_helper as smearer2dc 
     154                import sas.models.sas_extension.smearer2d_helper as smearer2dc 
    155155                smearc = smearer2dc.new_Smearer_helper(self.qx_data,  
    156156                                              self.qy_data, 

  • src/sas/perspectives/fitting/fitting.py

    rb9a5f0e rfd5ac0d  
    5151 
    5252MAX_NBR_DATA = 4 
    53 SANS_F_TOL = 5e-05 
     53SAS_F_TOL = 5e-05 
    5454 
    5555(PageInfoEvent, EVT_PAGE_INFO) = wx.lib.newevent.NewEvent() 
    … …  
    9494        self._gui_engine = None 
    9595        ## Relative error desired in the sum of squares (float); scipy only 
    96         self.ftol = SANS_F_TOL 
     96        self.ftol = SAS_F_TOL 
    9797        self.batch_reset_flag = True 
    9898        #List of selected data 
    … …  
    291291                msg += "Please manually remove the files (.py, .pyc) " 
    292292                msg += "in the 'plugin_models' folder \n" 
    293                 msg += "inside of the SansView application, " 
     293                msg += "inside of the SasView application, " 
    294294                msg += "and try it again." 
    295295                wx.MessageBox(msg, 'Info') 
    … …  
    817817        except: 
    818818            # default 
    819             f_tol = SANS_F_TOL 
     819            f_tol = SAS_F_TOL 
    820820             
    821821        self.ftol = f_tol 
    … …  
    13731373                if model is not None and hasattr(model, "model"): 
    13741374                    model = model.model 
    1375                 if data is not None and hasattr(data, "sans_data"): 
    1376                     data = data.sans_data 
     1375                if data is not None and hasattr(data, "sas_data"): 
     1376                    data = data.sas_data 
    13771377                 
    13781378                is_data2d = issubclass(data.__class__, Data2D) 
Note: See TracChangeset for help on using the changeset viewer.