Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r251ef684 r959eb01  
    1414################################################################################ 
    1515import copy 
    16  
    17 from sas.sascalc.fit.qsmearing import smear_selection 
    18  
    19 class FitProblem(object): 
     16from sas.sascalc.data_util.qsmearing import smear_selection 
     17 
     18class FitProblemComponent(object): 
    2019    """ 
    21     Define the relationship between data and model, including range, weights, 
    22     etc. 
     20    Inferface containing information to store data, model, range of data, etc... 
     21    and retreive this information. This is an inferface 
     22    for a fitProblem i.e relationship between data and model. 
    2323    """ 
    24     def __init__(self): 
    25         """ 
    26         contains information about data and model to fit 
    27         """ 
    28         ## data used for fitting 
    29         self.fit_data = None 
    30         self.theory_data = None 
    31         self.residuals = None 
    32         # original data: should not be modified 
    33         self.original_data = None 
    34         ## the current model 
    35         self.model = None 
    36         ## if 1 this fit problem will be selected to fit , if 0 
    37         ## it will not be selected for fit 
    38         self.schedule = 0 
    39         ##list containing parameter name and value 
    40         self.list_param = [] 
    41         self.list_param2fit = [] 
    42         ## smear object to smear or not data1D 
    43         self.smearer_computed = False 
    44         self.smearer_enable = False 
    45         self.smearer_computer_value = None 
    46         ## fitting range 
    47         self.qmin = None 
    48         self.qmax = None 
    49         # fit weight 
    50         self.weight = None 
    51         self.result = None 
    52         self.fit_tab_caption = None 
    53         self.name_per_page = None 
    54  
    5524    def enable_smearing(self, flag=False): 
    5625        """ 
    … …  
    5827            flag is 0 ingore smear value. 
    5928        """ 
    60         self.smearer_enable = flag 
    61  
    62     def set_smearer(self, smearer): 
    63         """ 
    64         save reference of  smear object on fitdata 
    65  
    66         :param smear: smear object from DataLoader 
    67  
    68         """ 
    69         self.smearer_computer_value = smearer 
    7029 
    7130    def get_smearer(self): 
    … …  
    7332        return smear object 
    7433        """ 
    75         if not self.smearer_enable: 
    76             return None 
    77         if not self.smearer_computed: 
    78             #smeari_selection should be call only once per fitproblem 
    79             self.smearer_computer_value = smear_selection(self.fit_data, 
    80                                                           self.model) 
    81             self.smearer_computed = True 
    82         return self.smearer_computer_value 
    83  
    8434    def save_model_name(self, name): 
    8535        """ 
    8636        """ 
    87         self.name_per_page = name 
    8837 
    8938    def get_name(self): 
    9039        """ 
    9140        """ 
    92         return self.name_per_page 
    9341 
    9442    def set_model(self, model): 
    … …  
    9846        :param name: name created for model 
    9947        """ 
    100         self.model = model 
    101         self.smearer_computer_value = smear_selection(self.fit_data, 
    102                                                       self.model) 
    103         self.smearer_computed = True 
    10448 
    10549    def get_model(self): 
    … …  
    10751        :return: saved model 
    10852        """ 
    109         return self.model 
    11053 
    11154    def set_residuals(self, residuals): 
    … …  
    11457        :param data: data selected 
    11558        """ 
    116         self.residuals = residuals 
    11759 
    11860    def get_residuals(self): 
    … …  
    12062        :return: residuals 
    12163        """ 
    122         return self.residuals 
    12364 
    12465    def set_theory_data(self, data): 
    12566        """ 
    12667        save a copy of the data select to fit 
    127  
    12868        :param data: data selected 
    129  
    130         """ 
    131         self.theory_data = copy.deepcopy(data) 
     69        """ 
    13270 
    13371    def get_theory_data(self): 
    13472        """ 
    135         :return: theory generated with the current model and data of this class 
    136         """ 
    137         return self.theory_data 
     73        :return: list of data dList 
     74        """ 
    13875 
    13976    def set_fit_data(self, data): 
    14077        """ 
    141         Store data associated with this class 
     78        Store of list of data and create  by create new fitproblem of each data 
     79        id, if there was existing information about model, this information 
     80        get copy to the new fitproblem 
    14281        :param data: list of data selected 
    14382        """ 
    144         self.original_data = None 
    145         self.fit_data = None 
    146         # original data: should not be modified 
    147         self.original_data = data 
    148         # fit data: used for fit and can be modified for convenience 
    149         self.fit_data = copy.deepcopy(data) 
    150         self.smearer_computer_value = smear_selection(self.fit_data, self.model) 
    151         self.smearer_computed = True 
    152         self.result = None 
    15383 
    15484    def get_fit_data(self): 
    15585        """ 
    156         :return: data associate with this class 
    157         """ 
    158         return self.fit_data 
    159  
    160     def get_origin_data(self): 
    161         """ 
    162         """ 
    163         return self.original_data 
    164  
    165     def set_weight(self, is2d, flag=None): 
    166         """ 
    167         Received flag and compute error on data. 
    168         :param flag: flag to transform error of data. 
    169         :param is2d: flag to distinguish 1D to 2D Data 
    170         """ 
    171         from sas.sasgui.perspectives.fitting.utils import get_weight 
    172         # send original data for weighting 
    173         self.weight = get_weight(data=self.original_data, is2d=is2d, flag=flag) 
    174         if is2d: 
    175             self.fit_data.err_data = self.weight 
    176         else: 
    177             self.fit_data.dy = self.weight 
    178  
    179     def get_weight(self): 
    180         """ 
    181         returns weight array 
    182         """ 
    183         return self.weight 
    184  
    185     def set_param2fit(self, list): 
    186         """ 
    187         Store param names to fit (checked) 
    188         :param list: list of the param names 
    189         """ 
    190         self.list_param2fit = list 
    191  
    192     def get_param2fit(self): 
    193         """ 
    194         return the list param names to fit 
    195         """ 
    196         return self.list_param2fit 
     86        """ 
    19787 
    19888    def set_model_param(self, name, value=None): 
    … …  
    20292        :param value: value of that parameter 
    20393        """ 
    204         self.list_param.append([name, value]) 
     94 
     95    def set_param2fit(self, list): 
     96        """ 
     97        Store param names to fit (checked) 
     98        :param list: list of the param names 
     99        """ 
     100 
     101    def get_param2fit(self): 
     102        """ 
     103        return the list param names to fit 
     104        """ 
    205105 
    206106    def get_model_param(self): 
    … …  
    208108        return list of couple of parameter name and value 
    209109        """ 
    210         return self.list_param 
    211110 
    212111    def schedule_tofit(self, schedule=0): 
    … …  
    214113        set schedule to true to decide if this fit  must be performed 
    215114        """ 
    216         self.schedule = schedule 
    217115 
    218116    def get_scheduled(self): 
    … …  
    220118        return true or false if a problem as being schedule for fitting 
    221119        """ 
    222         return self.schedule 
    223120 
    224121    def set_range(self, qmin=None, qmax=None): 
    225122        """ 
    226123        set fitting range 
    227         :param qmin: minimum value to consider for the fit range 
    228         :param qmax: maximum value to consider for the fit range 
    229         """ 
    230         self.qmin = qmin 
    231         self.qmax = qmax 
     124        """ 
    232125 
    233126    def get_range(self): 
    234127        """ 
    235128        :return: fitting range 
    236  
    237         """ 
    238         return self.qmin, self.qmax 
     129        """ 
     130 
     131    def set_weight(self, flag=None): 
     132        """ 
     133        set fitting range 
     134        """ 
     135 
     136    def get_weight(self): 
     137        """ 
     138        get fitting weight 
     139        """ 
    239140 
    240141    def clear_model_param(self): 
    … …  
    242143        clear constraint info 
    243144        """ 
    244         self.list_param = [] 
    245145 
    246146    def set_fit_tab_caption(self, caption): 
    247147        """ 
    248         """ 
    249         self.fit_tab_caption = str(caption) 
     148        store the caption of the page associated with object 
     149        """ 
    250150 
    251151    def get_fit_tab_caption(self): 
    252152        """ 
    253         """ 
    254         return self.fit_tab_caption 
     153        Return the caption of the page associated with object 
     154        """ 
    255155 
    256156    def set_graph_id(self, id): 
    … …  
    258158        Set graph id (from data_group_id at the time the graph produced) 
    259159        """ 
    260         self.graph_id = id 
    261160 
    262161    def get_graph_id(self): 
    … …  
    264163        Get graph_id 
    265164        """ 
    266         return self.graph_id 
    267165 
    268166    def set_result(self, result): 
    269167        """ 
    270168        """ 
    271         self.result = result 
    272169 
    273170    def get_result(self): 
    … …  
    275172        get result 
    276173        """ 
    277         return self.result 
    278  
    279  
    280 class FitProblemDictionary(dict): 
     174 
     175 
     176class FitProblemDictionary(FitProblemComponent, dict): 
    281177    """ 
    282178    This module implements a dictionary of fitproblem objects 
    283179    """ 
    284180    def __init__(self): 
     181        FitProblemComponent.__init__(self) 
    285182        dict.__init__(self) 
    286183        ## the current model 
    … …  
    309206        self._smear_on = flag 
    310207        if fid is None: 
    311             for value in self.values(): 
     208            for value in self.itervalues(): 
    312209                value.enable_smearing(flag) 
    313         elif fid in self: 
    314             self[fid].enable_smearing(flag) 
     210        else: 
     211            if fid in self.iterkeys(): 
     212                self[fid].enable_smearing(flag) 
    315213 
    316214    def set_smearer(self, smearer, fid=None): 
    … …  
    320218        """ 
    321219        if fid is None: 
    322             for value in self.values(): 
     220            for value in self.itervalues(): 
    323221                value.set_smearer(smearer) 
    324         elif fid in self: 
    325             self[fid].set_smearer(smearer) 
     222        else: 
     223            if fid in self.iterkeys(): 
     224                self[fid].set_smearer(smearer) 
    326225 
    327226    def get_smearer(self, fid=None): 
    … …  
    329228        return smear object 
    330229        """ 
    331         if fid in self: 
     230        if fid in self.iterkeys(): 
    332231            return self[fid].get_smearer() 
    333232 
    … …  
    336235        """ 
    337236        if fid is None: 
    338             for value in self.values(): 
     237            for value in self.itervalues(): 
    339238                value.save_model_name(name) 
    340         elif fid in self: 
    341             self[fid].save_model_name(name) 
     239        else: 
     240            if fid in self.iterkeys(): 
     241                self[fid].save_model_name(name) 
    342242 
    343243    def get_name(self, fid=None): 
    … …  
    346246        result = [] 
    347247        if fid is None: 
    348             for value in self.values(): 
     248            for value in self.itervalues(): 
    349249                result.append(value.get_name()) 
    350         elif fid in self: 
    351             result.append(self[fid].get_name()) 
     250        else: 
     251            if fid in self.iterkeys(): 
     252                result.append(self[fid].get_name()) 
    352253        return result 
    353254 
    … …  
    360261        self.model = model 
    361262        if fid is None: 
    362             for value in self.values(): 
     263            for value in self.itervalues(): 
    363264                value.set_model(self.model) 
    364         elif fid in self: 
    365             self[fid].set_model(self.model) 
     265        else: 
     266            if fid in self.iterkeys(): 
     267                self[fid].set_model(self.model) 
    366268 
    367269    def get_model(self, fid): 
    … …  
    369271        :return: saved model 
    370272        """ 
    371         if fid in self: 
     273        if fid in self.iterkeys(): 
    372274            return self[fid].get_model() 
    373275 
    … …  
    389291        :param data: data selected 
    390292        """ 
    391         if fid in self: 
     293        if fid in self.iterkeys(): 
    392294            self[fid].set_residuals(residuals) 
    393295 
    … …  
    396298        :return: residuals 
    397299        """ 
    398         if fid in self: 
     300        if fid in self.iterkeys(): 
    399301            return self[fid].get_residuals() 
    400302 
    … …  
    404306        :param data: data selected 
    405307        """ 
    406         if fid in self: 
     308        if fid in self.iterkeys(): 
    407309            self[fid].set_theory_data(data) 
    408310 
    … …  
    411313        :return: list of data dList 
    412314        """ 
    413         if fid in self: 
     315        if fid in self.iterkeys(): 
    414316            return self[fid].get_theory_data() 
    415317 
    … …  
    420322        :note: only data changes in the fit problem 
    421323        """ 
    422         if data.id not in self: 
     324        if data.id not in self.iterkeys(): 
    423325            self[data.id] = FitProblem() 
    424326        self[data.id].set_fit_data(data) 
    … …  
    434336            data = [] 
    435337        for d in data: 
    436             if d is not None: 
    437                 if d.id not in self: 
     338            if (d is not None): 
     339                if (d.id not in self.iterkeys()): 
    438340                    self[d.id] = FitProblem() 
    439341                self[d.id].set_fit_data(d) 
    … …  
    446348        :param fid: key representing a fitproblem, usually extract from data id 
    447349        """ 
    448         if fid in self: 
     350        if fid in self.iterkeys(): 
    449351            return self[fid].get_fit_data() 
    450352 
    … …  
    456358        """ 
    457359        if fid is None: 
    458             for value in self.values(): 
     360            for value in self.itervalues(): 
    459361                value.set_model_param(name, value) 
    460         elif fid in self: 
    461             self[fid].set_model_param(name, value) 
     362        else: 
     363            if fid in self.iterkeys(): 
     364                self[fid].set_model_param(name, value) 
    462365 
    463366    def get_model_param(self, fid): 
    … …  
    465368        return list of couple of parameter name and value 
    466369        """ 
    467         if fid in self: 
     370        if fid in self.iterkeys(): 
    468371            return self[fid].get_model_param() 
    469372 
    … …  
    486389        """ 
    487390        self.scheduled = schedule 
    488         for value in self.values(): 
     391        for value in self.itervalues(): 
    489392            value.schedule_tofit(schedule) 
    490393 
    … …  
    502405        self.qmax = qmax 
    503406        if fid is None: 
    504             for value in self.values(): 
     407            for value in self.itervalues(): 
    505408                value.set_range(self.qmin, self.qmax) 
    506         elif fid in self: 
    507             self[fid].value.set_range(self.qmin, self.qmax) 
     409        else: 
     410            if fid in self.iterkeys(): 
     411                self[fid].value.set_range(self.qmin, self.qmax) 
    508412 
    509413    def get_range(self, fid): 
    … …  
    511415        :return: fitting range 
    512416        """ 
    513         if fid in self: 
     417        if fid in self.iterkeys(): 
    514418            return self[fid].get_range() 
    515419 
    … …  
    519423        """ 
    520424        if fid is None: 
    521             for value in self.values(): 
     425            for value in self.itervalues(): 
    522426                value.set_weight(flag=flag, is2d=is2d) 
    523         elif fid in self: 
    524             self[fid].set_weight(flag=flag, is2d=is2d) 
     427        else: 
     428            if fid in self.iterkeys(): 
     429                self[fid].set_weight(flag=flag, is2d=is2d) 
    525430 
    526431    def get_weight(self, fid=None): 
    … …  
    528433        return fit weight 
    529434        """ 
    530         if fid in self: 
     435        if fid in self.iterkeys(): 
    531436            return self[fid].get_weight() 
    532437 
    … …  
    536441        """ 
    537442        if fid is None: 
    538             for value in self.values(): 
     443            for value in self.itervalues(): 
    539444                value.clear_model_param() 
    540         elif fid in self: 
    541             self[fid].clear_model_param() 
     445        else: 
     446            if fid in self.iterkeys(): 
     447                self[fid].clear_model_param() 
    542448 
    543449    def get_fit_problem(self): 
    … …  
    545451        return fitproblem contained in this dictionary 
    546452        """ 
    547         return self.values() 
     453        return self.itervalues() 
    548454 
    549455    def set_result(self, result, fid): 
    550456        """ 
    551457        """ 
    552         if fid in self: 
     458        if fid in self.iterkeys(): 
    553459            self[fid].set_result(result) 
    554460 
    … …  
    564470        get result 
    565471        """ 
    566         if fid in self: 
     472        if fid in self.iterkeys(): 
    567473            return self[fid].get_result() 
    568474 
    … …  
    584490        """ 
    585491        return self.graph_id 
     492 
     493 
     494class FitProblem(FitProblemComponent): 
     495    """ 
     496    FitProblem class allows to link a model with the new name created in _on_model, 
     497    a name theory created with that model  and the data fitted with the model. 
     498    FitProblem is mostly used  as value of the dictionary by fitting module. 
     499    """ 
     500    def __init__(self): 
     501        FitProblemComponent.__init__(self) 
     502        """ 
     503        contains information about data and model to fit 
     504        """ 
     505        ## data used for fitting 
     506        self.fit_data = None 
     507        self.theory_data = None 
     508        self.residuals = None 
     509        # original data: should not be modified 
     510        self.original_data = None 
     511        ## the current model 
     512        self.model = None 
     513        ## if 1 this fit problem will be selected to fit , if 0 
     514        ## it will not be selected for fit 
     515        self.schedule = 0 
     516        ##list containing parameter name and value 
     517        self.list_param = [] 
     518        ## smear object to smear or not data1D 
     519        self.smearer_computed = False 
     520        self.smearer_enable = False 
     521        self.smearer_computer_value = None 
     522        ## fitting range 
     523        self.qmin = None 
     524        self.qmax = None 
     525        # fit weight 
     526        self.weight = None 
     527        self.result = None 
     528 
     529    def enable_smearing(self, flag=False): 
     530        """ 
     531        :param flag: bool.When flag is 1 get the computer smear value. When 
     532            flag is 0 ingore smear value. 
     533        """ 
     534        self.smearer_enable = flag 
     535 
     536    def set_smearer(self, smearer): 
     537        """ 
     538        save reference of  smear object on fitdata 
     539 
     540        :param smear: smear object from DataLoader 
     541 
     542        """ 
     543        self.smearer_computer_value = smearer 
     544 
     545    def get_smearer(self): 
     546        """ 
     547        return smear object 
     548        """ 
     549        if not self.smearer_enable: 
     550            return None 
     551        if not self.smearer_computed: 
     552            #smeari_selection should be call only once per fitproblem 
     553            self.smearer_computer_value = smear_selection(self.fit_data, 
     554                                                           self.model) 
     555            self.smearer_computed = True 
     556        return self.smearer_computer_value 
     557 
     558    def save_model_name(self, name): 
     559        """ 
     560        """ 
     561        self.name_per_page = name 
     562 
     563    def get_name(self): 
     564        """ 
     565        """ 
     566        return self.name_per_page 
     567 
     568    def set_model(self, model): 
     569        """ 
     570        associates each model with its new created name 
     571        :param model: model selected 
     572        :param name: name created for model 
     573        """ 
     574        self.model = model 
     575        self.smearer_computer_value = smear_selection(self.fit_data, 
     576                                                           self.model) 
     577        self.smearer_computed = True 
     578 
     579    def get_model(self): 
     580        """ 
     581        :return: saved model 
     582        """ 
     583        return self.model 
     584 
     585    def set_residuals(self, residuals): 
     586        """ 
     587        save a copy of residual 
     588        :param data: data selected 
     589        """ 
     590        self.residuals = residuals 
     591 
     592    def get_residuals(self): 
     593        """ 
     594        :return: residuals 
     595        """ 
     596        return self.residuals 
     597 
     598    def set_theory_data(self, data): 
     599        """ 
     600        save a copy of the data select to fit 
     601 
     602        :param data: data selected 
     603 
     604        """ 
     605        self.theory_data = copy.deepcopy(data) 
     606 
     607    def get_theory_data(self): 
     608        """ 
     609        :return: theory generated with the current model and data of this class 
     610        """ 
     611        return self.theory_data 
     612 
     613    def set_fit_data(self, data): 
     614        """ 
     615        Store data associated with this class 
     616        :param data: list of data selected 
     617        """ 
     618        self.original_data = None 
     619        self.fit_data = None 
     620        # original data: should not be modified 
     621        self.original_data = data 
     622        # fit data: used for fit and can be modified for convenience 
     623        self.fit_data = copy.deepcopy(data) 
     624        self.smearer_computer_value = smear_selection(self.fit_data, 
     625                                                           self.model) 
     626        self.smearer_computed = True 
     627        self.result = None 
     628 
     629    def get_fit_data(self): 
     630        """ 
     631        :return: data associate with this class 
     632        """ 
     633        return self.fit_data 
     634 
     635    def get_origin_data(self): 
     636        """ 
     637        """ 
     638        return self.original_data 
     639 
     640    def set_weight(self, is2d, flag=None): 
     641        """ 
     642        Received flag and compute error on data. 
     643        :param flag: flag to transform error of data. 
     644        :param is2d: flag to distinguish 1D to 2D Data 
     645        """ 
     646        from sas.sasgui.perspectives.fitting.utils import get_weight 
     647        # send original data for weighting 
     648        self.weight = get_weight(data=self.original_data, is2d=is2d, flag=flag) 
     649        if is2d: 
     650            self.fit_data.err_data = self.weight 
     651        else: 
     652            self.fit_data.dy = self.weight 
     653 
     654    def get_weight(self): 
     655        """ 
     656        returns weight array 
     657        """ 
     658        return self.weight 
     659 
     660    def set_param2fit(self, list): 
     661        """ 
     662        Store param names to fit (checked) 
     663        :param list: list of the param names 
     664        """ 
     665        self.list_param2fit = list 
     666 
     667    def get_param2fit(self): 
     668        """ 
     669        return the list param names to fit 
     670        """ 
     671        return self.list_param2fit 
     672 
     673    def set_model_param(self, name, value=None): 
     674        """ 
     675        Store the name and value of a parameter of this fitproblem's model 
     676        :param name: name of the given parameter 
     677        :param value: value of that parameter 
     678        """ 
     679        self.list_param.append([name, value]) 
     680 
     681    def get_model_param(self): 
     682        """ 
     683        return list of couple of parameter name and value 
     684        """ 
     685        return self.list_param 
     686 
     687    def schedule_tofit(self, schedule=0): 
     688        """ 
     689        set schedule to true to decide if this fit  must be performed 
     690        """ 
     691        self.schedule = schedule 
     692 
     693    def get_scheduled(self): 
     694        """ 
     695        return true or false if a problem as being schedule for fitting 
     696        """ 
     697        return self.schedule 
     698 
     699    def set_range(self, qmin=None, qmax=None): 
     700        """ 
     701        set fitting range 
     702        :param qmin: minimum value to consider for the fit range 
     703        :param qmax: maximum value to consider for the fit range 
     704        """ 
     705        self.qmin = qmin 
     706        self.qmax = qmax 
     707 
     708    def get_range(self): 
     709        """ 
     710        :return: fitting range 
     711 
     712        """ 
     713        return self.qmin, self.qmax 
     714 
     715    def clear_model_param(self): 
     716        """ 
     717        clear constraint info 
     718        """ 
     719        self.list_param = [] 
     720 
     721    def set_fit_tab_caption(self, caption): 
     722        """ 
     723        """ 
     724        self.fit_tab_caption = str(caption) 
     725 
     726    def get_fit_tab_caption(self): 
     727        """ 
     728        """ 
     729        return self.fit_tab_caption 
     730 
     731    def set_graph_id(self, id): 
     732        """ 
     733        Set graph id (from data_group_id at the time the graph produced) 
     734        """ 
     735        self.graph_id = id 
     736 
     737    def get_graph_id(self): 
     738        """ 
     739        Get graph_id 
     740        """ 
     741        return self.graph_id 
     742 
     743    def set_result(self, result): 
     744        """ 
     745        """ 
     746        self.result = result 
     747 
     748    def get_result(self): 
     749        """ 
     750        get result 
     751        """ 
     752        return self.result 
Note: See TracChangeset for help on using the changeset viewer.