Changeset 2b440504 in sasview for sansmodels/src/sans/models


Ignore:
Timestamp:
Sep 30, 2011 10:01:06 AM (13 years ago)
Author:
Jae Cho <jhjcho@…>
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:
62f851f
Parents:
29a4024
Message:

reveting before changes for pickling

File:
1 edited

Legend:

Unmodified
Added
Removed
  • sansmodels/src/sans/models/qsmearing.py

    r946b452 r2b440504  
    1111import logging 
    1212import sys 
    13 import copy 
    14 import sans_extension.smearer as smearer  
     13import sans.models.sans_extension.smearer as smearer  
    1514from sans.models.smearing_2d import Smearer2D 
    1615 
     
    9594        self._smearer = None 
    9695        self.model = None 
    97      
     96         
     97    def __deepcopy__(self, memo={}): 
     98        """ 
     99        Return a valid copy of self. 
     100        Avoid copying the _smearer C object and force a matrix recompute 
     101        when the copy is used.   
     102        """ 
     103        result = _BaseSmearer() 
     104        result.nbins = self.nbins 
     105        return result 
     106 
    98107    def _compute_matrix(self): 
    99108        """ 
     
    116125        if q_max == None: 
    117126            q_max = self.max 
     127 
    118128        _qmin_unsmeared, _qmax_unsmeared = self.get_unsmeared_range(q_min, 
    119129                                                                     q_max) 
     
    162172        iq_in_temp = iq_in 
    163173        if self.model != None: 
    164             temp_first, temp_last = self._get_extrapolated_bin(first_bin,  
    165                                                               last_bin) 
     174            temp_first, temp_last = self._get_extrapolated_bin( \ 
     175                                                        first_bin, last_bin) 
    166176            if self.nbins_low > 0: 
    167                 iq_in_low = self.model.evalDistribution( 
     177                iq_in_low = self.model.evalDistribution( \ 
    168178                                    numpy.fabs(self.qvalues[0:self.nbins_low])) 
    169             iq_in_high = self.model.evalDistribution( 
     179            iq_in_high = self.model.evalDistribution( \ 
    170180                                            self.qvalues[(len(self.qvalues) - \ 
    171181                                            self.nbins_high - 1):]) 
     
    181191            temp_first = first_bin 
    182192            temp_last = last_bin 
     193            #iq_in_temp = iq_in 
     194 
    183195        # Sanity check 
    184196        if len(iq_in_temp) != self.nbins: 
     
    288300        self.qvalues  = None 
    289301         
    290     
    291302    def _initialize_smearer(self): 
    292303        """ 
     
    332343        self.nbins_low = 0 
    333344        self.nbins_high = 0 
    334         self.data = data1D 
    335345        self.model = model 
    336346        if data1D.dxw is not None and len(data1D.dxw) == len(data1D.x): 
     
    377387        self.qvalues = data1d_x 
    378388         
    379     def __deepcopy__(self, memo={}): 
    380         """ 
    381         Return a valid copy of self. 
    382         Avoid copying the _smearer C object and force a matrix recompute 
    383         when the copy is used.   
    384         """ 
    385         result = SlitSmearer(self.data, self.model) 
    386         result.width = self.width 
    387         result.height = self.height 
    388         result.nbins_low = self.nbins_low 
    389         result.nbins_high = self.nbins_high 
    390         result.data = copy.deepcopy(self.data) 
    391         result.model = copy.deepcopy(self.model) 
    392         result.nbins = self.nbins 
    393         result.nbins_low = self.nbins_low 
    394         result.nbins_high = self.nbins_high 
    395         result._weights = self._weights 
    396         ## Internal flag to keep track of C++ smearer initialization 
    397         result._init_complete = self._init_complete 
    398         import sans_extension.smearer as smearer  
    399         result._smearer =  smearer.new_slit_smearer_with_q(self.width,  
    400                                                     self.height, self.qvalues) 
    401         return result 
    402  
    403          
    404     def __setstate__(self, state): 
    405         """ 
    406         Restore the state of the object by reconstruction the (smearer) object 
    407         """ 
    408         self.__dict__, self.model,  self.data = state 
    409         import sans_extension.smearer as smearer  
    410         self._smearer = smearer.new_slit_smearer_with_q(self.width,  
    411                                                     self.height, self.qvalues) 
    412         self.__dict__['_smearer'] = self._smearer 
    413          
    414     def __reduce_ex__(self, proto): 
    415         """ 
    416         Overwrite the __reduce_ex__to avoid pickle PyCobject(smearer) 
    417         """ 
    418         model = copy.deepcopy(self.model) 
    419         data = copy.deepcopy(self.data) 
    420         dict = {} 
    421         for k , v in self.__dict__.iteritems(): 
    422             if k != "_smearer": 
    423                 dict[k] = v 
    424         state = (dict, model, data) 
    425         return (SlitSmearer, (data, model), state, None, None) 
    426          
    427389 
    428390class _QSmearer(_BaseSmearer): 
     
    452414        self._weights = None 
    453415        self.qvalues  = None 
    454        
    455416         
    456417    def _initialize_smearer(self): 
     
    496457        super(QSmearer, self).__init__() 
    497458        data1d_x = [] 
    498         self.data =  copy.deepcopy(data1D) 
    499459        self.nbins_low = 0 
    500460        self.nbins_high = 0 
    501         self.model = copy.deepcopy(model) 
     461        self.model = model 
    502462        ## Resolution 
    503463        #self.width = numpy.zeros(len(data1D.x)) 
     
    510470            self.nbins_low, self.nbins_high, self.width, data1d_x = \ 
    511471                                get_qextrapolate(self.width, data1D.x) 
     472 
    512473        ## Number of Q bins 
    513474        self.nbins = len(data1d_x) 
     
    518479        ## Q-values 
    519480        self.qvalues = data1d_x 
    520         
    521          
    522     def __deepcopy__(self, memo={}): 
    523         """ 
    524         Return a valid copy of self. 
    525         Avoid copying the _smearer C object and force a matrix recompute 
    526         when the copy is used.   
    527         """ 
    528         result = QSmearer(self.data, self.model) 
    529         result.nbins = self.nbins 
    530         result.min = self.min 
    531         result.max = self.max 
    532         result.nbins_low = self.nbins_low 
    533         result.nbins_high = self.nbins_high 
    534         result.width = copy.deepcopy(self.width) 
    535         result._weights = copy.deepcopy(self._weights) 
    536         result.qvalues = copy.deepcopy(self.qvalues) 
    537         ## Internal flag to keep track of C++ smearer initialization 
    538         result._init_complete = self._init_complete 
    539         import sans_extension.smearer as smearer  
    540         result._smearer =  smearer.new_q_smearer_with_q(numpy.asarray(result.width), 
    541                                                       result.qvalues) 
    542         return result 
    543  
    544          
    545     def __setstate__(self, state): 
    546         """ 
    547         Restore the state of the object by reconstruction the (smearer) object 
    548         """ 
    549         self.__dict__, self.model,  self.data = state 
    550         import sans_extension.smearer as smearer  
    551         self._smearer =  smearer.new_q_smearer_with_q(numpy.asarray(self.width), 
    552                                                       self.qvalues) 
    553         self.__dict__['_smearer'] = self._smearer 
    554   
    555     def __reduce_ex__(self, proto): 
    556         """ 
    557         Overwrite the __reduce_ex__to avoid pickle PyCobject(smearer) 
    558         """ 
    559         model = copy.deepcopy(self.model) 
    560         data = copy.deepcopy(self.data) 
    561         dict = {} 
    562         for k , v in self.__dict__.iteritems(): 
    563             if k != "_smearer": 
    564                 dict[k] = v 
    565         state = (dict, model, data) 
    566         return (QSmearer, (data, model), state, None, None) 
    567      
    568481 
    569482         
Note: See TracChangeset for help on using the changeset viewer.