Changeset 251ef684 in sasview


Ignore:
Timestamp:
Jun 27, 2017 2:19:02 PM (6 years ago)
Author:
Paul Kienzle <pkienzle@…>
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, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
277257f
Parents:
50fcb09
Message:

code cleanup for fitproblem

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/sas/sasgui/perspectives/fitting/fitproblem.py

    r50fcb09 r251ef684  
    1717from sas.sascalc.fit.qsmearing import smear_selection 
    1818 
    19 class FitProblemComponent(object): 
     19class FitProblem(object): 
    2020    """ 
    21     Inferface containing information to store data, model, range of data, etc... 
    22     and retreive this information. This is an inferface 
    23     for a fitProblem i.e relationship between data and model. 
     21    Define the relationship between data and model, including range, weights, 
     22    etc. 
    2423    """ 
     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 
    2555    def enable_smearing(self, flag=False): 
    2656        """ 
     
    2858            flag is 0 ingore smear value. 
    2959        """ 
     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 
    3070 
    3171    def get_smearer(self): 
     
    3373        return smear object 
    3474        """ 
     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 
    3584    def save_model_name(self, name): 
    3685        """ 
    3786        """ 
     87        self.name_per_page = name 
    3888 
    3989    def get_name(self): 
    4090        """ 
    4191        """ 
     92        return self.name_per_page 
    4293 
    4394    def set_model(self, model): 
     
    4798        :param name: name created for model 
    4899        """ 
     100        self.model = model 
     101        self.smearer_computer_value = smear_selection(self.fit_data, 
     102                                                      self.model) 
     103        self.smearer_computed = True 
    49104 
    50105    def get_model(self): 
     
    52107        :return: saved model 
    53108        """ 
     109        return self.model 
    54110 
    55111    def set_residuals(self, residuals): 
     
    58114        :param data: data selected 
    59115        """ 
     116        self.residuals = residuals 
    60117 
    61118    def get_residuals(self): 
     
    63120        :return: residuals 
    64121        """ 
     122        return self.residuals 
    65123 
    66124    def set_theory_data(self, data): 
    67125        """ 
    68126        save a copy of the data select to fit 
     127 
    69128        :param data: data selected 
    70         """ 
     129 
     130        """ 
     131        self.theory_data = copy.deepcopy(data) 
    71132 
    72133    def get_theory_data(self): 
    73134        """ 
    74         :return: list of data dList 
    75         """ 
     135        :return: theory generated with the current model and data of this class 
     136        """ 
     137        return self.theory_data 
    76138 
    77139    def set_fit_data(self, data): 
    78140        """ 
    79         Store of list of data and create  by create new fitproblem of each data 
    80         id, if there was existing information about model, this information 
    81         get copy to the new fitproblem 
     141        Store data associated with this class 
    82142        :param data: list of data selected 
    83143        """ 
     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 
    84153 
    85154    def get_fit_data(self): 
    86155        """ 
    87         """ 
     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 
    88197 
    89198    def set_model_param(self, name, value=None): 
     
    93202        :param value: value of that parameter 
    94203        """ 
    95  
    96     def set_param2fit(self, list): 
    97         """ 
    98         Store param names to fit (checked) 
    99         :param list: list of the param names 
    100         """ 
    101  
    102     def get_param2fit(self): 
    103         """ 
    104         return the list param names to fit 
    105         """ 
     204        self.list_param.append([name, value]) 
    106205 
    107206    def get_model_param(self): 
     
    109208        return list of couple of parameter name and value 
    110209        """ 
     210        return self.list_param 
    111211 
    112212    def schedule_tofit(self, schedule=0): 
     
    114214        set schedule to true to decide if this fit  must be performed 
    115215        """ 
     216        self.schedule = schedule 
    116217 
    117218    def get_scheduled(self): 
     
    119220        return true or false if a problem as being schedule for fitting 
    120221        """ 
     222        return self.schedule 
    121223 
    122224    def set_range(self, qmin=None, qmax=None): 
    123225        """ 
    124226        set fitting range 
    125         """ 
     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 
    126232 
    127233    def get_range(self): 
    128234        """ 
    129235        :return: fitting range 
    130         """ 
    131  
    132     def set_weight(self, flag=None): 
    133         """ 
    134         set fitting range 
    135         """ 
    136  
    137     def get_weight(self): 
    138         """ 
    139         get fitting weight 
    140         """ 
     236 
     237        """ 
     238        return self.qmin, self.qmax 
    141239 
    142240    def clear_model_param(self): 
     
    144242        clear constraint info 
    145243        """ 
     244        self.list_param = [] 
    146245 
    147246    def set_fit_tab_caption(self, caption): 
    148247        """ 
    149         store the caption of the page associated with object 
    150         """ 
     248        """ 
     249        self.fit_tab_caption = str(caption) 
    151250 
    152251    def get_fit_tab_caption(self): 
    153252        """ 
    154         Return the caption of the page associated with object 
    155         """ 
     253        """ 
     254        return self.fit_tab_caption 
    156255 
    157256    def set_graph_id(self, id): 
     
    159258        Set graph id (from data_group_id at the time the graph produced) 
    160259        """ 
     260        self.graph_id = id 
    161261 
    162262    def get_graph_id(self): 
     
    164264        Get graph_id 
    165265        """ 
     266        return self.graph_id 
    166267 
    167268    def set_result(self, result): 
    168269        """ 
    169270        """ 
     271        self.result = result 
    170272 
    171273    def get_result(self): 
     
    173275        get result 
    174276        """ 
    175  
    176  
    177 class FitProblemDictionary(FitProblemComponent, dict): 
     277        return self.result 
     278 
     279 
     280class FitProblemDictionary(dict): 
    178281    """ 
    179282    This module implements a dictionary of fitproblem objects 
    180283    """ 
    181284    def __init__(self): 
    182         FitProblemComponent.__init__(self) 
    183285        dict.__init__(self) 
    184286        ## the current model 
     
    207309        self._smear_on = flag 
    208310        if fid is None: 
    209             for value in self.itervalues(): 
     311            for value in self.values(): 
    210312                value.enable_smearing(flag) 
    211         else: 
    212             if fid in self.iterkeys(): 
    213                 self[fid].enable_smearing(flag) 
     313        elif fid in self: 
     314            self[fid].enable_smearing(flag) 
    214315 
    215316    def set_smearer(self, smearer, fid=None): 
     
    219320        """ 
    220321        if fid is None: 
    221             for value in self.itervalues(): 
     322            for value in self.values(): 
    222323                value.set_smearer(smearer) 
    223         else: 
    224             if fid in self.iterkeys(): 
    225                 self[fid].set_smearer(smearer) 
     324        elif fid in self: 
     325            self[fid].set_smearer(smearer) 
    226326 
    227327    def get_smearer(self, fid=None): 
     
    229329        return smear object 
    230330        """ 
    231         if fid in self.iterkeys(): 
     331        if fid in self: 
    232332            return self[fid].get_smearer() 
    233333 
     
    236336        """ 
    237337        if fid is None: 
    238             for value in self.itervalues(): 
     338            for value in self.values(): 
    239339                value.save_model_name(name) 
    240         else: 
    241             if fid in self.iterkeys(): 
    242                 self[fid].save_model_name(name) 
     340        elif fid in self: 
     341            self[fid].save_model_name(name) 
    243342 
    244343    def get_name(self, fid=None): 
     
    247346        result = [] 
    248347        if fid is None: 
    249             for value in self.itervalues(): 
     348            for value in self.values(): 
    250349                result.append(value.get_name()) 
    251         else: 
    252             if fid in self.iterkeys(): 
    253                 result.append(self[fid].get_name()) 
     350        elif fid in self: 
     351            result.append(self[fid].get_name()) 
    254352        return result 
    255353 
     
    262360        self.model = model 
    263361        if fid is None: 
    264             for value in self.itervalues(): 
     362            for value in self.values(): 
    265363                value.set_model(self.model) 
    266         else: 
    267             if fid in self.iterkeys(): 
    268                 self[fid].set_model(self.model) 
     364        elif fid in self: 
     365            self[fid].set_model(self.model) 
    269366 
    270367    def get_model(self, fid): 
     
    272369        :return: saved model 
    273370        """ 
    274         if fid in self.iterkeys(): 
     371        if fid in self: 
    275372            return self[fid].get_model() 
    276373 
     
    292389        :param data: data selected 
    293390        """ 
    294         if fid in self.iterkeys(): 
     391        if fid in self: 
    295392            self[fid].set_residuals(residuals) 
    296393 
     
    299396        :return: residuals 
    300397        """ 
    301         if fid in self.iterkeys(): 
     398        if fid in self: 
    302399            return self[fid].get_residuals() 
    303400 
     
    307404        :param data: data selected 
    308405        """ 
    309         if fid in self.iterkeys(): 
     406        if fid in self: 
    310407            self[fid].set_theory_data(data) 
    311408 
     
    314411        :return: list of data dList 
    315412        """ 
    316         if fid in self.iterkeys(): 
     413        if fid in self: 
    317414            return self[fid].get_theory_data() 
    318415 
     
    323420        :note: only data changes in the fit problem 
    324421        """ 
    325         if data.id not in self.iterkeys(): 
     422        if data.id not in self: 
    326423            self[data.id] = FitProblem() 
    327424        self[data.id].set_fit_data(data) 
     
    337434            data = [] 
    338435        for d in data: 
    339             if (d is not None): 
    340                 if (d.id not in self.iterkeys()): 
     436            if d is not None: 
     437                if d.id not in self: 
    341438                    self[d.id] = FitProblem() 
    342439                self[d.id].set_fit_data(d) 
     
    349446        :param fid: key representing a fitproblem, usually extract from data id 
    350447        """ 
    351         if fid in self.iterkeys(): 
     448        if fid in self: 
    352449            return self[fid].get_fit_data() 
    353450 
     
    359456        """ 
    360457        if fid is None: 
    361             for value in self.itervalues(): 
     458            for value in self.values(): 
    362459                value.set_model_param(name, value) 
    363         else: 
    364             if fid in self.iterkeys(): 
    365                 self[fid].set_model_param(name, value) 
     460        elif fid in self: 
     461            self[fid].set_model_param(name, value) 
    366462 
    367463    def get_model_param(self, fid): 
     
    369465        return list of couple of parameter name and value 
    370466        """ 
    371         if fid in self.iterkeys(): 
     467        if fid in self: 
    372468            return self[fid].get_model_param() 
    373469 
     
    390486        """ 
    391487        self.scheduled = schedule 
    392         for value in self.itervalues(): 
     488        for value in self.values(): 
    393489            value.schedule_tofit(schedule) 
    394490 
     
    406502        self.qmax = qmax 
    407503        if fid is None: 
    408             for value in self.itervalues(): 
     504            for value in self.values(): 
    409505                value.set_range(self.qmin, self.qmax) 
    410         else: 
    411             if fid in self.iterkeys(): 
    412                 self[fid].value.set_range(self.qmin, self.qmax) 
     506        elif fid in self: 
     507            self[fid].value.set_range(self.qmin, self.qmax) 
    413508 
    414509    def get_range(self, fid): 
     
    416511        :return: fitting range 
    417512        """ 
    418         if fid in self.iterkeys(): 
     513        if fid in self: 
    419514            return self[fid].get_range() 
    420515 
     
    424519        """ 
    425520        if fid is None: 
    426             for value in self.itervalues(): 
     521            for value in self.values(): 
    427522                value.set_weight(flag=flag, is2d=is2d) 
    428         else: 
    429             if fid in self.iterkeys(): 
    430                 self[fid].set_weight(flag=flag, is2d=is2d) 
     523        elif fid in self: 
     524            self[fid].set_weight(flag=flag, is2d=is2d) 
    431525 
    432526    def get_weight(self, fid=None): 
     
    434528        return fit weight 
    435529        """ 
    436         if fid in self.iterkeys(): 
     530        if fid in self: 
    437531            return self[fid].get_weight() 
    438532 
     
    442536        """ 
    443537        if fid is None: 
    444             for value in self.itervalues(): 
     538            for value in self.values(): 
    445539                value.clear_model_param() 
    446         else: 
    447             if fid in self.iterkeys(): 
    448                 self[fid].clear_model_param() 
     540        elif fid in self: 
     541            self[fid].clear_model_param() 
    449542 
    450543    def get_fit_problem(self): 
     
    452545        return fitproblem contained in this dictionary 
    453546        """ 
    454         return self.itervalues() 
     547        return self.values() 
    455548 
    456549    def set_result(self, result, fid): 
    457550        """ 
    458551        """ 
    459         if fid in self.iterkeys(): 
     552        if fid in self: 
    460553            self[fid].set_result(result) 
    461554 
     
    471564        get result 
    472565        """ 
    473         if fid in self.iterkeys(): 
     566        if fid in self: 
    474567            return self[fid].get_result() 
    475568 
     
    491584        """ 
    492585        return self.graph_id 
    493  
    494  
    495 class FitProblem(FitProblemComponent): 
    496     """ 
    497     FitProblem class allows to link a model with the new name created in _on_model, 
    498     a name theory created with that model  and the data fitted with the model. 
    499     FitProblem is mostly used  as value of the dictionary by fitting module. 
    500     """ 
    501     def __init__(self): 
    502         FitProblemComponent.__init__(self) 
    503         """ 
    504         contains information about data and model to fit 
    505         """ 
    506         ## data used for fitting 
    507         self.fit_data = None 
    508         self.theory_data = None 
    509         self.residuals = None 
    510         # original data: should not be modified 
    511         self.original_data = None 
    512         ## the current model 
    513         self.model = None 
    514         ## if 1 this fit problem will be selected to fit , if 0 
    515         ## it will not be selected for fit 
    516         self.schedule = 0 
    517         ##list containing parameter name and value 
    518         self.list_param = [] 
    519         ## smear object to smear or not data1D 
    520         self.smearer_computed = False 
    521         self.smearer_enable = False 
    522         self.smearer_computer_value = None 
    523         ## fitting range 
    524         self.qmin = None 
    525         self.qmax = None 
    526         # fit weight 
    527         self.weight = None 
    528         self.result = None 
    529  
    530     def enable_smearing(self, flag=False): 
    531         """ 
    532         :param flag: bool.When flag is 1 get the computer smear value. When 
    533             flag is 0 ingore smear value. 
    534         """ 
    535         self.smearer_enable = flag 
    536  
    537     def set_smearer(self, smearer): 
    538         """ 
    539         save reference of  smear object on fitdata 
    540  
    541         :param smear: smear object from DataLoader 
    542  
    543         """ 
    544         self.smearer_computer_value = smearer 
    545  
    546     def get_smearer(self): 
    547         """ 
    548         return smear object 
    549         """ 
    550         if not self.smearer_enable: 
    551             return None 
    552         if not self.smearer_computed: 
    553             #smeari_selection should be call only once per fitproblem 
    554             self.smearer_computer_value = smear_selection(self.fit_data, 
    555                                                            self.model) 
    556             self.smearer_computed = True 
    557         return self.smearer_computer_value 
    558  
    559     def save_model_name(self, name): 
    560         """ 
    561         """ 
    562         self.name_per_page = name 
    563  
    564     def get_name(self): 
    565         """ 
    566         """ 
    567         return self.name_per_page 
    568  
    569     def set_model(self, model): 
    570         """ 
    571         associates each model with its new created name 
    572         :param model: model selected 
    573         :param name: name created for model 
    574         """ 
    575         self.model = model 
    576         self.smearer_computer_value = smear_selection(self.fit_data, 
    577                                                            self.model) 
    578         self.smearer_computed = True 
    579  
    580     def get_model(self): 
    581         """ 
    582         :return: saved model 
    583         """ 
    584         return self.model 
    585  
    586     def set_residuals(self, residuals): 
    587         """ 
    588         save a copy of residual 
    589         :param data: data selected 
    590         """ 
    591         self.residuals = residuals 
    592  
    593     def get_residuals(self): 
    594         """ 
    595         :return: residuals 
    596         """ 
    597         return self.residuals 
    598  
    599     def set_theory_data(self, data): 
    600         """ 
    601         save a copy of the data select to fit 
    602  
    603         :param data: data selected 
    604  
    605         """ 
    606         self.theory_data = copy.deepcopy(data) 
    607  
    608     def get_theory_data(self): 
    609         """ 
    610         :return: theory generated with the current model and data of this class 
    611         """ 
    612         return self.theory_data 
    613  
    614     def set_fit_data(self, data): 
    615         """ 
    616         Store data associated with this class 
    617         :param data: list of data selected 
    618         """ 
    619         self.original_data = None 
    620         self.fit_data = None 
    621         # original data: should not be modified 
    622         self.original_data = data 
    623         # fit data: used for fit and can be modified for convenience 
    624         self.fit_data = copy.deepcopy(data) 
    625         self.smearer_computer_value = smear_selection(self.fit_data, 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.