reflectometry.model1d.model.dataLoader

1 # This program is public domain. 2 3 import numpy 4 from copy import deepcopy 5 from random import normalvariate 6 from calcRefl import fixedres, varyingres 7 from auxs import readdata, takelist, ravel 8 9

10 -class FixedResolution:

11 - def __init__(self, dLoL, dT):

12 self.dLoL = dLoL 13 self.dT = dT

14

15 - def calc_dQ(self, L, theQs):

16 return fixedres(L, self.dLoL, self.dT, theQs)

17 18

19 -class VaryingResolution:

20 - def __init__(self, dLoL, dToT):

21 self.dLoL = dLoL 22 self.dToT = dToT

23

24 - def calc_dQ(self, L, theQs):

25 return varyingres(L, self.dLoL, self.dToT, theQs)

26 27 28

29 -class Data:

30 - def __init__(self,filename=None):

31 if filename != None: 32 self.read(filename) 33 self.A = None 34 self.Rform = 'magnitude' 35 self.background = 0.0 36 self.wavelength = 1.54 37 self.resolution = FixedResolution(0.0, 0.0) 38 self.columns = None 39 self.Q = numpy.arange(0.0, 1.0, 0.001) 40 self.R = None 41 self.dQ = None 42 self.dR = None 43 self.selected_points = None 44 self.calcQset = None # None means no oversampling so just use self.fitQ 45 self.name = None 46 #the following are just to get the right defaults 47 self.Qlo = 0.0 48 self.Qhi = 1.0 49 self.Qskip = 0.001 50 self.calcres()

51

52 - def get_num_fitQs(self):

53 return len(self.get_fitQ())

54

55 - def get_fitQ(self):

56 if(self.Q == None): return None 57 else: return numpy.take(self.Q, self.get_selected_points())

58

59 - def get_fitR(self):

60 if(self.R == None): return None 61 else: return numpy.take(self.R, self.get_selected_points())

62

63 - def get_fitdQ(self):

64 if(self.dQ == None): return None 65 else: return numpy.take(self.dQ,self.get_selected_points())

66

67 - def get_fitdR(self):

68 if(self.dR == None): return None 69 else: return numpy.take(self.dR,self.get_selected_points())

70

71 - def get_calcQ(self):

72 if(self.isempty()): return self.Q.copy() 73 elif(self.calcQset == None): return self.get_fitQ() 74 else: return self.calcQset.copy()

75

76 - def get_selected_points(self):

77 if(self.selected_points == None): return numpy.arange(len(self.Q)) 78 else: return self.selected_points

79

80 - def set_background(self, val):

81 self.background = val

82

83 - def isempty(self):

84 return self.A == None

85 86

87 - def read_data(self, inlines ):

88 lines = inlines.split('\n') 89 data = [] 90 for text in lines: 91 if text[0] == '#': continue 92 data.append([float(value) for value in text.split()]) 93 return numpy.array(data)

94 95

96 - def load_inline(self, inlines ):

97 """Load data from inline data""" 98 self.A = None 99 self.file = "" 100 A = self.read_data( inlines) 101 columns = A.shape[1] 102 if columns == 2: 103 self.columns = ['Q','R'] 104 self.Q = A[:,0] 105 self.R = A[:,1] 106 self.dQ = None 107 self.dR = None 108 elif columns == 3: 109 self.columns = ['Q','R','dR'] 110 self.Q = A[:,0] 111 self.dQ = None 112 self.R = A[:,1] 113 self.dR = A[:,2] 114 elif columns == 4: 115 self.columns = ['Q','dQ','R','dR'] 116 self.Q = A[:,0] 117 self.dQ = A[:,1] 118 self.R = A[:,2] 119 self.dR = A[:,3] 120 elif columns == 5: 121 self.columns = ['Q','dQ','R','dR','L'] 122 self.Q = A[:,0] 123 self.dQ = A[:,1] 124 self.R = A[:,2] 125 self.dR = A[:,3] 126 self.L = A[:,4] # FIXME, it is wavelength, later we maybe use it 127 128 self.A = A 129 self.file = '' 130 self.name = '' 131 self.points_selected = numpy.arange(len(self.Q)) 132 self.dRdata = self.dR 133 self.calcres()

134 135

136 - def load(self,filename):

137 """Load data from filename""" 138 self.A = None 139 self.file = "" 140 A = readdata(filename) 141 columns = A.shape[1] 142 if columns == 2: 143 self.columns = ['Q','R'] 144 self.Q = A[:,0] 145 self.R = A[:,1] 146 self.dQ = None 147 self.dR = None 148 elif columns == 3: 149 self.columns = ['Q','R','dR'] 150 self.Q = A[:,0] 151 self.dQ = None 152 self.R = A[:,1] 153 self.dR = A[:,2] 154 elif columns == 4: 155 self.columns = ['Q','dQ','R','dR'] 156 self.Q = A[:,0] 157 self.dQ = A[:,1] 158 self.R = A[:,2] 159 self.dR = A[:,3] 160 elif columns == 5: 161 self.columns = ['Q','dQ','R','dR','L'] 162 self.Q = A[:,0] 163 self.dQ = A[:,1] 164 self.R = A[:,2] 165 self.dR = A[:,3] 166 self.L = A[:,4] # FIXME, it is wavelength, later we maybe use it 167 168 self.A = A 169 self.file = filename 170 self.name = filename 171 self.points_selected = numpy.arange(len(self.Q)) 172 self.dRdata = self.dR 173 self.calcres()

174 175

176 - def fresnelweight(self,model):

177 self.dR = model.fresnel(self.Q)

178

179 - def Q4weight(self):

180 self.dR = self.Q**-4

181

182 - def logweight(self):

183 self.dR = 0.01*self.R

184

185 - def dataweight(self):

186 self.dR = self.dRdata

187

188 - def fixedres(self,dLoL,dT):

189 self.resolution = FixedResolution(dLoL,dT) 190 self.calcres()

191

192 - def varyingres(self,dLoL,dToT):

193 self.resolution = VaryingResolution(dLoL,dToT) 194 self.calcres()

195

196 - def FixVaryingres(self, dLoL, dT1, dT2, dToT, Q1, Q2):

197 self.resolution1 = FixedResolution(dLoL,dT1) 198 self.resolution2 = FixedResolution(dLoL,dT2) 199 self.resolution3 = VaryingResolution(dLoL,dToT) 200 self.calcmixres(Q1,Q2)

201

202 - def genericres(self,resobj):

203 self.resolution = resobj 204 self.calcres()

205

206 - def set_wavelength(self, x):

207 self.wavelength = x 208 self.calcres()

209

210 - def resample(self):

211 newData = deepcopy(self) 212 for x in numpy.arange(len(newData.fitR)): 213 newData.fitR[x] = normalvariate(self.fitR[x], self.fitdR[x]) 214 return newData

215

216 - def get_default_range(self):

217 return (self.Qlo, self.Qhi, self.Qskip)

218 219

220 - def calcres(self):

221 self.dQ = self.resolution.calc_dQ(self.wavelength, self.Q)

222 223

224 - def calcmixres(self, Q1, Q2):

225 _Q1 = self.Q.take( numpy.where( self.Q <= Q1 ) )[0] 226 _Q2 = self.Q.take( numpy.where( self.Q > Q2 ) )[0] 227 _Q3 = self.Q.take( numpy.where( (self.Q <= Q2)&(self.Q>Q1) ) )[0] 228 _dQ1 = self.resolution1.calc_dQ(self.wavelength, _Q1 ) 229 _dQ2 = self.resolution2.calc_dQ(self.wavelength, _Q2 ) 230 _dQ3 = self.resolution3.calc_dQ(self.wavelength, _Q3 ) 231 self.dQ = numpy.concatenate( (_dQ1, _dQ3, _dQ2) ) 232 assert( len(self.dQ) == len(self.Q) )

233 234

235 - def get_dQ_for_qval(self, qval):

236 return self.dQ

237 #return self.resolution.calc_dQ(self.wavelength, qval) 238 239 240 241 242

243 -class DataSet:

244 """Support for polarized data"""

245 - def __init__(self, 246 filenames=None, 247 num_datasets = 4, 248 dataset_names = ["A (--)", "B (-+)", "C (+-)", "D (++)"] 249 ):

250 """Multidata(basenameA, num_sets, setnames, window=None) 251 Load A,B,C,D cross sections of polarized data from files named 252 basenameA, basenameB, basenameC and basenameD.""" 253 self.datasets = [ Data() for x in range(num_datasets)] 254 self.dataset_names = dataset_names 255 self.wfresnel = False 256 self.wq4 = False 257 self.wlog = False 258 self.wdata = False 259 if(filenames != None): 260 self.load_all(filenames) 261 self.num_datasets = num_datasets

262 263

264 - def isempty(self):

265 """Return true if there is no data [only checks in A]""" 266 return self.datasets[0].isempty()

267 268

269 - def get_num_datasets(self):

270 return self.num_datasets

271

272 - def get_num_fitQs(self, datasets=None):

273 if(datasets == None): 274 return len( ravel(self.get_fitQs())) 275 else: 276 return len( ravel( takelist(self.get_fitQs(), datasets)))

277

278 - def get_Rform(self):

279 return self.datasets[0].Rform

280

281 - def get_background(self):

282 return self.datasets[0].background

283

284 - def set_background(self, val):

285 for x in self.datasets: 286 x.set_background(val)

287

288 - def get_wavelength(self):

289 return self.datasets[0].wavelength

290

291 - def set_wavelength(self, x):

292 for dataset in self.datasets: 293 dataset.set_wavelength(x)

294

295 - def get_fitQs(self):

296 retVal = [] 297 for x in self.datasets: 298 retVal += [x.get_fitQ()] 299 return retVal

300

301 - def get_fitRs(self):

302 retVal = [] 303 for x in self.datasets: 304 retVal += [x.get_fitR()] 305 return retVal

306

307 - def get_fitdQs(self):

308 return self.get_dQs_for_qvals(self.get_fitQs())

309

310 - def get_fitdRs(self):

311 retVal = [] 312 for x in self.datasets: 313 retVal += [x.get_fitdR()] 314 return retVal

315

316 - def get_calcQs(self):

317 retVal = [] 318 for x in self.datasets: 319 retVal += [x.get_calcQ()] 320 return retVal

321

322 - def get_Qs(self):

323 retVal = [] 324 for x in self.datasets: 325 retVal += [x.Q] 326 return retVal

327

328 - def get_Rs(self):

329 retVal = [] 330 for x in self.datasets: 331 retVal += [x.R] 332 return retVal

333

334 - def get_dQs(self):

335 retVal = [] 336 for x in self.datasets: 337 retVal += [x.dQ] 338 return retVal

339

340 - def get_dRs(self):

341 retVal = [] 342 for x in self.datasets: 343 retVal += [x.dR] 344 return retVal

345

346 - def get_dQs_for_qvals(self, qvals):

347 # gets the dQs associated with a given set of Q values 348 retVal = [] 349 for x in range(self.get_num_datasets()): 350 retVal += [(self.datasets[x].get_dQ_for_qval(qvals[x]))] 351 return retVal

352

353 - def set_rform(self, value):

354 for dataset in self.datasets: 355 dataset.Rform = value

356 357

358 - def isempty(self):

359 return self.datasets[0].isempty()

360 361

362 - def load_file(self, file):

363 if(self.num_datasets == 4): 364 x = file[:-1] 365 if(file[-1] == 'A'): 366 self.load_all([x+'A', x+'B', x+'C', x+'D']) 367 if(file[-1] == 'a'): 368 self.load_all([x+'a', x+'b', x+'c', x+'d']) 369 elif(self.num_datasets == 1): 370 self.load_all([file]) 371 else: 372 raise NotImplementedError

373 374

375 - def load_inline(self, inlineRawData):

376 RawData = inlineRawData.strip().split('#') 377 if len(RawData) == 1: 378 379 self.load_all_inline([ RawData[0].strip() ]) 380 381 elif len(RawData) == 4: 382 self.load_all_inline([ RawData[0].strip(), 383 RawData[1].strip(), 384 RawData[2].strip(), 385 RawData[3].strip() ]) 386 else: 387 import sys 388 print "Error format in inline" 389 sys.exit()

390 391

392 - def load(self, filename, index):

393 self.datasets[index].load(filename)

394 395

396 - def load_all(self, filenames):

397 for x in range(len(filenames)): 398 self.datasets[x].load(filenames[x])

399 400 401

402 - def load_all_inline(self, strlists):

403 for x in range(len(strlists)): 404 self.datasets[x].load_inline(strlists[x])

405 406 407 # Functions that are broadcast to all datasets

408 - def fresnelweight(self):

409 for x in self.datasets: 410 x.fresnelweight() 411 self.wfresnel = True 412 self.wq4 = False 413 self.wlog = False 414 self.wdata = False

415 416

417 - def Q4weight(self):

418 for x in self.datasets: 419 x.Q4weight() 420 self.wfresnel = False 421 self.wq4 = True 422 self.wlog = False 423 self.wdata = False

424 425

426 - def logweight(self):

427 for x in self.datasets: 428 x.logweight() 429 self.wfresnel = False 430 self.wq4 = False 431 self.wlog = True 432 self.wdata = False

433 434

435 - def dataweight(self):

436 for x in self.datasets: 437 x.dataweight() 438 self.wfresnel = False 439 self.wq4 = False 440 self.wlog = False 441 self.wdata = True

442 443

444 - def fixedres(self, dLoL, dT):

445 for x in self.datasets: 446 x.fixedres(dLoL, dT)

447 448

449 - def varyingres(self, dLoL, dToT):

450 for x in self.datasets: 451 x.varyingres(dLoL, dToT)

452 453

454 - def FixVaryingres(self, dLoL, dT1, dT2, dToT, Q1, Q2):

455 for x in self.datasets: 456 x.FixVaryingres(dLoL, dT1, dT2, dToT, Q1, Q2)

457 458

459 - def genericres(self, resobj):

460 for x in self.datasets: 461 x.genericres(resobj)

462 463

464 - def GetResolution(self):

465 return self.datasets[0].resolution()

466 467

468 - def resample(self):

469 # need to temporarily get rid of window since deepcopy doesn't work on windows 470 temp = self.window 471 self.window = None 472 newData = deepcopy(self) 473 self.window = temp 474 for dataset in newData.datasets: 475 for x in range(len(dataset.R)): 476 dataset.R[x] = normalvariate(dataset.R[x], dataset.dR[x]) 477 return newData

478

Source Code for Module reflectometry.model1d.model.dataLoader