[72c7d31] | 1 | import logging, sys |
---|
[54c21f50] | 2 | import park,numpy,math, copy |
---|
[48882d1] | 3 | |
---|
| 4 | class SansParameter(park.Parameter): |
---|
| 5 | """ |
---|
| 6 | SANS model parameters for use in the PARK fitting service. |
---|
| 7 | The parameter attribute value is redirected to the underlying |
---|
| 8 | parameter value in the SANS model. |
---|
| 9 | """ |
---|
| 10 | def __init__(self, name, model): |
---|
[ca6d914] | 11 | """ |
---|
| 12 | @param name: the name of the model parameter |
---|
| 13 | @param model: the sans model to wrap as a park model |
---|
| 14 | """ |
---|
| 15 | self._model, self._name = model,name |
---|
| 16 | #set the value for the parameter of the given name |
---|
| 17 | self.set(model.getParam(name)) |
---|
[48882d1] | 18 | |
---|
[ca6d914] | 19 | def _getvalue(self): |
---|
| 20 | """ |
---|
| 21 | override the _getvalue of park parameter |
---|
| 22 | @return value the parameter associates with self.name |
---|
| 23 | """ |
---|
| 24 | return self._model.getParam(self.name) |
---|
[48882d1] | 25 | |
---|
[ca6d914] | 26 | def _setvalue(self,value): |
---|
| 27 | """ |
---|
| 28 | override the _setvalue pf park parameter |
---|
| 29 | @param value: the value to set on a given parameter |
---|
| 30 | """ |
---|
[48882d1] | 31 | self._model.setParam(self.name, value) |
---|
| 32 | |
---|
| 33 | value = property(_getvalue,_setvalue) |
---|
| 34 | |
---|
| 35 | def _getrange(self): |
---|
[ca6d914] | 36 | """ |
---|
| 37 | Override _getrange of park parameter |
---|
| 38 | return the range of parameter |
---|
| 39 | """ |
---|
[c79ee796] | 40 | if not self.name in self._model.getDispParamList(): |
---|
| 41 | lo,hi = self._model.details[self.name][1:] |
---|
| 42 | if lo is None: lo = -numpy.inf |
---|
| 43 | if hi is None: hi = numpy.inf |
---|
| 44 | else: |
---|
| 45 | lo= -numpy.inf |
---|
| 46 | hi= numpy.inf |
---|
[05f14dd] | 47 | if lo >= hi: |
---|
| 48 | raise ValueError,"wrong fit range for parameters" |
---|
| 49 | |
---|
[48882d1] | 50 | return lo,hi |
---|
| 51 | |
---|
| 52 | def _setrange(self,r): |
---|
[ca6d914] | 53 | """ |
---|
| 54 | override _setrange of park parameter |
---|
| 55 | @param r: the value of the range to set |
---|
| 56 | """ |
---|
[48882d1] | 57 | self._model.details[self.name][1:] = r |
---|
| 58 | range = property(_getrange,_setrange) |
---|
[a9e04aa] | 59 | |
---|
| 60 | class Model(park.Model): |
---|
[48882d1] | 61 | """ |
---|
| 62 | PARK wrapper for SANS models. |
---|
| 63 | """ |
---|
[388309d] | 64 | def __init__(self, sans_model, **kw): |
---|
[ca6d914] | 65 | """ |
---|
| 66 | @param sans_model: the sans model to wrap using park interface |
---|
| 67 | """ |
---|
[a9e04aa] | 68 | park.Model.__init__(self, **kw) |
---|
[48882d1] | 69 | self.model = sans_model |
---|
[ca6d914] | 70 | self.name = sans_model.name |
---|
| 71 | #list of parameters names |
---|
[48882d1] | 72 | self.sansp = sans_model.getParamList() |
---|
[ca6d914] | 73 | #list of park parameter |
---|
[48882d1] | 74 | self.parkp = [SansParameter(p,sans_model) for p in self.sansp] |
---|
[ca6d914] | 75 | #list of parameterset |
---|
[48882d1] | 76 | self.parameterset = park.ParameterSet(sans_model.name,pars=self.parkp) |
---|
| 77 | self.pars=[] |
---|
[ca6d914] | 78 | |
---|
| 79 | |
---|
[48882d1] | 80 | def getParams(self,fitparams): |
---|
[ca6d914] | 81 | """ |
---|
| 82 | return a list of value of paramter to fit |
---|
| 83 | @param fitparams: list of paramaters name to fit |
---|
| 84 | """ |
---|
[48882d1] | 85 | list=[] |
---|
| 86 | self.pars=[] |
---|
| 87 | self.pars=fitparams |
---|
| 88 | for item in fitparams: |
---|
| 89 | for element in self.parkp: |
---|
| 90 | if element.name ==str(item): |
---|
| 91 | list.append(element.value) |
---|
| 92 | return list |
---|
| 93 | |
---|
[ca6d914] | 94 | |
---|
[e71440c] | 95 | def setParams(self,paramlist, params): |
---|
[ca6d914] | 96 | """ |
---|
| 97 | Set value for parameters to fit |
---|
| 98 | @param params: list of value for parameters to fit |
---|
| 99 | """ |
---|
[e71440c] | 100 | try: |
---|
| 101 | for i in range(len(self.parkp)): |
---|
| 102 | for j in range(len(paramlist)): |
---|
| 103 | if self.parkp[i].name==paramlist[j]: |
---|
| 104 | self.parkp[i].value = params[j] |
---|
| 105 | self.model.setParam(self.parkp[i].name,params[j]) |
---|
| 106 | except: |
---|
| 107 | raise |
---|
[ca6d914] | 108 | |
---|
[48882d1] | 109 | def eval(self,x): |
---|
[ca6d914] | 110 | """ |
---|
| 111 | override eval method of park model. |
---|
| 112 | @param x: the x value used to compute a function |
---|
| 113 | """ |
---|
[d8a2e31] | 114 | try: |
---|
| 115 | return self.model.evalDistribution(x) |
---|
| 116 | except: |
---|
| 117 | return self.model.runXY(x) |
---|
[388309d] | 118 | |
---|
| 119 | |
---|
[a9e04aa] | 120 | |
---|
| 121 | |
---|
[48882d1] | 122 | class Data(object): |
---|
| 123 | """ Wrapper class for SANS data """ |
---|
| 124 | def __init__(self,x=None,y=None,dy=None,dx=None,sans_data=None): |
---|
[ca6d914] | 125 | """ |
---|
| 126 | Data can be initital with a data (sans plottable) |
---|
| 127 | or with vectors. |
---|
| 128 | """ |
---|
[48882d1] | 129 | if sans_data !=None: |
---|
| 130 | self.x= sans_data.x |
---|
| 131 | self.y= sans_data.y |
---|
| 132 | self.dx= sans_data.dx |
---|
| 133 | self.dy= sans_data.dy |
---|
| 134 | |
---|
| 135 | elif (x!=None and y!=None and dy!=None): |
---|
| 136 | self.x=x |
---|
| 137 | self.y=y |
---|
| 138 | self.dx=dx |
---|
| 139 | self.dy=dy |
---|
| 140 | else: |
---|
| 141 | raise ValueError,\ |
---|
| 142 | "Data is missing x, y or dy, impossible to compute residuals later on" |
---|
| 143 | self.qmin=None |
---|
| 144 | self.qmax=None |
---|
| 145 | |
---|
[ca6d914] | 146 | |
---|
[48882d1] | 147 | def setFitRange(self,mini=None,maxi=None): |
---|
| 148 | """ to set the fit range""" |
---|
[773806e] | 149 | |
---|
| 150 | self.qmin=mini |
---|
[48882d1] | 151 | self.qmax=maxi |
---|
[ca6d914] | 152 | |
---|
| 153 | |
---|
[48882d1] | 154 | def getFitRange(self): |
---|
[ca6d914] | 155 | """ |
---|
| 156 | @return the range of data.x to fit |
---|
| 157 | """ |
---|
| 158 | return self.qmin, self.qmax |
---|
| 159 | |
---|
| 160 | |
---|
[48882d1] | 161 | def residuals(self, fn): |
---|
| 162 | """ @param fn: function that return model value |
---|
| 163 | @return residuals |
---|
| 164 | """ |
---|
| 165 | x,y,dy = [numpy.asarray(v) for v in (self.x,self.y,self.dy)] |
---|
| 166 | if self.qmin==None and self.qmax==None: |
---|
[ca6d914] | 167 | fx =numpy.asarray([fn(v) for v in x]) |
---|
[48882d1] | 168 | return (y - fx)/dy |
---|
| 169 | else: |
---|
| 170 | idx = (x>=self.qmin) & (x <= self.qmax) |
---|
[ca6d914] | 171 | fx = numpy.asarray([fn(item)for item in x[idx ]]) |
---|
[48882d1] | 172 | return (y[idx] - fx)/dy[idx] |
---|
[e71440c] | 173 | |
---|
[48882d1] | 174 | def residuals_deriv(self, model, pars=[]): |
---|
| 175 | """ |
---|
| 176 | @return residuals derivatives . |
---|
| 177 | @note: in this case just return empty array |
---|
| 178 | """ |
---|
| 179 | return [] |
---|
[b64fa56] | 180 | |
---|
| 181 | |
---|
[7d0c1a8] | 182 | class FitData1D(object): |
---|
| 183 | """ Wrapper class for SANS data """ |
---|
[b461b6d7] | 184 | def __init__(self,sans_data1d, smearer=None): |
---|
[7d0c1a8] | 185 | """ |
---|
| 186 | Data can be initital with a data (sans plottable) |
---|
| 187 | or with vectors. |
---|
[109e60ab] | 188 | |
---|
| 189 | self.smearer is an object of class QSmearer or SlitSmearer |
---|
| 190 | that will smear the theory data (slit smearing or resolution |
---|
| 191 | smearing) when set. |
---|
| 192 | |
---|
| 193 | The proper way to set the smearing object would be to |
---|
| 194 | do the following: |
---|
| 195 | |
---|
| 196 | from DataLoader.qsmearing import smear_selection |
---|
| 197 | fitdata1d = FitData1D(some_data) |
---|
| 198 | fitdata1d.smearer = smear_selection(some_data) |
---|
| 199 | |
---|
| 200 | Note that some_data _HAS_ to be of class DataLoader.data_info.Data1D |
---|
| 201 | |
---|
| 202 | Setting it back to None will turn smearing off. |
---|
| 203 | |
---|
[7d0c1a8] | 204 | """ |
---|
[b461b6d7] | 205 | |
---|
| 206 | self.smearer = smearer |
---|
| 207 | |
---|
[109e60ab] | 208 | # Initialize from Data1D object |
---|
[7d0c1a8] | 209 | self.data=sans_data1d |
---|
[72c7d31] | 210 | self.x= sans_data1d.x |
---|
| 211 | self.y= sans_data1d.y |
---|
| 212 | self.dx= sans_data1d.dx |
---|
| 213 | self.dy= sans_data1d.dy |
---|
[109e60ab] | 214 | |
---|
| 215 | ## Min Q-value |
---|
[4bd557d] | 216 | #Skip the Q=0 point, especially when y(q=0)=None at x[0]. |
---|
| 217 | if min (self.data.x) ==0.0 and self.data.x[0]==0 and not numpy.isfinite(self.data.y[0]): |
---|
[773806e] | 218 | self.qmin = min(self.data.x[self.data.x!=0]) |
---|
| 219 | else: |
---|
| 220 | self.qmin= min (self.data.x) |
---|
[109e60ab] | 221 | ## Max Q-value |
---|
[20d30e9] | 222 | self.qmax= max (self.data.x) |
---|
[058b2d7] | 223 | |
---|
[72c7d31] | 224 | # Range used for input to smearing |
---|
| 225 | self._qmin_unsmeared = self.qmin |
---|
| 226 | self._qmax_unsmeared = self.qmax |
---|
| 227 | |
---|
| 228 | |
---|
[20d30e9] | 229 | def setFitRange(self,qmin=None,qmax=None): |
---|
[7d0c1a8] | 230 | """ to set the fit range""" |
---|
[09975cbb] | 231 | # Skip Q=0 point, (especially for y(q=0)=None at x[0]). |
---|
[773806e] | 232 | #ToDo: Fix this. |
---|
[90db8e8] | 233 | if qmin==0.0 and not numpy.isfinite(self.data.y[qmin]): |
---|
[773806e] | 234 | self.qmin = min(self.data.x[self.data.x!=0]) |
---|
| 235 | elif qmin!=None: |
---|
| 236 | self.qmin = qmin |
---|
| 237 | |
---|
[eef2e0ed] | 238 | if qmax !=None: |
---|
| 239 | self.qmax = qmax |
---|
[72c7d31] | 240 | |
---|
| 241 | # Range used for input to smearing |
---|
| 242 | self._qmin_unsmeared = self.qmin |
---|
| 243 | self._qmax_unsmeared = self.qmax |
---|
| 244 | |
---|
| 245 | # Determine the range needed in unsmeared-Q to cover |
---|
| 246 | # the smeared Q range |
---|
| 247 | #TODO: use the smearing matrix to determine which |
---|
| 248 | # bin range to use |
---|
| 249 | if self.smearer.__class__.__name__ == 'SlitSmearer': |
---|
| 250 | self._qmin_unsmeared = min(self.data.x) |
---|
| 251 | self._qmax_unsmeared = max(self.data.x) |
---|
| 252 | elif self.smearer.__class__.__name__ == 'QSmearer': |
---|
| 253 | # Take 3 sigmas as the offset between smeared and unsmeared space |
---|
| 254 | try: |
---|
| 255 | offset = 3.0*max(self.smearer.width) |
---|
| 256 | self._qmin_unsmeared = max([min(self.data.x), self.qmin-offset]) |
---|
| 257 | self._qmax_unsmeared = min([max(self.data.x), self.qmax+offset]) |
---|
| 258 | except: |
---|
| 259 | logging.error("FitData1D.setFitRange: %s" % sys.exc_value) |
---|
| 260 | |
---|
[7d0c1a8] | 261 | |
---|
| 262 | def getFitRange(self): |
---|
| 263 | """ |
---|
| 264 | @return the range of data.x to fit |
---|
| 265 | """ |
---|
| 266 | return self.qmin, self.qmax |
---|
[72c7d31] | 267 | |
---|
[7d0c1a8] | 268 | def residuals(self, fn): |
---|
[72c7d31] | 269 | """ |
---|
| 270 | Compute residuals. |
---|
| 271 | |
---|
| 272 | If self.smearer has been set, use if to smear |
---|
| 273 | the data before computing chi squared. |
---|
| 274 | |
---|
| 275 | @param fn: function that return model value |
---|
| 276 | @return residuals |
---|
[109e60ab] | 277 | """ |
---|
[72c7d31] | 278 | x,y = [numpy.asarray(v) for v in (self.x,self.y)] |
---|
| 279 | if self.dy ==None or self.dy==[]: |
---|
| 280 | dy= numpy.zeros(len(y)) |
---|
| 281 | else: |
---|
| 282 | dy= numpy.asarray(self.dy) |
---|
| 283 | |
---|
| 284 | # For fitting purposes, replace zero errors by 1 |
---|
| 285 | #TODO: check validity for the rare case where only |
---|
| 286 | # a few points have zero errors |
---|
| 287 | dy[dy==0]=1 |
---|
[058b2d7] | 288 | |
---|
[72c7d31] | 289 | # Identify the bin range for the unsmeared and smeared spaces |
---|
| 290 | idx = (x>=self.qmin) & (x <= self.qmax) |
---|
| 291 | idx_unsmeared = (x>=self._qmin_unsmeared) & (x <= self._qmax_unsmeared) |
---|
| 292 | |
---|
[109e60ab] | 293 | # Compute theory data f(x) |
---|
[72c7d31] | 294 | fx= numpy.zeros(len(x)) |
---|
| 295 | |
---|
| 296 | _first_bin = None |
---|
| 297 | _last_bin = None |
---|
| 298 | for i_x in range(len(x)): |
---|
[d5b488b] | 299 | try: |
---|
[72c7d31] | 300 | if idx_unsmeared[i_x]==True: |
---|
| 301 | # Identify first and last bin |
---|
| 302 | #TODO: refactor this to pass q-values to the smearer |
---|
| 303 | # and let it figure out which bin range to use |
---|
| 304 | if _first_bin is None: |
---|
| 305 | _first_bin = i_x |
---|
| 306 | else: |
---|
| 307 | _last_bin = i_x |
---|
| 308 | |
---|
| 309 | value = fn(x[i_x]) |
---|
| 310 | fx[i_x] = value |
---|
[d5b488b] | 311 | except: |
---|
| 312 | ## skip error for model.run(x) |
---|
| 313 | pass |
---|
[72c7d31] | 314 | |
---|
[d5b488b] | 315 | ## Smear theory data |
---|
[109e60ab] | 316 | if self.smearer is not None: |
---|
[72c7d31] | 317 | fx = self.smearer(fx, _first_bin, _last_bin) |
---|
| 318 | |
---|
[d5b488b] | 319 | ## Sanity check |
---|
[72c7d31] | 320 | if numpy.size(dy)!= numpy.size(fx): |
---|
| 321 | raise RuntimeError, "FitData1D: invalid error array %d <> %d" % (numpy.size(dy), numpy.size(fx)) |
---|
[058b2d7] | 322 | |
---|
[72c7d31] | 323 | return (y[idx]-fx[idx])/dy[idx] |
---|
| 324 | |
---|
| 325 | |
---|
| 326 | |
---|
[7d0c1a8] | 327 | def residuals_deriv(self, model, pars=[]): |
---|
| 328 | """ |
---|
| 329 | @return residuals derivatives . |
---|
| 330 | @note: in this case just return empty array |
---|
| 331 | """ |
---|
| 332 | return [] |
---|
| 333 | |
---|
| 334 | |
---|
| 335 | class FitData2D(object): |
---|
| 336 | """ Wrapper class for SANS data """ |
---|
| 337 | def __init__(self,sans_data2d): |
---|
| 338 | """ |
---|
| 339 | Data can be initital with a data (sans plottable) |
---|
| 340 | or with vectors. |
---|
| 341 | """ |
---|
| 342 | self.data=sans_data2d |
---|
[415bc97] | 343 | self.image = sans_data2d.data |
---|
| 344 | self.err_image = sans_data2d.err_data |
---|
[d8a2e31] | 345 | self.x_bins_array= numpy.reshape(sans_data2d.x_bins, |
---|
| 346 | [1,len(sans_data2d.x_bins)]) |
---|
| 347 | self.y_bins_array = numpy.reshape(sans_data2d.y_bins, |
---|
| 348 | [len(sans_data2d.y_bins),1]) |
---|
| 349 | |
---|
| 350 | |
---|
| 351 | self.x_bins = sans_data2d.x_bins |
---|
| 352 | self.y_bins = sans_data2d.y_bins |
---|
[7d0c1a8] | 353 | |
---|
[20d30e9] | 354 | x = max(self.data.xmin, self.data.xmax) |
---|
| 355 | y = max(self.data.ymin, self.data.ymax) |
---|
| 356 | |
---|
| 357 | ## fitting range |
---|
[773806e] | 358 | self.qmin = 1e-16 |
---|
[20d30e9] | 359 | self.qmax = math.sqrt(x*x +y*y) |
---|
[70bf68c] | 360 | ## new error image for fitting purpose |
---|
| 361 | if self.err_image== None or self.err_image ==[]: |
---|
| 362 | self.res_err_image= numpy.zeros(len(self.y_bins),len(self.x_bins)) |
---|
| 363 | else: |
---|
| 364 | self.res_err_image = copy.deepcopy(self.err_image) |
---|
| 365 | self.res_err_image[self.err_image==0]=1 |
---|
[d8a2e31] | 366 | |
---|
| 367 | self.radius= numpy.sqrt(self.x_bins_array**2 + self.y_bins_array**2) |
---|
| 368 | self.index_model = (self.qmin <= self.radius)&(self.radius<= self.qmax) |
---|
[7d0c1a8] | 369 | |
---|
[20d30e9] | 370 | |
---|
| 371 | def setFitRange(self,qmin=None,qmax=None): |
---|
[7d0c1a8] | 372 | """ to set the fit range""" |
---|
[773806e] | 373 | if qmin==0.0: |
---|
| 374 | self.qmin = 1e-16 |
---|
| 375 | elif qmin!=None: |
---|
| 376 | self.qmin = qmin |
---|
[eef2e0ed] | 377 | if qmax!=None: |
---|
| 378 | self.qmax= qmax |
---|
[20d30e9] | 379 | |
---|
[7d0c1a8] | 380 | |
---|
| 381 | def getFitRange(self): |
---|
| 382 | """ |
---|
| 383 | @return the range of data.x to fit |
---|
| 384 | """ |
---|
[20d30e9] | 385 | return self.qmin, self.qmax |
---|
[7d0c1a8] | 386 | |
---|
[d8a2e31] | 387 | def residuals(self, fn): |
---|
| 388 | try: |
---|
| 389 | res=self.index_model*(self.image - fn([self.y_bins_array, |
---|
| 390 | self.x_bins_array]))/self.res_err_image |
---|
| 391 | return res.ravel() |
---|
| 392 | except: |
---|
| 393 | print "Using old residual method" |
---|
| 394 | return self.old_residuals( fn) |
---|
| 395 | |
---|
| 396 | |
---|
| 397 | def old_residuals(self, fn): |
---|
[7d0c1a8] | 398 | """ @param fn: function that return model value |
---|
| 399 | @return residuals |
---|
| 400 | """ |
---|
| 401 | res=[] |
---|
[70bf68c] | 402 | |
---|
[fff74cb] | 403 | for i in range(len(self.x_bins)): |
---|
| 404 | for j in range(len(self.y_bins)): |
---|
| 405 | temp = math.pow(self.data.x_bins[i],2)+math.pow(self.data.y_bins[j],2) |
---|
| 406 | radius= math.sqrt(temp) |
---|
[20d30e9] | 407 | if self.qmin <= radius and radius <= self.qmax: |
---|
| 408 | res.append( (self.image[j][i]- fn([self.x_bins[i],self.y_bins[j]]))\ |
---|
[70bf68c] | 409 | /self.res_err_image[j][i] ) |
---|
[0e51519] | 410 | |
---|
| 411 | return numpy.array(res) |
---|
| 412 | |
---|
| 413 | |
---|
[7d0c1a8] | 414 | def residuals_deriv(self, model, pars=[]): |
---|
| 415 | """ |
---|
| 416 | @return residuals derivatives . |
---|
| 417 | @note: in this case just return empty array |
---|
| 418 | """ |
---|
| 419 | return [] |
---|
[48882d1] | 420 | |
---|
[4bd557d] | 421 | class FitAbort(Exception): |
---|
| 422 | """ |
---|
| 423 | Exception raise to stop the fit |
---|
| 424 | """ |
---|
| 425 | print"Creating fit abort Exception" |
---|
| 426 | |
---|
| 427 | |
---|
[70bf68c] | 428 | class SansAssembly: |
---|
[ca6d914] | 429 | """ |
---|
| 430 | Sans Assembly class a class wrapper to be call in optimizer.leastsq method |
---|
| 431 | """ |
---|
[4bd557d] | 432 | def __init__(self,paramlist,Model=None , Data=None, curr_thread= None): |
---|
[ca6d914] | 433 | """ |
---|
| 434 | @param Model: the model wrapper fro sans -model |
---|
| 435 | @param Data: the data wrapper for sans data |
---|
| 436 | """ |
---|
| 437 | self.model = Model |
---|
| 438 | self.data = Data |
---|
[e71440c] | 439 | self.paramlist=paramlist |
---|
[4bd557d] | 440 | self.curr_thread= curr_thread |
---|
[ca6d914] | 441 | self.res=[] |
---|
[4bd557d] | 442 | self.func_name="Functor" |
---|
[48882d1] | 443 | def chisq(self, params): |
---|
| 444 | """ |
---|
| 445 | Calculates chi^2 |
---|
| 446 | @param params: list of parameter values |
---|
| 447 | @return: chi^2 |
---|
| 448 | """ |
---|
| 449 | sum = 0 |
---|
| 450 | for item in self.res: |
---|
| 451 | sum += item*item |
---|
[4bd557d] | 452 | if len(self.res)==0: |
---|
| 453 | return None |
---|
[26cb768] | 454 | return sum/ len(self.res) |
---|
[20d30e9] | 455 | |
---|
[48882d1] | 456 | def __call__(self,params): |
---|
[ca6d914] | 457 | """ |
---|
| 458 | Compute residuals |
---|
| 459 | @param params: value of parameters to fit |
---|
| 460 | """ |
---|
[681f0dc] | 461 | #import thread |
---|
[e71440c] | 462 | self.model.setParams(self.paramlist,params) |
---|
[48882d1] | 463 | self.res= self.data.residuals(self.model.eval) |
---|
[24b8d5c] | 464 | #if self.curr_thread != None : |
---|
| 465 | # try: |
---|
| 466 | # self.curr_thread.isquit() |
---|
| 467 | # except: |
---|
| 468 | # raise FitAbort,"stop leastsqr optimizer" |
---|
[48882d1] | 469 | return self.res |
---|
| 470 | |
---|
[4c718654] | 471 | class FitEngine: |
---|
[ee5b04c] | 472 | def __init__(self): |
---|
[ca6d914] | 473 | """ |
---|
| 474 | Base class for scipy and park fit engine |
---|
| 475 | """ |
---|
| 476 | #List of parameter names to fit |
---|
[ee5b04c] | 477 | self.paramList=[] |
---|
[ca6d914] | 478 | #Dictionnary of fitArrange element (fit problems) |
---|
| 479 | self.fitArrangeDict={} |
---|
| 480 | |
---|
[4c718654] | 481 | def _concatenateData(self, listdata=[]): |
---|
| 482 | """ |
---|
| 483 | _concatenateData method concatenates each fields of all data contains ins listdata. |
---|
| 484 | @param listdata: list of data |
---|
[ca6d914] | 485 | @return Data: Data is wrapper class for sans plottable. it is created with all parameters |
---|
| 486 | of data concatenanted |
---|
[4c718654] | 487 | @raise: if listdata is empty will return None |
---|
| 488 | @raise: if data in listdata don't contain dy field ,will create an error |
---|
| 489 | during fitting |
---|
| 490 | """ |
---|
[109e60ab] | 491 | #TODO: we have to refactor the way we handle data. |
---|
| 492 | # We should move away from plottables and move towards the Data1D objects |
---|
| 493 | # defined in DataLoader. Data1D allows data manipulations, which should be |
---|
| 494 | # used to concatenate. |
---|
| 495 | # In the meantime we should switch off the concatenation. |
---|
| 496 | #if len(listdata)>1: |
---|
| 497 | # raise RuntimeError, "FitEngine._concatenateData: Multiple data files is not currently supported" |
---|
| 498 | #return listdata[0] |
---|
| 499 | |
---|
[4c718654] | 500 | if listdata==[]: |
---|
| 501 | raise ValueError, " data list missing" |
---|
| 502 | else: |
---|
| 503 | xtemp=[] |
---|
| 504 | ytemp=[] |
---|
| 505 | dytemp=[] |
---|
[48882d1] | 506 | self.mini=None |
---|
| 507 | self.maxi=None |
---|
[4c718654] | 508 | |
---|
[7d0c1a8] | 509 | for item in listdata: |
---|
| 510 | data=item.data |
---|
[48882d1] | 511 | mini,maxi=data.getFitRange() |
---|
| 512 | if self.mini==None and self.maxi==None: |
---|
| 513 | self.mini=mini |
---|
| 514 | self.maxi=maxi |
---|
| 515 | else: |
---|
| 516 | if mini < self.mini: |
---|
| 517 | self.mini=mini |
---|
| 518 | if self.maxi < maxi: |
---|
| 519 | self.maxi=maxi |
---|
| 520 | |
---|
| 521 | |
---|
[4c718654] | 522 | for i in range(len(data.x)): |
---|
| 523 | xtemp.append(data.x[i]) |
---|
| 524 | ytemp.append(data.y[i]) |
---|
| 525 | if data.dy is not None and len(data.dy)==len(data.y): |
---|
| 526 | dytemp.append(data.dy[i]) |
---|
| 527 | else: |
---|
[ee5b04c] | 528 | raise RuntimeError, "Fit._concatenateData: y-errors missing" |
---|
[20d30e9] | 529 | data= Data(x=xtemp,y=ytemp,dy=dytemp) |
---|
[48882d1] | 530 | data.setFitRange(self.mini, self.maxi) |
---|
| 531 | return data |
---|
[ca6d914] | 532 | |
---|
| 533 | |
---|
| 534 | def set_model(self,model,Uid,pars=[]): |
---|
| 535 | """ |
---|
| 536 | set a model on a given uid in the fit engine. |
---|
| 537 | @param model: the model to fit |
---|
| 538 | @param Uid :is the key of the fitArrange dictionnary where model is saved as a value |
---|
| 539 | @param pars: the list of parameters to fit |
---|
| 540 | @note : pars must contains only name of existing model's paramaters |
---|
| 541 | """ |
---|
[f44dbc7] | 542 | if len(pars) >0: |
---|
[6831a99] | 543 | if model==None: |
---|
[f44dbc7] | 544 | raise ValueError, "AbstractFitEngine: Specify parameters to fit" |
---|
[6831a99] | 545 | else: |
---|
[aed7c57] | 546 | temp=[] |
---|
[ca6d914] | 547 | for item in pars: |
---|
| 548 | if item in model.model.getParamList(): |
---|
[aed7c57] | 549 | temp.append(item) |
---|
[ca6d914] | 550 | self.paramList.append(item) |
---|
| 551 | else: |
---|
| 552 | raise ValueError,"wrong paramter %s used to set model %s. Choose\ |
---|
| 553 | parameter name within %s"%(item, model.model.name,str(model.model.getParamList())) |
---|
| 554 | return |
---|
[6831a99] | 555 | #A fitArrange is already created but contains dList only at Uid |
---|
[ca6d914] | 556 | if self.fitArrangeDict.has_key(Uid): |
---|
| 557 | self.fitArrangeDict[Uid].set_model(model) |
---|
[aed7c57] | 558 | self.fitArrangeDict[Uid].pars= pars |
---|
[6831a99] | 559 | else: |
---|
| 560 | #no fitArrange object has been create with this Uid |
---|
[48882d1] | 561 | fitproblem = FitArrange() |
---|
[6831a99] | 562 | fitproblem.set_model(model) |
---|
[aed7c57] | 563 | fitproblem.pars= pars |
---|
[ca6d914] | 564 | self.fitArrangeDict[Uid] = fitproblem |
---|
[aed7c57] | 565 | |
---|
[d4b0687] | 566 | else: |
---|
[6831a99] | 567 | raise ValueError, "park_integration:missing parameters" |
---|
[48882d1] | 568 | |
---|
[20d30e9] | 569 | def set_data(self,data,Uid,smearer=None,qmin=None,qmax=None): |
---|
[d4b0687] | 570 | """ Receives plottable, creates a list of data to fit,set data |
---|
| 571 | in a FitArrange object and adds that object in a dictionary |
---|
| 572 | with key Uid. |
---|
| 573 | @param data: data added |
---|
| 574 | @param Uid: unique key corresponding to a fitArrange object with data |
---|
[ca6d914] | 575 | """ |
---|
[f2817bb] | 576 | if data.__class__.__name__=='Data2D': |
---|
[f8ce013] | 577 | fitdata=FitData2D(data) |
---|
| 578 | else: |
---|
[b461b6d7] | 579 | fitdata=FitData1D(data, smearer) |
---|
[20d30e9] | 580 | |
---|
| 581 | fitdata.setFitRange(qmin=qmin,qmax=qmax) |
---|
[d4b0687] | 582 | #A fitArrange is already created but contains model only at Uid |
---|
[ca6d914] | 583 | if self.fitArrangeDict.has_key(Uid): |
---|
[f8ce013] | 584 | self.fitArrangeDict[Uid].add_data(fitdata) |
---|
[d4b0687] | 585 | else: |
---|
| 586 | #no fitArrange object has been create with this Uid |
---|
| 587 | fitproblem= FitArrange() |
---|
[f8ce013] | 588 | fitproblem.add_data(fitdata) |
---|
[ca6d914] | 589 | self.fitArrangeDict[Uid]=fitproblem |
---|
[20d30e9] | 590 | |
---|
[d4b0687] | 591 | def get_model(self,Uid): |
---|
| 592 | """ |
---|
| 593 | @param Uid: Uid is key in the dictionary containing the model to return |
---|
| 594 | @return a model at this uid or None if no FitArrange element was created |
---|
| 595 | with this Uid |
---|
| 596 | """ |
---|
[ca6d914] | 597 | if self.fitArrangeDict.has_key(Uid): |
---|
| 598 | return self.fitArrangeDict[Uid].get_model() |
---|
[d4b0687] | 599 | else: |
---|
| 600 | return None |
---|
| 601 | |
---|
| 602 | def remove_Fit_Problem(self,Uid): |
---|
| 603 | """remove fitarrange in Uid""" |
---|
[ca6d914] | 604 | if self.fitArrangeDict.has_key(Uid): |
---|
| 605 | del self.fitArrangeDict[Uid] |
---|
[a9e04aa] | 606 | |
---|
| 607 | def select_problem_for_fit(self,Uid,value): |
---|
| 608 | """ |
---|
| 609 | select a couple of model and data at the Uid position in dictionary |
---|
| 610 | and set in self.selected value to value |
---|
| 611 | @param value: the value to allow fitting. can only have the value one or zero |
---|
| 612 | """ |
---|
| 613 | if self.fitArrangeDict.has_key(Uid): |
---|
| 614 | self.fitArrangeDict[Uid].set_to_fit( value) |
---|
[eef2e0ed] | 615 | |
---|
| 616 | |
---|
[a9e04aa] | 617 | def get_problem_to_fit(self,Uid): |
---|
| 618 | """ |
---|
| 619 | return the self.selected value of the fit problem of Uid |
---|
| 620 | @param Uid: the Uid of the problem |
---|
| 621 | """ |
---|
| 622 | if self.fitArrangeDict.has_key(Uid): |
---|
| 623 | self.fitArrangeDict[Uid].get_to_fit() |
---|
[4c718654] | 624 | |
---|
[d4b0687] | 625 | class FitArrange: |
---|
| 626 | def __init__(self): |
---|
| 627 | """ |
---|
| 628 | Class FitArrange contains a set of data for a given model |
---|
| 629 | to perform the Fit.FitArrange must contain exactly one model |
---|
| 630 | and at least one data for the fit to be performed. |
---|
| 631 | model: the model selected by the user |
---|
| 632 | Ldata: a list of data what the user wants to fit |
---|
| 633 | |
---|
| 634 | """ |
---|
| 635 | self.model = None |
---|
| 636 | self.dList =[] |
---|
[aed7c57] | 637 | self.pars=[] |
---|
[a9e04aa] | 638 | #self.selected is zero when this fit problem is not schedule to fit |
---|
| 639 | #self.selected is 1 when schedule to fit |
---|
| 640 | self.selected = 0 |
---|
[d4b0687] | 641 | |
---|
| 642 | def set_model(self,model): |
---|
| 643 | """ |
---|
| 644 | set_model save a copy of the model |
---|
| 645 | @param model: the model being set |
---|
| 646 | """ |
---|
| 647 | self.model = model |
---|
| 648 | |
---|
| 649 | def add_data(self,data): |
---|
| 650 | """ |
---|
| 651 | add_data fill a self.dList with data to fit |
---|
| 652 | @param data: Data to add in the list |
---|
| 653 | """ |
---|
| 654 | if not data in self.dList: |
---|
| 655 | self.dList.append(data) |
---|
| 656 | |
---|
| 657 | def get_model(self): |
---|
| 658 | """ @return: saved model """ |
---|
| 659 | return self.model |
---|
| 660 | |
---|
| 661 | def get_data(self): |
---|
| 662 | """ @return: list of data dList""" |
---|
[7d0c1a8] | 663 | #return self.dList |
---|
| 664 | return self.dList[0] |
---|
[d4b0687] | 665 | |
---|
| 666 | def remove_data(self,data): |
---|
| 667 | """ |
---|
| 668 | Remove one element from the list |
---|
| 669 | @param data: Data to remove from dList |
---|
| 670 | """ |
---|
| 671 | if data in self.dList: |
---|
| 672 | self.dList.remove(data) |
---|
[a9e04aa] | 673 | def set_to_fit (self, value=0): |
---|
| 674 | """ |
---|
| 675 | set self.selected to 0 or 1 for other values raise an exception |
---|
| 676 | @param value: integer between 0 or 1 |
---|
| 677 | """ |
---|
| 678 | self.selected= value |
---|
| 679 | |
---|
| 680 | def get_to_fit(self): |
---|
| 681 | """ |
---|
| 682 | @return self.selected value |
---|
| 683 | """ |
---|
| 684 | return self.selected |
---|