[3e3ab46] | 1 | ################################################################################ |
---|
| 2 | #This software was developed by the University of Tennessee as part of the |
---|
| 3 | #Distributed Data Analysis of Neutron Scattering Experiments (DANSE) |
---|
| 4 | #project funded by the US National Science Foundation. |
---|
| 5 | # |
---|
| 6 | #See the license text in license.txt |
---|
| 7 | # |
---|
| 8 | #copyright 2009, University of Tennessee |
---|
| 9 | ################################################################################ |
---|
[e88ebfd] | 10 | import copy |
---|
[3e3ab46] | 11 | from sans.models.qsmearing import smear_selection |
---|
[d89f09b] | 12 | |
---|
[3e3ab46] | 13 | |
---|
| 14 | class FitProblemComponent(object): |
---|
| 15 | """ |
---|
| 16 | Inferface containing information to store data, model, range of data, etc... |
---|
| 17 | and retreive this information. This is an inferface |
---|
| 18 | for a fitProblem i.e relationship between data and model. |
---|
| 19 | """ |
---|
| 20 | def enable_smearing(self, flag=False): |
---|
| 21 | """ |
---|
| 22 | :param flag: bool.When flag is 1 get the computer smear value. When |
---|
| 23 | flag is 0 ingore smear value. |
---|
| 24 | """ |
---|
| 25 | def get_smearer(self): |
---|
| 26 | """ |
---|
| 27 | return smear object |
---|
| 28 | """ |
---|
| 29 | def save_model_name(self, name): |
---|
| 30 | """ |
---|
| 31 | """ |
---|
| 32 | def get_name(self): |
---|
| 33 | """ |
---|
| 34 | """ |
---|
| 35 | def set_model(self, model): |
---|
| 36 | """ |
---|
| 37 | associates each model with its new created name |
---|
| 38 | :param model: model selected |
---|
| 39 | :param name: name created for model |
---|
| 40 | """ |
---|
| 41 | def get_model(self): |
---|
| 42 | """ |
---|
| 43 | :return: saved model |
---|
| 44 | """ |
---|
[62f851f] | 45 | def set_residuals(self, residuals): |
---|
| 46 | """ |
---|
| 47 | save a copy of residual |
---|
| 48 | :param data: data selected |
---|
| 49 | """ |
---|
| 50 | def get_residuals(self): |
---|
| 51 | """ |
---|
| 52 | :return: residuals |
---|
| 53 | """ |
---|
| 54 | |
---|
[3e3ab46] | 55 | def set_theory_data(self, data): |
---|
| 56 | """ |
---|
| 57 | save a copy of the data select to fit |
---|
| 58 | :param data: data selected |
---|
| 59 | """ |
---|
| 60 | def get_theory_data(self): |
---|
| 61 | """ |
---|
| 62 | :return: list of data dList |
---|
| 63 | """ |
---|
| 64 | def set_fit_data(self, data): |
---|
| 65 | """ |
---|
| 66 | Store of list of data and create by create new fitproblem of each data |
---|
| 67 | id , if there was existing information about model, this information |
---|
| 68 | get copy to the new fitproblem |
---|
| 69 | :param data: list of data selected |
---|
| 70 | """ |
---|
| 71 | def get_fit_data(self): |
---|
| 72 | """ |
---|
| 73 | """ |
---|
| 74 | def set_model_param(self, name, value=None): |
---|
| 75 | """ |
---|
| 76 | Store the name and value of a parameter of this fitproblem's model |
---|
| 77 | :param name: name of the given parameter |
---|
| 78 | :param value: value of that parameter |
---|
| 79 | """ |
---|
[1b14795] | 80 | def set_param2fit(self, list): |
---|
| 81 | """ |
---|
| 82 | Store param names to fit (checked) |
---|
| 83 | :param list: list of the param names |
---|
| 84 | """ |
---|
| 85 | def get_param2fit(self): |
---|
| 86 | """ |
---|
| 87 | return the list param names to fit |
---|
| 88 | """ |
---|
[3e3ab46] | 89 | def get_model_param(self): |
---|
| 90 | """ |
---|
| 91 | return list of couple of parameter name and value |
---|
| 92 | """ |
---|
| 93 | def schedule_tofit(self, schedule=0): |
---|
| 94 | """ |
---|
| 95 | set schedule to true to decide if this fit must be performed |
---|
| 96 | """ |
---|
| 97 | def get_scheduled(self): |
---|
| 98 | """ |
---|
| 99 | return true or false if a problem as being schedule for fitting |
---|
| 100 | """ |
---|
| 101 | def set_range(self, qmin=None, qmax=None): |
---|
| 102 | """ |
---|
| 103 | set fitting range |
---|
| 104 | """ |
---|
| 105 | def get_range(self): |
---|
| 106 | """ |
---|
| 107 | :return: fitting range |
---|
| 108 | """ |
---|
[f7ef313] | 109 | def set_weight(self, flag=None): |
---|
[55bb249c] | 110 | """ |
---|
| 111 | set fitting range |
---|
| 112 | """ |
---|
| 113 | def get_weight(self): |
---|
| 114 | """ |
---|
| 115 | get fitting weight |
---|
| 116 | """ |
---|
[3e3ab46] | 117 | def clear_model_param(self): |
---|
| 118 | """ |
---|
| 119 | clear constraint info |
---|
| 120 | """ |
---|
| 121 | def set_fit_tab_caption(self, caption): |
---|
| 122 | """ |
---|
| 123 | store the caption of the page associated with object |
---|
| 124 | """ |
---|
| 125 | def get_fit_tab_caption(self): |
---|
| 126 | """ |
---|
| 127 | Return the caption of the page associated with object |
---|
| 128 | """ |
---|
[5e48acb] | 129 | def set_graph_id(self, id): |
---|
| 130 | """ |
---|
| 131 | Set graph id (from data_group_id at the time the graph produced) |
---|
| 132 | """ |
---|
| 133 | def get_graph_id(self): |
---|
| 134 | """ |
---|
| 135 | Get graph_id |
---|
| 136 | """ |
---|
[3e3ab46] | 137 | |
---|
| 138 | class FitProblemDictionary(FitProblemComponent, dict): |
---|
| 139 | """ |
---|
| 140 | This module implements a dictionary of fitproblem objects |
---|
| 141 | """ |
---|
| 142 | def __init__(self): |
---|
| 143 | FitProblemComponent.__init__(self) |
---|
| 144 | dict.__init__(self) |
---|
| 145 | ## the current model |
---|
| 146 | self.model = None |
---|
| 147 | ## if 1 this fit problem will be selected to fit , if 0 |
---|
| 148 | ## it will not be selected for fit |
---|
| 149 | self.schedule = 0 |
---|
| 150 | ##list containing parameter name and value |
---|
| 151 | self.list_param = [] |
---|
| 152 | ## fitting range |
---|
| 153 | self.qmin = None |
---|
| 154 | self.qmax = None |
---|
[5e48acb] | 155 | self.graph_id = None |
---|
[3e3ab46] | 156 | self._smear_on = False |
---|
| 157 | self.scheduled = 0 |
---|
| 158 | self.fit_tab_caption = '' |
---|
| 159 | |
---|
| 160 | def enable_smearing(self, flag=False, fid=None): |
---|
| 161 | """ |
---|
| 162 | :param flag: bool.When flag is 1 get the computer smear value. When |
---|
| 163 | flag is 0 ingore smear value. |
---|
| 164 | """ |
---|
| 165 | self._smear_on = flag |
---|
| 166 | if fid is None: |
---|
| 167 | for value in self.itervalues(): |
---|
| 168 | value.enable_smearing(flag) |
---|
| 169 | else: |
---|
| 170 | if fid in self.iterkeys(): |
---|
| 171 | self[fid].enable_smearing(flag) |
---|
| 172 | |
---|
| 173 | def set_smearer(self, smearer, fid=None): |
---|
| 174 | """ |
---|
| 175 | save reference of smear object on fitdata |
---|
| 176 | :param smear: smear object from DataLoader |
---|
| 177 | """ |
---|
| 178 | if fid is None: |
---|
| 179 | for value in self.itervalues(): |
---|
| 180 | value.set_smearer(smearer) |
---|
| 181 | else: |
---|
| 182 | if fid in self.iterkeys(): |
---|
| 183 | self[fid].set_smearer(smearer) |
---|
| 184 | |
---|
| 185 | def get_smearer(self, fid=None): |
---|
| 186 | """ |
---|
| 187 | return smear object |
---|
| 188 | """ |
---|
[62f851f] | 189 | if fid in self.iterkeys(): |
---|
| 190 | return self[fid].get_smearer() |
---|
| 191 | |
---|
[3e3ab46] | 192 | |
---|
| 193 | def save_model_name(self, name, fid=None): |
---|
| 194 | """ |
---|
| 195 | """ |
---|
| 196 | if fid is None: |
---|
| 197 | for value in self.itervalues(): |
---|
| 198 | value.save_model_name(name) |
---|
| 199 | else: |
---|
| 200 | if fid in self.iterkeys(): |
---|
| 201 | self[fid].save_model_name(name) |
---|
| 202 | |
---|
| 203 | def get_name(self, fid=None): |
---|
| 204 | """ |
---|
| 205 | """ |
---|
| 206 | result = [] |
---|
| 207 | if fid is None: |
---|
| 208 | for value in self.itervalues(): |
---|
| 209 | result.append(value.get_name()) |
---|
| 210 | else: |
---|
| 211 | if fid in self.iterkeys(): |
---|
| 212 | result.append(self[fid].get_name()) |
---|
| 213 | return result |
---|
| 214 | |
---|
| 215 | def set_model(self, model, fid=None): |
---|
| 216 | """ |
---|
| 217 | associates each model with its new created name |
---|
| 218 | :param model: model selected |
---|
| 219 | :param name: name created for model |
---|
| 220 | """ |
---|
| 221 | self.model = model |
---|
| 222 | if fid is None: |
---|
| 223 | for value in self.itervalues(): |
---|
| 224 | value.set_model(self.model) |
---|
| 225 | else: |
---|
| 226 | if fid in self.iterkeys(): |
---|
| 227 | self[fid].set_model(self.model) |
---|
| 228 | |
---|
| 229 | def get_model(self, fid): |
---|
| 230 | """ |
---|
| 231 | :return: saved model |
---|
| 232 | """ |
---|
| 233 | if fid in self.iterkeys(): |
---|
[62f851f] | 234 | return self[fid].get_model() |
---|
[3e3ab46] | 235 | |
---|
| 236 | def set_fit_tab_caption(self, caption): |
---|
| 237 | """ |
---|
| 238 | store the caption of the page associated with object |
---|
| 239 | """ |
---|
| 240 | self.fit_tab_caption = caption |
---|
| 241 | |
---|
| 242 | def get_fit_tab_caption(self): |
---|
| 243 | """ |
---|
| 244 | Return the caption of the page associated with object |
---|
| 245 | """ |
---|
| 246 | return self.fit_tab_caption |
---|
| 247 | |
---|
[62f851f] | 248 | def set_residuals(self, residuals, fid): |
---|
| 249 | """ |
---|
| 250 | save a copy of residual |
---|
| 251 | :param data: data selected |
---|
| 252 | """ |
---|
| 253 | if fid in self.iterkeys(): |
---|
| 254 | self[fid].set_residuals(residuals) |
---|
| 255 | |
---|
| 256 | def get_residuals(self, fid): |
---|
| 257 | """ |
---|
| 258 | :return: residuals |
---|
| 259 | """ |
---|
| 260 | if fid in self.iterkeys(): |
---|
| 261 | return self[fid].get_residuals() |
---|
| 262 | |
---|
[3e3ab46] | 263 | def set_theory_data(self, fid, data=None): |
---|
| 264 | """ |
---|
| 265 | save a copy of the data select to fit |
---|
| 266 | :param data: data selected |
---|
| 267 | """ |
---|
| 268 | if fid in self.iterkeys(): |
---|
| 269 | self[fid].set_theory_data(data) |
---|
| 270 | |
---|
| 271 | def get_theory_data(self, fid): |
---|
| 272 | """ |
---|
| 273 | :return: list of data dList |
---|
| 274 | """ |
---|
| 275 | if fid in self.iterkeys(): |
---|
| 276 | return self[fid].get_theory_data() |
---|
| 277 | |
---|
| 278 | def add_data(self, data): |
---|
| 279 | """ |
---|
| 280 | Add data to the current dictionary of fitproblem. if data id does not |
---|
| 281 | exist create a new fit problem. |
---|
| 282 | :note: only data changes in the fit problem |
---|
| 283 | """ |
---|
| 284 | if data.id not in self.iterkeys(): |
---|
| 285 | self[data.id] = FitProblem() |
---|
| 286 | self[data.id].set_fit_data(data) |
---|
| 287 | |
---|
| 288 | def set_fit_data(self, data): |
---|
| 289 | """ |
---|
| 290 | save a copy of the data select to fit |
---|
| 291 | :param data: data selected |
---|
| 292 | |
---|
| 293 | """ |
---|
| 294 | self.clear() |
---|
| 295 | if data is None: |
---|
| 296 | data = [] |
---|
| 297 | for d in data: |
---|
| 298 | if (d is not None): |
---|
| 299 | if (d.id not in self.iterkeys()): |
---|
| 300 | self[d.id] = FitProblem() |
---|
| 301 | self[d.id].set_fit_data(d) |
---|
| 302 | self[d.id].set_model(self.model) |
---|
| 303 | self[d.id].set_range(self.qmin, self.qmax) |
---|
[55bb249c] | 304 | #self[d.id].set_smearer(self[d.id].get_smearer()) |
---|
[3e3ab46] | 305 | def get_fit_data(self, fid): |
---|
| 306 | """ |
---|
| 307 | |
---|
| 308 | return data for the given fitproblem id |
---|
| 309 | :param fid: is key representing a fitproblem. usually extract from data |
---|
| 310 | id |
---|
| 311 | """ |
---|
| 312 | if fid in self.iterkeys(): |
---|
| 313 | return self[fid].get_fit_data() |
---|
| 314 | |
---|
| 315 | def set_model_param(self, name, value=None, fid=None): |
---|
| 316 | """ |
---|
| 317 | Store the name and value of a parameter of this fitproblem's model |
---|
| 318 | :param name: name of the given parameter |
---|
| 319 | :param value: value of that parameter |
---|
| 320 | """ |
---|
| 321 | if fid is None: |
---|
| 322 | for value in self.itervalues(): |
---|
| 323 | value.set_model_param(name, value) |
---|
| 324 | else: |
---|
| 325 | if fid in self.iterkeys(): |
---|
| 326 | self[fid].set_model_param(name, value) |
---|
| 327 | |
---|
| 328 | def get_model_param(self, fid): |
---|
| 329 | """ |
---|
| 330 | return list of couple of parameter name and value |
---|
| 331 | """ |
---|
| 332 | if fid in self.iterkeys(): |
---|
| 333 | return self[fid].get_model_param() |
---|
[1b14795] | 334 | |
---|
| 335 | def set_param2fit(self, list): |
---|
| 336 | """ |
---|
| 337 | Store param names to fit (checked) |
---|
| 338 | :param list: list of the param names |
---|
| 339 | """ |
---|
| 340 | self.list_param2fit = list |
---|
| 341 | |
---|
| 342 | def get_param2fit(self): |
---|
| 343 | """ |
---|
| 344 | return the list param names to fit |
---|
| 345 | """ |
---|
| 346 | return self.list_param2fit |
---|
| 347 | |
---|
[3e3ab46] | 348 | def schedule_tofit(self, schedule=0): |
---|
| 349 | """ |
---|
| 350 | set schedule to true to decide if this fit must be performed |
---|
| 351 | """ |
---|
| 352 | self.scheduled = schedule |
---|
| 353 | for value in self.itervalues(): |
---|
| 354 | value.schedule_tofit(schedule) |
---|
| 355 | |
---|
| 356 | def get_scheduled(self): |
---|
| 357 | """ |
---|
| 358 | return true or false if a problem as being schedule for fitting |
---|
| 359 | """ |
---|
| 360 | return self.scheduled |
---|
| 361 | |
---|
| 362 | def set_range(self, qmin=None, qmax=None, fid=None): |
---|
| 363 | """ |
---|
| 364 | set fitting range |
---|
| 365 | """ |
---|
| 366 | self.qmin = qmin |
---|
| 367 | self.qmax = qmax |
---|
| 368 | if fid is None: |
---|
| 369 | for value in self.itervalues(): |
---|
| 370 | value.set_range(self.qmin, self.qmax) |
---|
| 371 | else: |
---|
| 372 | if fid in self.iterkeys(): |
---|
| 373 | self[fid].value.set_range(self.qmin, self.qmax) |
---|
| 374 | |
---|
| 375 | def get_range(self, fid): |
---|
| 376 | """ |
---|
| 377 | :return: fitting range |
---|
| 378 | """ |
---|
| 379 | if fid in self.iterkeys(): |
---|
| 380 | return self[fid].get_range() |
---|
| 381 | |
---|
[f7ef313] | 382 | def set_weight(self, is2d, flag=None, fid=None): |
---|
[55bb249c] | 383 | """ |
---|
| 384 | fit weight |
---|
| 385 | """ |
---|
| 386 | if fid is None: |
---|
| 387 | for value in self.itervalues(): |
---|
[f7ef313] | 388 | value.set_weight(flag=flag, is2d=is2d) |
---|
[55bb249c] | 389 | else: |
---|
| 390 | if fid in self.iterkeys(): |
---|
[f7ef313] | 391 | self[fid].set_weight(flag=flag, is2d=is2d) |
---|
[55bb249c] | 392 | |
---|
| 393 | def get_weight(self, fid=None): |
---|
| 394 | """ |
---|
| 395 | return fit weight |
---|
| 396 | """ |
---|
| 397 | if fid in self.iterkeys(): |
---|
| 398 | return self[fid].get_weight() |
---|
| 399 | |
---|
[3e3ab46] | 400 | def clear_model_param(self, fid=None): |
---|
| 401 | """ |
---|
| 402 | clear constraint info |
---|
| 403 | """ |
---|
| 404 | if fid is None: |
---|
| 405 | for value in self.itervalues(): |
---|
| 406 | value.clear_model_param() |
---|
| 407 | else: |
---|
| 408 | if fid in self.iterkeys(): |
---|
| 409 | self[fid].clear_model_param() |
---|
| 410 | |
---|
| 411 | def get_fit_problem(self): |
---|
| 412 | """ |
---|
| 413 | return fitproblem contained in this dictionary |
---|
| 414 | """ |
---|
| 415 | return self.itervalues() |
---|
| 416 | |
---|
| 417 | def set_result(self, result): |
---|
| 418 | """ |
---|
| 419 | set a list of result |
---|
| 420 | """ |
---|
| 421 | self.result = result |
---|
| 422 | |
---|
| 423 | def get_result(self): |
---|
| 424 | """ |
---|
| 425 | get result |
---|
| 426 | """ |
---|
| 427 | return self.result |
---|
| 428 | |
---|
[5e48acb] | 429 | def set_graph_id(self, id): |
---|
| 430 | """ |
---|
| 431 | Set graph id (from data_group_id at the time the graph produced) |
---|
| 432 | """ |
---|
| 433 | self.graph_id = id |
---|
| 434 | |
---|
| 435 | def get_graph_id(self): |
---|
| 436 | """ |
---|
| 437 | Get graph_id |
---|
| 438 | """ |
---|
| 439 | return self.graph_id |
---|
| 440 | |
---|
| 441 | |
---|
[3e3ab46] | 442 | class FitProblem(FitProblemComponent): |
---|
[d89f09b] | 443 | """ |
---|
[5062bbf] | 444 | FitProblem class allows to link a model with the new name created in _on_model, |
---|
| 445 | a name theory created with that model and the data fitted with the model. |
---|
| 446 | FitProblem is mostly used as value of the dictionary by fitting module. |
---|
[d89f09b] | 447 | """ |
---|
| 448 | def __init__(self): |
---|
[3e3ab46] | 449 | FitProblemComponent.__init__(self) |
---|
[d89f09b] | 450 | """ |
---|
[5062bbf] | 451 | contains information about data and model to fit |
---|
[d89f09b] | 452 | """ |
---|
[925a30e] | 453 | ## data used for fitting |
---|
[6bbeacd4] | 454 | self.fit_data = None |
---|
| 455 | self.theory_data = None |
---|
[62f851f] | 456 | self.residuals = None |
---|
[05325ec4] | 457 | # original data: should not be modified |
---|
| 458 | self.original_data = None |
---|
[2140e68] | 459 | ## the current model |
---|
| 460 | self.model = None |
---|
[925a30e] | 461 | ## if 1 this fit problem will be selected to fit , if 0 |
---|
| 462 | ## it will not be selected for fit |
---|
[6bbeacd4] | 463 | self.schedule = 0 |
---|
[925a30e] | 464 | ##list containing parameter name and value |
---|
[6bbeacd4] | 465 | self.list_param = [] |
---|
[925a30e] | 466 | ## smear object to smear or not data1D |
---|
[7afcae8] | 467 | self.smearer_computed = False |
---|
[3e3ab46] | 468 | self.smearer_enable = False |
---|
| 469 | self.smearer_computer_value = None |
---|
[2140e68] | 470 | ## fitting range |
---|
| 471 | self.qmin = None |
---|
| 472 | self.qmax = None |
---|
[55bb249c] | 473 | # fit weight |
---|
| 474 | self.weight = None |
---|
[08b9c6c8] | 475 | |
---|
[ba1f0b2] | 476 | |
---|
[3e3ab46] | 477 | def enable_smearing(self, flag=False): |
---|
[9853ad0] | 478 | """ |
---|
[3e3ab46] | 479 | :param flag: bool.When flag is 1 get the computer smear value. When |
---|
| 480 | flag is 0 ingore smear value. |
---|
[9853ad0] | 481 | """ |
---|
[3e3ab46] | 482 | self.smearer_enable = flag |
---|
[9853ad0] | 483 | |
---|
[08b9c6c8] | 484 | def set_smearer(self, smearer): |
---|
[925a30e] | 485 | """ |
---|
[5062bbf] | 486 | save reference of smear object on fitdata |
---|
| 487 | |
---|
| 488 | :param smear: smear object from DataLoader |
---|
| 489 | |
---|
[925a30e] | 490 | """ |
---|
[3e3ab46] | 491 | self.smearer_computer_value = smearer |
---|
[925a30e] | 492 | |
---|
[08b9c6c8] | 493 | def get_smearer(self): |
---|
[925a30e] | 494 | """ |
---|
[5062bbf] | 495 | return smear object |
---|
[925a30e] | 496 | """ |
---|
[3e3ab46] | 497 | if not self.smearer_enable: |
---|
| 498 | return None |
---|
[7afcae8] | 499 | if not self.smearer_computed: |
---|
[3e3ab46] | 500 | #smeari_selection should be call only once per fitproblem |
---|
[7afcae8] | 501 | self.smearer_computer_value = smear_selection(self.fit_data, |
---|
[3e3ab46] | 502 | self.model) |
---|
[7afcae8] | 503 | self.smearer_computed = True |
---|
[3e3ab46] | 504 | return self.smearer_computer_value |
---|
[08b9c6c8] | 505 | |
---|
[5062bbf] | 506 | def save_model_name(self, name): |
---|
| 507 | """ |
---|
| 508 | """ |
---|
[bb18ef1] | 509 | self.name_per_page= name |
---|
| 510 | |
---|
| 511 | def get_name(self): |
---|
[5062bbf] | 512 | """ |
---|
| 513 | """ |
---|
[bb18ef1] | 514 | return self.name_per_page |
---|
[08b9c6c8] | 515 | |
---|
[8aa5788] | 516 | def set_model(self, model): |
---|
[d89f09b] | 517 | """ |
---|
[5062bbf] | 518 | associates each model with its new created name |
---|
| 519 | :param model: model selected |
---|
| 520 | :param name: name created for model |
---|
[d89f09b] | 521 | """ |
---|
[7afcae8] | 522 | self.model = model |
---|
| 523 | self.smearer_computer_value = smear_selection(self.fit_data, |
---|
| 524 | self.model) |
---|
| 525 | self.smearer_computed = True |
---|
[bb18ef1] | 526 | |
---|
[2140e68] | 527 | def get_model(self): |
---|
[5062bbf] | 528 | """ |
---|
| 529 | :return: saved model |
---|
| 530 | """ |
---|
[2140e68] | 531 | return self.model |
---|
[62f851f] | 532 | |
---|
| 533 | def set_residuals(self, residuals): |
---|
| 534 | """ |
---|
| 535 | save a copy of residual |
---|
| 536 | :param data: data selected |
---|
| 537 | """ |
---|
| 538 | self.residuals = residuals |
---|
| 539 | |
---|
| 540 | def get_residuals(self): |
---|
| 541 | """ |
---|
| 542 | :return: residuals |
---|
| 543 | """ |
---|
| 544 | return self.residuals |
---|
| 545 | |
---|
[6bbeacd4] | 546 | def set_theory_data(self, data): |
---|
[d89f09b] | 547 | """ |
---|
[5062bbf] | 548 | save a copy of the data select to fit |
---|
| 549 | |
---|
| 550 | :param data: data selected |
---|
| 551 | |
---|
[d89f09b] | 552 | """ |
---|
[e88ebfd] | 553 | self.theory_data = copy.deepcopy(data) |
---|
[ba1f0b2] | 554 | |
---|
[3e3ab46] | 555 | |
---|
[ba1f0b2] | 556 | |
---|
[6bbeacd4] | 557 | def get_theory_data(self): |
---|
[5062bbf] | 558 | """ |
---|
[3e3ab46] | 559 | :return: theory generated with the current model and data of this class |
---|
[5062bbf] | 560 | """ |
---|
[6bbeacd4] | 561 | return self.theory_data |
---|
[5062bbf] | 562 | |
---|
[3e3ab46] | 563 | def set_fit_data(self, data): |
---|
[2a8fac1] | 564 | """ |
---|
[3e3ab46] | 565 | Store data associated with this class |
---|
| 566 | :param data: list of data selected |
---|
[2a8fac1] | 567 | """ |
---|
[3fb5e68] | 568 | self.original_data = None |
---|
| 569 | self.fit_data = None |
---|
[05325ec4] | 570 | # original data: should not be modified |
---|
| 571 | self.original_data = copy.deepcopy(data) |
---|
| 572 | # fit data: used for fit and can be modified for convenience |
---|
[55bb249c] | 573 | self.fit_data = copy.deepcopy(data) |
---|
[7afcae8] | 574 | self.smearer_computer_value = smear_selection(self.fit_data, |
---|
| 575 | self.model) |
---|
| 576 | self.smearer_computed = True |
---|
[f7ef313] | 577 | |
---|
[2a8fac1] | 578 | def get_fit_data(self): |
---|
[5062bbf] | 579 | """ |
---|
[3e3ab46] | 580 | :return: data associate with this class |
---|
[5062bbf] | 581 | """ |
---|
[2a8fac1] | 582 | return self.fit_data |
---|
| 583 | |
---|
[f7ef313] | 584 | def set_weight(self, is2d, flag=None): |
---|
[55bb249c] | 585 | """ |
---|
[f7ef313] | 586 | Received flag and compute error on data. |
---|
| 587 | :param flag: flag to transform error of data. |
---|
| 588 | :param is2d: flag to distinguish 1D to 2D Data |
---|
[55bb249c] | 589 | """ |
---|
[f7ef313] | 590 | from .utils import get_weight |
---|
[05325ec4] | 591 | # send original data for weighting |
---|
| 592 | self.weight = get_weight(data=self.original_data, is2d=is2d, flag=flag) |
---|
[55bb249c] | 593 | if is2d: |
---|
| 594 | self.fit_data.err_data = self.weight |
---|
| 595 | else: |
---|
| 596 | self.fit_data.dy = self.weight |
---|
| 597 | |
---|
| 598 | def get_weight(self): |
---|
| 599 | """ |
---|
| 600 | returns weight array |
---|
| 601 | """ |
---|
| 602 | return self.weight |
---|
[1b14795] | 603 | |
---|
| 604 | def set_param2fit(self, list): |
---|
| 605 | """ |
---|
| 606 | Store param names to fit (checked) |
---|
| 607 | :param list: list of the param names |
---|
| 608 | """ |
---|
| 609 | self.list_param2fit = list |
---|
[55bb249c] | 610 | |
---|
[1b14795] | 611 | def get_param2fit(self): |
---|
| 612 | """ |
---|
| 613 | return the list param names to fit |
---|
| 614 | """ |
---|
| 615 | return self.list_param2fit |
---|
| 616 | |
---|
[2140e68] | 617 | def set_model_param(self,name,value=None): |
---|
[d89f09b] | 618 | """ |
---|
[5062bbf] | 619 | Store the name and value of a parameter of this fitproblem's model |
---|
| 620 | :param name: name of the given parameter |
---|
| 621 | :param value: value of that parameter |
---|
[d89f09b] | 622 | """ |
---|
[8e81af0] | 623 | self.list_param.append([name,value]) |
---|
[925a30e] | 624 | |
---|
[00561739] | 625 | def get_model_param(self): |
---|
| 626 | """ |
---|
[5062bbf] | 627 | return list of couple of parameter name and value |
---|
[00561739] | 628 | """ |
---|
[8e81af0] | 629 | return self.list_param |
---|
[d89f09b] | 630 | |
---|
[948add7] | 631 | def schedule_tofit(self, schedule=0): |
---|
[3b19ac9] | 632 | """ |
---|
[5062bbf] | 633 | set schedule to true to decide if this fit must be performed |
---|
[3b19ac9] | 634 | """ |
---|
[3e3ab46] | 635 | self.schedule = schedule |
---|
[6bcdad1] | 636 | |
---|
[3b19ac9] | 637 | def get_scheduled(self): |
---|
[5062bbf] | 638 | """ |
---|
| 639 | return true or false if a problem as being schedule for fitting |
---|
| 640 | """ |
---|
[3b19ac9] | 641 | return self.schedule |
---|
[925a30e] | 642 | |
---|
[2140e68] | 643 | def set_range(self, qmin=None, qmax=None): |
---|
| 644 | """ |
---|
[3e3ab46] | 645 | set fitting range |
---|
| 646 | :param qmin: minimum value to consider for the fit range |
---|
| 647 | :param qmax: maximum value to consider for the fit range |
---|
[2140e68] | 648 | """ |
---|
| 649 | self.qmin = qmin |
---|
| 650 | self.qmax = qmax |
---|
| 651 | |
---|
| 652 | def get_range(self): |
---|
| 653 | """ |
---|
[5062bbf] | 654 | :return: fitting range |
---|
| 655 | |
---|
[2140e68] | 656 | """ |
---|
| 657 | return self.qmin, self.qmax |
---|
[925a30e] | 658 | |
---|
[9e27de9] | 659 | def clear_model_param(self): |
---|
| 660 | """ |
---|
| 661 | clear constraint info |
---|
| 662 | """ |
---|
[3e3ab46] | 663 | self.list_param = [] |
---|
[6bbeacd4] | 664 | |
---|
| 665 | def set_fit_tab_caption(self, caption): |
---|
| 666 | """ |
---|
| 667 | """ |
---|
| 668 | self.fit_tab_caption = str(caption) |
---|
| 669 | |
---|
| 670 | def get_fit_tab_caption(self): |
---|
| 671 | """ |
---|
| 672 | """ |
---|
| 673 | return self.fit_tab_caption |
---|
[ba1f0b2] | 674 | |
---|
[5e48acb] | 675 | def set_graph_id(self, id): |
---|
| 676 | """ |
---|
| 677 | Set graph id (from data_group_id at the time the graph produced) |
---|
| 678 | """ |
---|
| 679 | self.graph_id = id |
---|
| 680 | |
---|
| 681 | def get_graph_id(self): |
---|
| 682 | """ |
---|
| 683 | Get graph_id |
---|
| 684 | """ |
---|
| 685 | return self.graph_id |
---|
[5062bbf] | 686 | |
---|