reflectometry.model1d.profileview.parseReflModel

1 from xml.dom import minidom 2 from xml.dom.minidom import getDOMImplementation as getDOMImp 3 from reflectometry.model1d.model.auxs import readdata, isString, \ 4 isvector, isfactory, isscientific, AFloat, tFloat 5 6

7 -class xmlData:

8 """ 9 This class just get Multiplexor xml information from xml String 10 or xml file. 11 Later time, we maybe extend to get DataSet information, etc 12 """

13 - def __init__(self, 14 xmlU, 15 magnetic=False 16 ):

17 18 self.magnetic = magnetic 19 self.xmlU = xmlU 20 self.xmldoc = self.xmlU.getUniplexorXML() 21 self.data = self.xmldoc.getElementsByTagName('Data') 22 self.datafile= self.data[0].getAttribute('Name') 23 #print self.datafile 24 self.setNameAtr() 25 if self.datafile.lower() != "inline": 26 self.setData() 27 if self.datafile.lower().strip() == "build": 28 self.setData_Inline()

29 30

31 - def getXOR(self):

32 return self.XOR

33 34

35 - def getData(self):

36 return self.data

37 38

39 - def getNData(self):

40 return len(self.data)

41 42

43 - def setNameAtr(self):

44 d = self.getData()[0] 45 d.setAttribute('Name','inline')

46 47 48

49 - def setData(self):

50 xdoc = getDOMImp().createDocument(None, "Notitle", None) 51 doc = self.getData()[0] 52 if not self.magnetic: 53 data = readdata( self.datafile ) 54 doc = self.getData()[0] 55 doc.appendChild( xdoc.createTextNode( data) ) 56 else: 57 if self.datafile[-1] =='A': endCC = ['A','B','C','D'] 58 else: endCC = ['a','b','c','d'] 59 for i in range(4): 60 data = readdata( self.datafile[:-1]+endCC[i] ) 61 if i < 3 : 62 data += '#' 63 doc.appendChild( xdoc.createTextNode( data) )

64 65 66

67 - def setData_Inline(self):

68 #print "THH" 69 xdoc = getDOMImp().createDocument(None, "Notitle", None) 70 doc = self.getData()[0] 71 doc.appendChild( xdoc.createTextNode( self._dataStr ) )

72 73 74

75 -def uor2uor( xmlu ):

76 77 u = xmlData( xmlu, xmlu.getMagnetic() ) 78 return u.xmlU

79 80 81 #==============================================================

82 -class xmlFit:

83

84 - def __init__(self):

85 self.xdoc = getDOMImp().createDocument(None, "FIT", None) 86 self.root_el = self.xdoc.documentElement #root elements 87 comm = self.xdoc.createComment("Name is the user visible name") 88 self.root_el.appendChild(comm)

89 #self.Remove_a_Par() 90

91 - def Add_a_Par(self, 92 str_name, 93 low, 94 high 95 ):

96 el = self.xdoc.createElement("p") 97 el.setAttribute("Name", str_name) 98 el.setAttribute("Low", str(low) ) 99 el.setAttribute("High", str(high) ) 100 101 self.root_el.appendChild(el)

102 103

104 - def Remove_a_Par(self, name):

105 cNs = self.root_el.getElementsByTagName( "p") 106 for i in range(len(cNs)): 107 n = cNs[i].getAttribute("Name") 108 if n==name: 109 self.root_el.removeChild( cNs[i] ) 110 break

111 112

113 - def Add_blank_line(self):

114 self.root_el.appendChild( self.xdoc.createTextNode('') )

115 116

117 - def addFitPar(self, i, Dict, ModelID, pname):

118 name = Dict[i]["name"]; q= Dict[i][pname] 119 if isString( q ): 120 pass 121 elif isvector( q ): 122 123 n = ModelID + ".L("+ name + ")." + pname 124 if len(q) == 3: 125 self.Add_a_Par( n, q[0], q[2] ) 126 else: 127 self.Add_a_Par( n, q[0], q[1] ) 128 elif isfactory( q ): 129 r = AFloat( q ) 130 if len(r[0]) == 2: 131 n = ModelID + ".L("+ name + ")." + pname+".left" 132 self.Add_a_Par( n, r[1][0], r[2][0] ) 133 n = ModelID + ".L("+ name + ")." + pname+".right" 134 self.Add_a_Par( n, r[1][1], r[2][1] ) 135 else: 136 for j in range( len(r[0]) ): 137 n = ModelID + ".L("+ name + ")." + pname+".rho_"+str(j) 138 self.Add_a_Par( n, r[1][j], r[2][j] ) 139 140 elif isscientific( q ): 141 p = str( q ) 142 listp = p.strip()[:-1].split('(') 143 p1 = listp[0].strip(); p2 = listp[1].strip(); 144 if p2[-1] == "%": 145 p2 = p2[:-1] 146 Low = float(p1) - float(p1)*float(p2)/100.0 147 High = float(p1) + float(p1)*float(p2)/100.0 148 else: 149 Low = float(p1) - float(p2) 150 High = float(p1) + float(p2) 151 n = ModelID + ".L("+ name + ")." + pname 152 self.Add_a_Par( n, Low, High )

153 154 155 ######################################################################## 156 #For the roughness

157 - def addFitPar2(self, i, DictL, DictI, ModelID):

158 n1=DictL[i]["name"]; n2=DictL[i+1]["name"]; p=DictI[i]["interface"] 159 160 if isString( p ): 161 pass 162 elif isvector( p ): 163 n = ModelID + ".I("+ n1 + "/" + n2 + ").roughness" 164 if len(p) ==3: 165 self.Add_a_Par( n, p[0], p[2] ) 166 else: 167 self.Add_a_Par( n, p[0], p[1] ) 168 169 elif isfactory( p ): 170 r = AFloat( p ) 171 if r[0] == 2: 172 n = ModelID + ".I("+ n1 + "/" + n2 + ").roughness.left" 173 self.Add_a_Par( n, r[1][0], r[1][1] ) 174 n = ModelID + ".I("+ n1 + "/" + n2 + ").roughness.right" 175 self.Add_a_Par( n, r[1][0], r[1][1] ) 176 else: 177 for j in range(r[0]): 178 n = ModelID+".L("+ n1+"/"+n2 + ").roughness.rho_"+str(j) 179 self.Add_a_Par( n, r[1][0], r[1][1] ) 180 elif isscientific( p): 181 q = str( p ) 182 listp = q.strip()[:-1].split('(') 183 p1 = listp[0].strip(); p2 = listp[1].strip(); 184 if p2[-1] == "%": 185 p2 = p2[:-1] 186 Low = float(p1) - float(p1)*float(p2)/100.0 187 High = float(p1) + float(p1)*float(p2)/100.0 188 else: 189 Low = float(p1) - float(p2) 190 High = float(p1) + float(p2) 191 n = ModelID + ".I("+ n1+"/"+n2+ ").roughness" 192 self.Add_a_Par( n, Low, High )

193 194 195

196 - def getFitXML(self):

197 return self.root_el

198 199

200 -class xmlCalculated:

201

202 - def __init__(self):

203 self.xdoc = getDOMImp().createDocument(None, "Calculated", None) 204 self.root_el = self.xdoc.documentElement #root elements

205

206 - def Add_a_Calc(self, 207 target, 208 data 209 ):

210 el = self.xdoc.createElement("C") 211 el.setAttribute("Target", target ) 212 el.appendChild( self.xdoc.createTextNode( data) ) 213 el.normalize() 214 self.root_el.appendChild(el)

215

216 - def Add_blank_line(self):

217 self.root_el.appendChild( self.xdoc.createTextNode('') )

218

219 - def getCalculatedXML(self):

220 return self.root_el

221 222 223 #########################################################################

224 -class xmlTheory:

225

226 - def __init__(self, 227 classType, 228 magneticType, 229 comments = "Example magnetic system for debugging purposes" 230 ):

231 self.xdoc=getDOMImp().createDocument(None,"Theory",None) 232 self.top_element = self.xdoc.documentElement 233 class_Type = "" 234 if classType.lower() == "refl": 235 class_Type = "reflectometry.model1d.fitmodel" 236 #FIXME! For sans or other Model 237 self.top_element.setAttribute( "class", class_Type ) 238 self.top_element.setAttribute( "magnetic", str(magneticType) ) 239 self.magnetic = magneticType 240 self.top_element.appendChild( self.xdoc.createComment( comments ) )

241 242

243 - def addElement(self, tagname, layername, rho=0, depth=0, 244 mu=0, phi=0, theta=0):

245 el = self.xdoc.createElement(tagname) 246 el.setAttribute("name", layername) 247 el.setAttribute("rho", str(rho) ) 248 el.setAttribute("depth", str(depth) ) 249 el.setAttribute("mu", str(mu) ) 250 if self.magnetic: 251 el.setAttribute("phi", str(phi) ) 252 el.setAttribute("theta", str(theta) ) 253 return el

254

255 - def addIncident(self, layername="Air",rho=0,depth=0,mu=0,phi=0, theta=0):

256 e1=self.addElement("incident",layername,rho,depth,mu,phi,theta) 257 self.top_element.appendChild(e1) 258 self.Add_blank_line()

259 260

261 - def addSubstrate(self, layername="Si", rho=2.07, depth=0, mu=0.0002254, 262 phi=0, theta=180):

263 el=self.addElement("substrate", layername, rho, depth, mu, phi, theta) 264 self.top_element.appendChild(el)

265 266

267 - def addLayer(self, layername, rho=0, depth=0, mu=0, phi=0, theta=0 ):

268 el=self.addElement("layer", layername, rho, depth, mu, phi, theta) 269 self.top_element.appendChild(el)

270 271

272 - def addInterface(self, roughness ):

273 el = self.xdoc.createElement("interface") 274 el.setAttribute("roughness", str(roughness) ) 275 self.top_element.appendChild(el)

276 277

278 - def Add_a_Pair(self, roughness, str_name, rho, depth, mu, phi, theta):

279 self.addInterface( roughness ) 280 self.addLayer(str_name, rho, depth, mu, phi, theta)

281

282 - def addMetadata2(self, 283 wavelength, 284 background, 285 wavelengthdivergence, 286 angulardivergence 287 ):

288 el = self.xdoc.createElement("meta") 289 el.setAttribute("wavelength", str(wavelength) ) 290 el.setAttribute("background", str(background) ) 291 el.setAttribute("wavelengthdivergence", str(wavelengthdivergence) ) 292 el.setAttribute("angulardivergence", str(angulardivergence) ) 293 self.top_element.appendChild(el)

294 295

296 - def addMetadata(self, 297 wavelength, 298 background, 299 wavelengthdivergence, 300 angulardivergence, 301 dtheta1, 302 dtheta2, 303 Q1, 304 Q2, 305 dvtheta 306 ):

307 el = self.xdoc.createElement("meta") 308 el.setAttribute("wavelength", str(wavelength) ) 309 el.setAttribute("background", str(background) ) 310 el.setAttribute("wavelengthdivergence", str(wavelengthdivergence) ) 311 el.setAttribute("angulardivergence", str(angulardivergence) ) 312 el.setAttribute("dtheta1", str(dtheta1) ) 313 el.setAttribute("dtheta2", str(dtheta2) ) 314 el.setAttribute("Q1", str(Q1) ) 315 el.setAttribute("Q2", str(Q2) ) 316 el.setAttribute("dvtheta", str(dvtheta) ) 317 318 self.top_element.appendChild(el)

319 320 321

322 - def Add_blank_line(self):

323 self.top_element.appendChild( self.xdoc.createTextNode('') )

324

325 - def getTheoryXML(self):

326 return self.top_element

327 328 329 330 #===============================================================

331 -class ReflModel:

332

333 - def __init__(self, 334 ModelID="M1", 335 classType="refl", 336 magnetic=True, 337 file="", 338 comments=" " 339 ):

340 self.ModelID = ModelID 341 self.classType = classType 342 self.magnetic = magnetic 343 self.datafile = file 344 self.xdoc=getDOMImp().createDocument(None,"Uniplexor",None) 345 self.top_element = self.xdoc.documentElement 346 self.top_element.appendChild( self.xdoc.createComment(comments) ) 347 self.top_element.setAttribute( "modelName", ModelID ) 348 self.t = xmlTheory( self.classType, self.magnetic ) 349 self.current_interface = 0 350 self.current_layer = 0 351 self.DictLayers = [ {} ] 352 self.DictInterfaces = [ {} ] 353 #Meta data 354 self.wavelength=4.75 355 self.background = 1.0e-10 356 self.wavelengthdivergence = 0.021 357 self.angulardivergence = 7e-4

358

359 - def addMetadata2(self, 360 wavelength=4.75, 361 background=1.0e-10, 362 wavelengthdivergence=0.021, 363 angulardivergence=0.0007 364 ):

365 self.t.addMetadata(wavelength, 366 background, 367 wavelengthdivergence, 368 angulardivergence)

369

370 - def addMetadata(self, 371 wavelength=4.75, 372 background=1.0e-10, 373 wavelengthdivergence=0.021, 374 angulardivergence=0.0007, 375 dtheta1=0.0007, 376 dtheta2=0.0007, 377 Q1=0.0, 378 Q2=0.0, 379 dvtheta=0.0007 380 ):

381 self.t.addMetadata(wavelength, background, wavelengthdivergence, 382 angulardivergence, dtheta1, dtheta2, 383 Q1, Q2, dvtheta)

384

385 - def getModelID(self):

386 return self.ModelID

387

388 - def getMagnetic(self):

389 return self.magnetic

390

391 - def addIncident(self, layername="Air",rho=0,depth=0,mu=0,phi=0,theta=0):

392 self.t.addIncident(layername, rho, depth, mu, phi, theta)

393

394 - def addSubstrate(self, layername="Si", rho=2.07, depth=0, 395 mu=0.0002254, phi=0, theta=180):

396 self.t.addSubstrate(layername, rho, depth, mu, phi, theta)

397

398 - def addLayer(self, layername, rho=0, depth=0, mu=0, phi=0, theta=0):

399 self.t.addLayer(layername, rho, depth, mu, phi, theta)

400

401 - def addInterface(self, roughness=5 ):

402 self.t.addInterface(roughness)

403

404 - def Add_pair_in_Theory(self,s1=0, s2=0, s3=0, s4=0, s5=0, s6=0, s7=0 ):

405 self.t.Add_a_Pair(s1, s2, s3, s4, s5, s6, s7) 406 self.t.Add_blank_line()

407

408 - def Add_Theory(self):

409 self.top_element.appendChild( self.t.getTheoryXML() )

410

411 - def Add_Data(self):

412 el = self.xdoc.createElement("Data") 413 el.setAttribute("Name", self.datafile) 414 self.top_element.appendChild(el)

415

416 - def getDictLayers(self):

417 return self.DictLayers

418

419 - def getDictInterfaces(self):

420 return self.DictInterfaces

421

422 - def Add_blank_line(self):

423 self.top_element.appendChild( self.xdoc.createTextNode('') )

424

425 - def incident(self, name='Air', depth=0, rho=0, mu=0, phi=0, theta=270):

426 dic = { "name":name, "rho":rho, "depth":depth, 427 "mu":mu, "phi":phi, "theta":theta 428 } 429 self.DictLayers[0] = dic 430 self.current_layer += 1

431

432 - def layer(self, name='Air', depth=0, rho=0, mu=0, phi=0, theta=270):

433 dic = { "name":name, "rho":rho, "depth":depth, 434 "mu":mu, "phi":phi, "theta":theta 435 } 436 self.DictLayers.append(dic) 437 self.current_layer += 1

438

439 - def substrate(self, name="Si", depth=0, rho=0, mu=0, phi=0, theta=270):

440 dic = { "name":name, "rho":rho, "depth":depth, 441 "mu":mu, "phi":phi, "theta":theta 442 } 443 self.DictLayers.append(dic) 444 self.current_layer += 1

445

446 - def interface(self, roughness):

447 dic = { "interface":roughness} 448 if self.current_interface ==0 : 449 self.DictInterfaces[0] = dic 450 else: 451 self.DictInterfaces.append(dic) 452 453 self.current_interface += 1

454

455 - def myPars(self, i ):

456 name = self.DictLayers[i]["name"] 457 rho = tFloat( self.DictLayers[i]["rho"]) 458 depth = tFloat( self.DictLayers[i]["depth"]) 459 mu = tFloat( self.DictLayers[i]["mu"]) 460 if self.magnetic: 461 phi = tFloat( self.DictLayers[i]["phi"]) 462 theta = tFloat( self.DictLayers[i]["theta"]) 463 return [name, rho, depth, mu, phi, theta] 464 else: 465 return [name, rho, depth, mu]

466

467 - def addTheoryXML(self):

468 NLayers = self.current_layer - 1 469 NInterfaces = self.current_interface - 1 470 471 if self.magnetic: 472 self.addIncident() 473 for i in range( NInterfaces ): 474 #roughness = float( self.DictInterfaces[i]["interface"] ) 475 roughness = AFloat( self.DictInterfaces[i]["interface"] ) 476 [name, rho, depth, mu, phi, theta] = self.myPars(i+1) 477 self.Add_pair_in_Theory(roughness,name,rho,depth,mu,phi,theta) 478 479 roughness = AFloat( self.DictInterfaces[NInterfaces]["interface"] ) 480 self.addInterface(roughness) 481 482 [name, rho, depth, mu, phi, theta] = self.myPars( NLayers ) 483 self.addSubstrate(name,rho,depth,mu,phi,theta) 484 else: 485 self.addIncident() 486 for i in range( NInterfaces ): 487 #roughness = float( self.DictInterfaces[i]["interface"] ) 488 roughness = AFloat( self.DictInterfaces[i]["interface"] ) 489 [name, rho, depth, mu] = self.myPars(i+1) 490 self.Add_pair_in_Theory(roughness,name,rho,depth,mu) 491 492 roughness = AFloat( self.DictInterfaces[NInterfaces]["interface"] ) 493 self.addInterface(roughness) 494 495 [name, rho, depth, mu] = self.myPars( NLayers ) 496 self.addSubstrate(name,rho,depth,mu) 497 498 # Meta data 499 self.t.Add_blank_line() 500 self.addMetadata(self.wavelength, 501 self.background, 502 self.wavelengthdivergence, 503 self.angulardivergence)

504

505 - def SetWavelength(self, 506 wavelength=4.75):

507 self.wavelength = wavelength

508

509 - def SetBackground(self, 510 background=1.0e-10):

511 self.background = background

512

513 - def SetFixedResolution( self, 514 wavelengthdivergence=0.021, 515 angulardivergence=7e-4):

516 self.wavelengthdivergence = wavelengthdivergence 517 self.angulardivergence = angulardivergence

518 519

520 - def setUniplexorXML(self):

521 self.addTheoryXML() 522 self.Add_Theory() 523 self.Add_Data() 524 self.Add_blank_line()

525

526 - def getUniplexorXML(self):

527 #self.setUniplexorXML() 528 #return self.top_element.toprettyxml() 529 return self.top_element

530 531 532 ########################################################################

533 -class ParkFit:

534

535 - def __init__(self, models, comments=" "):

536 self.xdoc=getDOMImp().createDocument(None,"Multiplexor",None) 537 self.top_element = self.xdoc.documentElement 538 self.Add_blank_line() 539 self.top_element.appendChild( self.xdoc.createComment( comments) ) 540 self.u = [] # Uniplexors 541 self.f = xmlFit() # Fit parameters 542 self.c = xmlCalculated() 543 self.targets=[] 544 545 for m in models: self.addModel(m)

546

547 - def addModel(self, 548 xmlU # This is a Uniplxor Object 549 ):

550 xmlU.setUniplexorXML() 551 newxmlU = uor2uor( xmlU ) 552 self.u.append( newxmlU )

553 554

555 - def Add_blank_line(self):

556 self.top_element.appendChild( self.xdoc.createTextNode('') )

557

558 - def Add_Fit_blank_line(self):

559 self.f.Add_blank_line()

560

561 - def addCalc(self, target, data):

562 self.c.Add_a_Calc(target, data) 563 self.targets.append(target)

564

565 - def addFitXML(self, i):

566 u = self.u[i] 567 ModelID = u.getModelID() 568 magnetic = u.getMagnetic() 569 dictL = u.getDictLayers() 570 dictI = u.getDictInterfaces() 571 NLayers = len(dictL); NInterfaces = len(dictI); 572 573 for i in range( NLayers ): 574 self.f.addFitPar(i, dictL, ModelID, "depth") 575 self.f.addFitPar(i, dictL, ModelID, "rho") 576 self.f.addFitPar(i, dictL, ModelID, "mu") 577 if magnetic: 578 self.f.addFitPar(i, dictL, ModelID,"phi") 579 self.f.addFitPar(i, dictL, ModelID,"theta") 580 581 for i in range( NInterfaces ): 582 self.f.addFitPar2(i, dictL, dictI, ModelID)

583 584

585 - def addAllFitXML(self):

586 for i in range( len(self.u) ): 587 self.addFitXML(i) 588 self.Add_Fit_blank_line()

589 590

591 - def setMultiplexorXML(self):

592 for i in range( len(self.u) ): 593 self.top_element.appendChild( self.u[i].getUniplexorXML() ) 594 self.Add_blank_line() 595 596 self.addAllFitXML() 597 # remove 598 for i in range( len(self.targets) ): 599 self.f.Remove_a_Par( self.targets[i] ) 600 601 self.top_element.appendChild( self.f.getFitXML() ) 602 603 self.Add_blank_line() 604 self.top_element.appendChild( self.c.getCalculatedXML() )

605 606

607 - def Request(self):

608 self.setMultiplexorXML() 609 610 return self.top_element.toprettyxml(indent=" ")

611 612 613 # ================ Example program ===========================

614 -def demo():

615 616 M1 = ReflModel("M1", file="du53.dat", magnetic=False) 617 M1.incident('Air', rho=0, mu=0) 618 M1.interface(8) 619 M1.layer('dPS', depth=[40, 90], rho=1.86850712846, mu= bspline([2,4,3]) ) 620 M1.interface(5) 621 M1.layer('P2VP', depth=[10, 30], rho=2.52216569755, mu=[0, 3] ) 622 M1.interface(5) 623 M1.layer('SiOx', depth=[14, 20.399999999999999], rho=3.8, mu=0) 624 M1.interface(5) 625 M1.substrate('Si', rho=2.07, mu=0) 626 627 fit = ParkFit([M1]) 628 print fit.Request()

629 630 if __name__ == "__main__": demo() 631

Source Code for Module reflectometry.model1d.profileview.parseReflModel