Changeset 1e3169c in sasview


Ignore:
Timestamp:
Oct 27, 2009 11:56:39 AM (15 years ago)
Author:
Gervaise Alina <gervyh@…>
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:
b37f72f
Parents:
cc1500d
Message:

change fitdata1D to inheritates from dataloader.data1D

Location:
park_integration
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • park_integration/AbstractFitEngine.py

    r2eaaf1a r1e3169c  
    11import logging, sys 
    22import park,numpy,math, copy 
    3  
     3from DataLoader.data_info import Data1D 
     4from DataLoader.data_info import Data2D 
    45class SansParameter(park.Parameter): 
    56    """ 
    … …  
    119120 
    120121     
    121 class FitData1D(object): 
    122     """ Wrapper class  for SANS data """ 
    123     def __init__(self,sans_data1d, smearer=None): 
    124         """ 
    125             Data can be initital with a data (sans plottable) 
    126             or with vectors. 
    127              
    128             self.smearer is an object of class QSmearer or SlitSmearer 
     122class FitData1D(Data1D): 
     123    """  
     124        Wrapper class  for SANS data  
     125        FitData1D inherits from DataLoader.data_info.Data1D. Implements  
     126        a way to get residuals from data. 
     127    """ 
     128    def __init__(self,x, y,dx= None, dy=None, smearer=None): 
     129        Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy) 
     130        """ 
     131            @param smearer: is an object of class QSmearer or SlitSmearer 
    129132            that will smear the theory data (slit smearing or resolution  
    130133            smearing) when set. 
    … …  
    134137             
    135138            from DataLoader.qsmearing import smear_selection 
    136             fitdata1d = FitData1D(some_data) 
    137             fitdata1d.smearer = smear_selection(some_data) 
    138              
     139            smearer = smear_selection(some_data) 
     140            fitdata1d = FitData1D( x= [1,3,..,],  
     141                                    y= [3,4,..,8],  
     142                                    dx=None, 
     143                                    dy=[1,2...], smearer= smearer) 
     144            
    139145            Note that some_data _HAS_ to be of class DataLoader.data_info.Data1D 
    140146             
    … …  
    144150         
    145151        self.smearer = smearer 
    146        
    147         # Initialize from Data1D object 
    148         self.data=sans_data1d 
    149         self.x= numpy.array(sans_data1d.x) 
    150         self.y= numpy.array(sans_data1d.y) 
    151         self.dx= sans_data1d.dx 
    152         if sans_data1d.dy ==None or sans_data1d.dy==[]: 
     152        if dy ==None or dy==[]: 
    153153            self.dy= numpy.zeros(len(self.y))   
    154154        else: 
    155             self.dy= numpy.asarray(sans_data1d.dy) 
     155            self.dy= numpy.asarray(dy) 
    156156      
    157157        # For fitting purposes, replace zero errors by 1 
    … …  
    162162        ## Min Q-value 
    163163        #Skip the Q=0 point, especially when y(q=0)=None at x[0]. 
    164         if min (self.data.x) ==0.0 and self.data.x[0]==0 and not numpy.isfinite(self.data.y[0]): 
    165             self.qmin = min(self.data.x[self.data.x!=0]) 
     164        if min (self.x) ==0.0 and self.x[0]==0 and not numpy.isfinite(self.y[0]): 
     165            self.qmin = min(self.x[self.x!=0]) 
    166166        else:                               
    167             self.qmin= min (self.data.x) 
     167            self.qmin= min (self.x) 
    168168        ## Max Q-value 
    169         self.qmax= max (self.data.x) 
     169        self.qmax = max (self.x) 
    170170         
    171171        # Range used for input to smearing 
    … …  
    182182        # Skip Q=0 point, (especially for y(q=0)=None at x[0]). 
    183183        #ToDo: Fix this. 
    184         if qmin==0.0 and not numpy.isfinite(self.data.y[qmin]): 
    185             self.qmin = min(self.data.x[self.data.x!=0]) 
     184        if qmin==0.0 and not numpy.isfinite(self.y[qmin]): 
     185            self.qmin = min(self.x[self.x!=0]) 
    186186        elif qmin!=None:                        
    187187            self.qmin = qmin             
    … …  
    196196         
    197197        self._first_unsmeared_bin = 0 
    198         self._last_unsmeared_bin  = len(self.data.x)-1 
     198        self._last_unsmeared_bin  = len(self.x)-1 
    199199         
    200200        if self.smearer!=None: 
    201201            self._first_unsmeared_bin, self._last_unsmeared_bin = self.smearer.get_bin_range(self.qmin, self.qmax) 
    202             self._qmin_unsmeared = self.data.x[self._first_unsmeared_bin] 
    203             self._qmax_unsmeared = self.data.x[self._last_unsmeared_bin] 
     202            self._qmin_unsmeared = self.x[self._first_unsmeared_bin] 
     203            self._qmax_unsmeared = self.x[self._last_unsmeared_bin] 
    204204             
    205205        # Identify the bin range for the unsmeared and smeared spaces 
    … …  
    249249     
    250250     
    251 class FitData2D(object): 
     251class FitData2D(Data2D): 
    252252    """ Wrapper class  for SANS data """ 
    253     def __init__(self,sans_data2d): 
     253    def __init__(self,sans_data2d ,data=None, err_data=None,): 
     254        Data2D.__init__(self, data= data, err_data= err_data) 
    254255        """ 
    255256            Data can be initital with a data (sans plottable) 
    256257            or with vectors. 
    257258        """ 
    258         self.data=sans_data2d 
    259         self.image = sans_data2d.data 
    260         self.err_image = sans_data2d.err_data 
     259        self.x_bins_array = [] 
     260        self.y_bins_array = [] 
     261        self.res_err_image=[] 
     262        self.index_model=[] 
     263        self.qmin= None 
     264        self.qmax= None 
     265        self.set_data(sans_data2d ) 
     266         
     267         
     268    def set_data(self, sans_data2d ): 
     269        """ 
     270            Determine the correct x_bin and y_bin to fit 
     271        """ 
     272        self.err_data = sans_data2d.err_data 
    261273        self.x_bins_array= numpy.reshape(sans_data2d.x_bins, 
    262274                                         [1,len(sans_data2d.x_bins)]) 
    … …  
    264276                                          [len(sans_data2d.y_bins),1]) 
    265277         
    266         x = max(self.data.xmin, self.data.xmax) 
    267         y = max(self.data.ymin, self.data.ymax) 
     278        x_max = max(self.data.xmin, self.data.xmax) 
     279        y_max = max(self.data.ymin, self.data.ymax) 
    268280         
    269281        ## fitting range 
    270282        self.qmin = 1e-16 
    271         self.qmax = math.sqrt(x*x +y*y) 
     283        self.qmax = math.sqrt(x_max*x_max +y_max*y_max) 
    272284        ## new error image for fitting purpose 
    273285        if self.err_image== None or self.err_image ==[]: 
    … …  
    467479        """ 
    468480        if data.__class__.__name__=='Data2D': 
    469             fitdata=FitData2D(data) 
    470         else: 
    471             fitdata=FitData1D(data, smearer) 
     481            fitdata=FitData2D(sans_data2d=data, data=data.data, err_data= data.err_data) 
     482        else: 
     483            fitdata=FitData1D(x=data.x, y=data.y , dx= data.dx,dy=data.dy,smearer=smearer) 
    472484        
    473485        fitdata.setFitRange(qmin=qmin,qmax=qmax) 

  • park_integration/test/small_test.py

    r1ea3488 r1e3169c  
    33""" 
    44import unittest 
    5 from danse.common.plottools.plottables import Theory1D 
    6 from danse.common.plottools.plottables import Data1D 
    7 from sans.fit.AbstractFitEngine import Model,FitData1D 
     5from sans.fit.AbstractFitEngine import Model 
    86import math 
    97from sans.fit.Fitting import Fit 
    … …  
    1311    """ test fitting """ 
    1412    def test_park(self): 
    15         """ Simple cylinder model fit (park)  """ 
     13        """ Simple cylinder model fit (scipy)  """ 
    1614         
    17         out=Loader().load("cyl_400_20.txt") 
    18         data1 = Data1D(x=out.x, y=out.y, dx=out.dx, dy=out.y) 
    19          
     15        out= Loader().load("cyl_400_20.txt") 
     16        
    2017        fitter = Fit('scipy') 
    2118        # Receives the type of model for the fitting 
    … …  
    2320        model1  = CylinderModel() 
    2421        model1.setParam('contrast', 1) 
    25         data1.smearer = None 
    26         data = FitData1D(data1) 
    2722        model = Model(model1) 
    2823         
    2924        pars1 =['length','radius','scale'] 
    30         fitter.set_data(data,1) 
     25        fitter.set_data(out,1) 
    3126        model.set( scale=1e-10 ) 
    3227        fitter.set_model(model,1,pars1) 

  • park_integration/test/test_fit_cylinder.py

    reb575b0 r1e3169c  
    55import unittest 
    66 
    7 from danse.common.plottools.plottables import Data1D,Theory1D 
    8 from sans.fit.AbstractFitEngine import Model,FitData1D 
     7from sans.fit.AbstractFitEngine import Model 
    98import math 
    109from sans.fit.Fitting import Fit 
    … …  
    1514    def setUp(self): 
    1615        """ initialize data""" 
    17         out = Loader().load("cyl_400_20.txt") 
    18         #Create data that fitting engine understands 
    19         data1 = Data1D(x=out.x, y=out.y, dx=out.dx, dy=out.dy) 
    20         self.data = FitData1D(data1) 
     16        self.data = Loader().load("cyl_400_20.txt") 
    2117        # Create model that fitting engine understands 
    2218        from sans.models.CylinderModel import CylinderModel 
    … …  
    7773        """ initialize data""" 
    7874         
    79         out=Loader().load("cyl_400_20.txt") 
    80         data1 = Data1D(x=out.x, y=out.y, dx=out.dx, dy=out.dy) 
    81         self.data1 = FitData1D(data1) 
    82          
    83         out2=Loader().load("cyl_400_40.txt") 
    84         data2 = Data1D(x=out2.x, y=out2.y, dx=out2.dx, dy=out2.dy) 
    85         self.data2 = FitData1D(data2) 
     75        self.data1=Loader().load("cyl_400_20.txt") 
     76        self.data2=Loader().load("cyl_400_40.txt") 
    8677     
    8778        # Receives the type of model for the fitting 

  • park_integration/test/test_fit_line.py

    r2eaaf1a r1e3169c  
    55import unittest 
    66 
    7 from danse.common.plottools.plottables import Data1D,Theory1D 
    8 from sans.fit.AbstractFitEngine import Model,FitData1D 
     7from sans.fit.AbstractFitEngine import Model 
    98import math 
    109class testFitModule(unittest.TestCase): 
    … …  
    1514        #load data 
    1615        from DataLoader.loader import Loader 
    17         data1 = Loader().load("testdata_line.txt") 
     16        data = Loader().load("testdata_line.txt") 
    1817        #Importing the Fit module 
    1918        from sans.fit.Fitting import Fit 
    … …  
    2322        model1  = LineModel() 
    2423        model1.name = "M1" 
    25         #data = Data(sans_data=data1 ) 
    26         #data1.smearer=None 
    27         data = FitData1D(data1 ) 
    2824        model = Model(model1) 
    2925        #fit with scipy test 
    … …  
    7167        from DataLoader.loader import Loader 
    7268        l = Loader() 
    73         out=l.load("testdata_line.txt") 
    74         data11 = Data1D(x=out.x, y=out.y, dx=out.dx, dy=out.y) 
    75         out=l.load("testdata_line1.txt") 
    76         data22 = Data1D(x=out.x, y=out.y, dx=out.dx, dy=out.y) 
     69        data1=l.load("testdata_line.txt") 
     70       
     71        data2=l.load("testdata_line1.txt") 
     72      
    7773        #Importing the Fit module 
    7874        from sans.fit.Fitting import Fit 
    … …  
    8480        model22  = LineModel() 
    8581        model11.name= "M2" 
    86         data11.smearer=None 
    87         data22.smearer=None 
    88         data1 = FitData1D(data11 ) 
    89         data2 = FitData1D(data22 ) 
    90          
     82       
    9183        model1 = Model(model11) 
    9284        model2 = Model(model22) 
    … …  
    124116        self.assertTrue( math.fabs(result2.pvec[0]-4)/3 <= result2.stderr[0] ) 
    125117        self.assertTrue( math.fabs(result2.pvec[1]-2.5)/3 <= result2.stderr[1] ) 
    126         self.assertTrue( result2.fitness/len(data2.x) < 2) 
     118        self.assertTrue( result2.fitness/(len(data1.x)+len(data2.x)) < 2) 
    127119         
    128120         
    … …  
    132124        from DataLoader.loader import Loader 
    133125        l = Loader() 
    134         out=l.load("testdata_line.txt") 
    135         data11 = Data1D(x=out.x, y=out.y, dx=out.dx, dy=out.y) 
    136         out=l.load("testdata_cst.txt") 
    137         data22 = Data1D(x=out.x, y=out.y, dx=out.dx, dy=out.y) 
    138         #Importing the Fit module 
    139         from sans.fit.Fitting import Fit 
    140         fitter = Fit('park') 
    141         # Receives the type of model for the fitting 
    142         from sans.models.LineModel import LineModel 
    143         from sans.models.Constant import Constant 
     126        data1= l.load("testdata_line.txt") 
     127        data2= l.load("testdata_cst.txt") 
     128        
     129        # Receives the type of model for the fitting 
     130        from sans.models.LineModel import LineModel 
    144131        model11  = LineModel() 
    145132        model11.name= "line" 
    … …  
    147134        model11.setParam("B",1.0) 
    148135         
     136        from sans.models.Constant import Constant 
    149137        model22  = Constant() 
    150138        model22.name= "cst" 
    151139        model22.setParam("value", 1.0) 
    152140         
    153         # Constrain the constant value to be equal to parameter B (the real value is 2.5) 
    154       
    155         data11.smearer= None 
    156         data22.smearer= None 
    157         data1 = FitData1D(data11 ) 
    158         data2 = FitData1D(data22 ) 
    159141        model1 = Model(model11) 
    160142        model2 = Model(model22) 
    161143        model1.set(A=4) 
    162144        model1.set(B=3) 
     145        # Constraint the constant value to be equal to parameter B (the real value is 2.5) 
    163146        model2.set(value='line.B') 
    164147        #fit with scipy test 
    … …  
    166149        pars2= ['value'] 
    167150         
     151        #Importing the Fit module 
     152        from sans.fit.Fitting import Fit 
     153        fitter = Fit('park') 
    168154        fitter.set_data(data1,1) 
    169155        fitter.set_model(model1,1,pars1) 
    … …  
    177163        self.assertTrue( math.fabs(result2.pvec[0]-4.0)/3. <= result2.stderr[0])  
    178164        self.assertTrue( math.fabs(result2.pvec[1]-2.5)/3. <= result2.stderr[1]) 
    179         self.assertTrue( result2.fitness/len(data2.x) < 2) 
     165        self.assertTrue( result2.fitness/(len(data1.x)+len(data2.x)) < 2) 
    180166         
    181167         
    … …  
    185171        from DataLoader.loader import Loader 
    186172        l = Loader() 
    187         out=l.load("testdata_line.txt") 
    188         data11 = Data1D(x=out.x, y=out.y, dx=out.dx, dy=out.y) 
    189         out=l.load("testdata_line1.txt") 
    190         data22 = Data1D(x=out.x, y=out.y, dx=out.dx, dy=out.y) 
    191         #Importing the Fit module 
    192         from sans.fit.Fitting import Fit 
    193         fitter = Fit('scipy') 
     173        data1 = l.load("testdata_line.txt") 
     174        data2 = l.load("testdata_line1.txt") 
     175         
     176        
    194177        # Receives the type of model for the fitting 
    195178        from sans.models.LineModel import LineModel 
    … …  
    199182        model1.setParam("B",1.0) 
    200183        model = Model(model1) 
    201          
    202         data11.smearer= None 
    203         data22.smearer= None 
    204         data1 = FitData1D(data11 ) 
    205         data2 = FitData1D(data22 ) 
    206          
    207         #fit with scipy test 
    208         pars1= ['A','B'] 
     184       
     185        #fit with scipy test 
     186        pars1= ['A','B'] 
     187        #Importing the Fit module 
     188        from sans.fit.Fitting import Fit 
     189        fitter = Fit('scipy') 
    209190        fitter.set_data(data1,1,qmin=0, qmax=7) 
    210191        fitter.set_model(model,1,pars1) 
    … …  
    236217        self.assertAlmostEquals( result1.stderr[0],result2.stderr[0] ) 
    237218        self.assertAlmostEquals( result1.stderr[1],result2.stderr[1] ) 
    238         #self.assertAlmostEquals( result1.fitness,result2.fitness ) 
    239         self.assertTrue( result1.fitness/len(data1.x) < 2 ) 
    240         self.assertTrue( result2.fitness/len(data2.x) < 2 ) 
     219        self.assertTrue( result2.fitness/(len(data2.x)+len(data1.x)) < 2 ) 
    241220         
    242221         
Note: See TracChangeset for help on using the changeset viewer.