diffpy.pdffit2.tests.TestPdfFit

1 #!/usr/bin/env python 2 3 """Unit tests for PdfFit.py 4 """ 5 6 7 import unittest 8 9 from diffpy.pdffit2 import PdfFit 10 from diffpy.pdffit2 import pdffit2 11 from pdffit2testutils import datafile 12 13 ##############################################################################

14 -class TestPdfFit(unittest.TestCase):

15 16 places = 6 17

18 - def setUp(self):

19 self.P = PdfFit() 20 return

21

22 - def tearDown(self):

23 del self.P 24 return

25 26 # def test_intro(self): 27 # """check PdfFit.intro() 28 # """ 29 # return 30

31 - def test_add_structure(self):

32 """check PdfFit.add_structure() 33 """ 34 # skip test when diffpy.Structure is not installed 35 try: 36 from diffpy.Structure import Structure 37 except ImportError: 38 return 39 ni = Structure(filename=datafile('Ni.stru')) 40 self.P.add_structure(ni) 41 self.assertEqual(4, self.P.num_atoms()) 42 return

43 44 # def test_read_struct(self): 45 # """check PdfFit.read_struct() 46 # """ 47 # return 48 # 49 # def test_read_struct_string(self): 50 # """check PdfFit.read_struct_string() 51 # """ 52 # return 53 # 54 # def test_read_data(self): 55 # """check PdfFit.read_data() 56 # """ 57 # return 58 # 59 # def test_read_data_string(self): 60 # """check PdfFit.read_data_string() 61 # """ 62 # return 63 # 64 # def test_read_data_lists(self): 65 # """check PdfFit.read_data_lists() 66 # """ 67 # return 68 # 69 # def test_pdfrange(self): 70 # """check PdfFit.pdfrange() 71 # """ 72 # return 73 # 74 # def test_reset(self): 75 # """check PdfFit.reset() 76 # """ 77 # return 78

79 - def test_alloc(self):

80 """check PdfFit.alloc() 81 """ 82 # alloc and read_struct can be called in any order. 83 self.P.alloc('X', 25, 0.0, 0.01, 10, 1000) 84 # without a structure calculated PDF is all zero 85 self.P.calc() 86 Gzero = self.P.getpdf_fit() 87 self.assertEqual(1000*[0.0], Gzero) 88 self.P.read_struct(datafile('Ni.stru')) 89 self.P.calc() 90 # check r-values 91 r = self.P.getR() 92 self.assertEqual(1000, len(r)) 93 for i in range(1000): 94 self.assertAlmostEqual(0.01*(i + 1), r[i], self.places) 95 Gfit_alloc_read = self.P.getpdf_fit() 96 # now try the other order 97 self.P.reset() 98 self.P.read_struct(datafile('Ni.stru')) 99 self.P.alloc('X', 25, 0.0, 0.01, 10, 1000) 100 self.P.calc() 101 Gfit_read_alloc = self.P.getpdf_fit() 102 # and they should be the same 103 self.assertEqual(Gfit_read_alloc, Gfit_alloc_read) 104 return

105 106 # def test_calc(self): 107 # """check PdfFit.calc() 108 # """ 109 # return 110 # 111 # def test_refine(self): 112 # """check PdfFit.refine() 113 # """ 114 # return 115 # 116 # def test_refine_step(self): 117 # """check PdfFit.refine_step() 118 # """ 119 # return 120 # 121 # def test_save_pdf(self): 122 # """check PdfFit.save_pdf() 123 # """ 124 # return 125 # 126 # def test_save_pdf_string(self): 127 # """check PdfFit.save_pdf_string() 128 # """ 129 # return 130 # 131 # def test_save_dif(self): 132 # """check PdfFit.save_dif() 133 # """ 134 # return 135 # 136 # def test_save_dif_string(self): 137 # """check PdfFit.save_dif_string() 138 # """ 139 # return 140 # 141 # def test_save_res(self): 142 # """check PdfFit.save_res() 143 # """ 144 # return 145 # 146 # def test_save_res_string(self): 147 # """check PdfFit.save_res_string() 148 # """ 149 # return 150

151 - def test_get_structure(self):

152 """check PdfFit.get_structure() 153 """ 154 self.P.read_struct(datafile('Ni.stru')) 155 self.P.read_struct(datafile('PbScW25TiO3.stru')) 156 stru1 = self.P.get_structure(1) 157 self.assertEqual(4, len(stru1)) 158 self.assertEqual('Ni', stru1[0].element) 159 stru2 = self.P.get_structure(2) 160 self.assertEqual(56, len(stru2)) 161 self.assertEqual('Ti', stru2[-1].element) 162 return

163 164 # def test_save_struct(self): 165 # """check PdfFit.save_struct() 166 # """ 167 # return 168 # 169 # def test_save_struct_string(self): 170 # """check PdfFit.save_struct_string() 171 # """ 172 # return 173 # 174 # def test_show_struct(self): 175 # """check PdfFit.show_struct() 176 # """ 177 # return 178 # 179 # def test_constrain(self): 180 # """check PdfFit.constrain() 181 # """ 182 # return 183 # 184 # def test_setpar(self): 185 # """check PdfFit.setpar() 186 # """ 187 # return 188 # 189 # def test_setvar(self): 190 # """check PdfFit.setvar() 191 # """ 192 # return 193 # 194 # def test_getvar(self): 195 # """check PdfFit.getvar() 196 # """ 197 # return 198 # 199 # def test_getrw(self): 200 # """check PdfFit.getrw() 201 # """ 202 # return 203 # 204 # def test_getR(self): 205 # """check PdfFit.getR() 206 # """ 207 # return 208 # 209 # def test_getpdf_fit(self): 210 # """check PdfFit.getpdf_fit() 211 # """ 212 # return 213 # 214 # def test_getpdf_obs(self): 215 # """check PdfFit.getpdf_obs() 216 # """ 217 # return 218 # 219 # def test_getpdf_diff(self): 220 # """check PdfFit.getpdf_diff() 221 # """ 222 # return 223

224 - def test_get_atoms(self):

225 """check PdfFit.get_atoms() 226 """ 227 self.P.read_struct(datafile('Ni.stru')) 228 self.P.read_struct(datafile('PbScW25TiO3.stru')) 229 self.P.setphase(1) 230 a1 = self.P.get_atoms() 231 a2 = self.P.get_atoms(2) 232 self.assertEqual(4*['NI'], a1) 233 self.assertEqual(8*['PB']+24*['O']+8*['SC']+8*['W']+8*['TI'], a2) 234 return

235

236 - def test_get_atom_types(self):

237 """check PdfFit.get_atom_types() 238 """ 239 self.P.read_struct(datafile('Ni.stru')) 240 self.P.read_struct(datafile('PbScW25TiO3.stru')) 241 self.P.setphase(1) 242 atp1 = self.P.get_atom_types() 243 atp2 = self.P.get_atom_types(2) 244 self.assertEqual(['NI'], atp1) 245 self.assertEqual(['PB', 'O', 'SC', 'W', 'TI'], atp2) 246 return

247

248 - def test_num_phases(self):

249 """check PdfFit.num_phases() 250 """ 251 self.assertEqual(0, self.P.num_phases()) 252 self.P.read_struct(datafile('Ni.stru')) 253 self.assertEqual(1, self.P.num_phases()) 254 self.P.read_struct(datafile('PbScW25TiO3.stru')) 255 self.assertEqual(2, self.P.num_phases()) 256 self.P.reset() 257 self.assertEqual(0, self.P.num_phases()) 258 return

259

260 - def test_num_datasets(self):

261 """check PdfFit.num_datasets() 262 """ 263 self.assertEqual(0, self.P.num_datasets()) 264 self.P.read_data(datafile('Ni.dat'), 'X', 25.0, 0.5) 265 self.assertEqual(1, self.P.num_datasets()) 266 # failed data should not increase num_datasets 267 try: 268 self.P.read_data(datafile('badNi.dat')) 269 except: 270 pass 271 self.assertEqual(1, self.P.num_datasets()) 272 # alloc should increase number of datasets 273 # alloc requires a loaded structure 274 self.P.read_struct(datafile('Ni.stru')) 275 self.P.alloc('X', 30.0, 0.05, 2, 10, 100) 276 self.assertEqual(2, self.P.num_datasets()) 277 self.P.reset() 278 self.assertEqual(0, self.P.num_datasets()) 279 return

280

281 - def test_getcrw(self):

282 """check PdfFit.getcrw() 283 """ 284 import numpy 285 self.assertEqual(0, self.P.num_datasets()) 286 # Setting qmax=0 so that partial crw are not disturbed by 287 # termination ripples. 288 self.P.read_data(datafile('Ni.dat'), 'X', 0.0, 0.0) 289 # crw is empty before data refinement 290 self.assertEqual([], self.P.getcrw()) 291 self.P.read_struct(datafile('Ni.stru')) 292 self.P.pdfrange(1, 2, 19) 293 self.P.refine() 294 crw19 = numpy.array(self.P.getcrw()) 295 self.failUnless(numpy.all(crw19 >= 0.0)) 296 # check that crw19 is non decreasing 297 self.failUnless(numpy.all(numpy.diff(crw19) >= 0.0)) 298 # check that crw19 and getrw give the same value 299 rw19 = crw19[-1] 300 self.assertAlmostEqual(self.P.getrw(), rw19, self.places) 301 # renormalize cumulative Rw and compare with Rw at r=15 302 Gobs19 = numpy.array(self.P.getpdf_obs()) 303 Gnorm19 = numpy.sqrt(numpy.sum(Gobs19**2)) 304 r = numpy.array(self.P.getR()) 305 idx = numpy.nonzero(r <= 15)[0] 306 Gnorm15 = numpy.sqrt(numpy.sum(Gobs19[idx]**2)) 307 i15 = idx[-1] 308 rw15 = crw19[i15] * Gnorm19 / Gnorm15 309 self.P.pdfrange(1, 2, r[i15] + 1e-5) 310 self.P.refine() 311 self.assertAlmostEqual(self.P.getrw(), rw15, self.places) 312 return

313

314 - def test_getcrw_two_datasets(self):

315 """check that getcrw() and getrw() are consistent for two datasets. 316 """ 317 self.P.read_data(datafile('Ni.dat'), 'X', 25.0, 0.0) 318 self.P.pdfrange(1, 2, 8) 319 self.P.read_data(datafile('300K.gr'), 'N', 32.0, 0.0) 320 self.P.pdfrange(2, 1, 11) 321 self.P.read_struct(datafile('Ni.stru')) 322 # mess lattice parameters to have comparable Rw contributions 323 self.P.setvar('lat(1)', 3) 324 self.P.setvar('lat(2)', 3) 325 self.P.setvar('lat(3)', 3) 326 self.P.refine() 327 rwtot = self.P.getrw() 328 self.failUnless(rwtot > 0.0) 329 self.P.setdata(1) 330 rw1 = self.P.getcrw()[-1] 331 self.P.setdata(2) 332 rw2 = self.P.getcrw()[-1] 333 self.assertAlmostEqual(rwtot**2, rw1**2 + rw2**2, self.places) 334 return

335 336 # def test_getpar(self): 337 # """check PdfFit.getpar() 338 # """ 339 # return 340 # 341 # def test_fixpar(self): 342 # """check PdfFit.fixpar() 343 # """ 344 # return 345 # 346 # def test_freepar(self): 347 # """check PdfFit.freepar() 348 # """ 349 # return 350 # 351 # def test_setphase(self): 352 # """check PdfFit.setphase() 353 # """ 354 # return 355 # 356 # def test_setdata(self): 357 # """check PdfFit.setdata() 358 # """ 359 # return 360 #

361 - def test_psel(self):

362 """check PdfFit.psel() 363 """ 364 def doalloc(): 365 self.P.alloc('X', 30.0, 0.05, 2, 10, 100) 366 return

367 self.assertRaises(pdffit2.unassignedError, self.P.psel, 0) 368 self.assertRaises(pdffit2.unassignedError, self.P.psel, 1) 369 self.P.read_struct(datafile('Ni.stru')) 370 doalloc() 371 self.P.calc() 372 G1 = self.P.getpdf_fit() 373 self.P.reset() 374 self.P.read_struct(datafile('PbScW25TiO3.stru')) 375 doalloc() 376 self.P.calc() 377 G2 = self.P.getpdf_fit() 378 self.P.reset() 379 self.P.read_struct(datafile('Ni.stru')) 380 self.P.read_struct(datafile('PbScW25TiO3.stru')) 381 doalloc() 382 self.P.pdesel('ALL') 383 self.P.psel(1) 384 self.P.calc() 385 self.assertEqual(G1, self.P.getpdf_fit()) 386 self.P.pdesel('ALL') 387 self.P.psel(2) 388 self.P.calc() 389 self.assertEqual(G2, self.P.getpdf_fit()) 390 self.P.psel('ALL') 391 self.P.calc() 392 Gall = self.P.getpdf_fit() 393 dGmax = max([abs(g1 + g2 - gall) 394 for g1, g2, gall in zip(G1, G2, Gall)]) 395 self.assertAlmostEqual(0, dGmax, self.places) 396 self.assertRaises(pdffit2.unassignedError, self.P.psel, 10) 397 self.assertRaises(pdffit2.unassignedError, self.P.psel, 0) 398 self.assertRaises(pdffit2.unassignedError, self.P.psel, -100) 399 return

400

401 - def test_pdesel(self):

402 """check PdfFit.pdesel() 403 """ 404 def doalloc(): 405 self.P.alloc('X', 30.0, 0.05, 2, 10, 100) 406 return

407 self.assertRaises(pdffit2.unassignedError, self.P.pdesel, 0) 408 self.assertRaises(pdffit2.unassignedError, self.P.pdesel, 1) 409 self.P.read_struct(datafile('Ni.stru')) 410 doalloc() 411 self.P.calc() 412 G1 = self.P.getpdf_fit() 413 self.P.reset() 414 self.P.read_struct(datafile('PbScW25TiO3.stru')) 415 doalloc() 416 self.P.calc() 417 G2 = self.P.getpdf_fit() 418 self.P.reset() 419 self.P.read_struct(datafile('Ni.stru')) 420 self.P.read_struct(datafile('PbScW25TiO3.stru')) 421 doalloc() 422 self.P.psel('ALL') 423 self.P.pdesel(2) 424 self.P.calc() 425 self.assertEqual(G1, self.P.getpdf_fit()) 426 self.P.psel('ALL') 427 self.P.pdesel(1) 428 self.P.calc() 429 self.assertEqual(G2, self.P.getpdf_fit()) 430 self.P.pdesel('ALL') 431 self.P.calc() 432 G0 = self.P.getpdf_fit() 433 self.assertEqual([0.0]*len(G0), G0) 434 self.assertRaises(pdffit2.unassignedError, self.P.pdesel, 10) 435 self.assertRaises(pdffit2.unassignedError, self.P.pdesel, 0) 436 self.assertRaises(pdffit2.unassignedError, self.P.pdesel, -100) 437 return 438 # 439 # def test_selectAtomType(self): 440 # """check PdfFit.selectAtomType() 441 # """ 442 # return 443 # 444 # def test_selectAtomIndex(self): 445 # """check PdfFit.selectAtomIndex() 446 # """ 447 # return 448 # 449 # def test_selectAll(self): 450 # """check PdfFit.selectAll() 451 # """ 452 # return 453 # 454 # def test_selectNone(self): 455 # """check PdfFit.selectNone() 456 # """ 457 # return 458

459 - def test_bond_angle(self):

460 """check PdfFit.bond_angle() 461 """ 462 self.P.read_struct(datafile('Ni.stru')) 463 a, e = self.P.bond_angle(1, 2, 3) 464 self.assertAlmostEqual(60.0, a, self.places) 465 self.assertRaises(ValueError, self.P.bond_angle, 0, 1, 2) 466 self.assertRaises(ValueError, self.P.bond_angle, 1, 2, 7) 467 return

468

469 - def test_bond_length_atoms(self):

470 """check PdfFit.bond_length_atoms() 471 """ 472 self.P.read_struct(datafile('Ni.stru')) 473 self.P.read_struct(datafile('PbScW25TiO3.stru')) 474 dij, ddij = self.P.bond_length_atoms(1, 5) 475 self.assertAlmostEqual(4.03635, dij, self.places) 476 self.P.setphase(1) 477 self.assertRaises(ValueError, self.P.bond_length_atoms, 1, 5) 478 return

479

480 - def test_bond_length_types(self):

481 """check PdfFit.bond_length_types() 482 """ 483 self.P.read_struct(datafile('Ni.stru')) 484 self.P.read_struct(datafile('PbScW25TiO3.stru')) 485 dPbO = self.P.bond_length_types('Pb', 'O', 0.1, 3.0) 486 # check if keys are present 487 self.failUnless('dij' in dPbO) 488 self.failUnless('ddij' in dPbO) 489 self.failUnless('ij0' in dPbO) 490 self.failUnless('ij1' in dPbO) 491 # check if they have the same length 492 npts = len(dPbO['dij']) 493 self.assertEqual(npts, len(dPbO['ddij'])) 494 self.assertEqual(npts, len(dPbO['ij0'])) 495 self.assertEqual(npts, len(dPbO['ij1'])) 496 # 8 Pb atoms have coordination 12 in perovskite structure 497 self.assertEqual(8*12, len(dPbO['dij'])) 498 self.P.setphase(1) 499 dfcc = self.P.bond_length_types('ALL', 'ALL', 0.1, 2.6) 500 # 4 Ni atoms with coordination 12 501 self.assertEqual(4*12, len(dfcc['dij'])) 502 # invalid element 503 self.assertRaises(ValueError, self.P.bond_length_types, 'Ni', 'Nix', 0.1, 5.0) 504 # check indices ij0 505 allij0 = sum(dfcc['ij0'], tuple()) 506 self.assertEqual(0, min(allij0)) 507 self.assertEqual(3, max(allij0)) 508 # check indices ij1 509 allij1 = sum(dfcc['ij1'], tuple()) 510 self.assertEqual(1, min(allij1)) 511 self.assertEqual(4, max(allij1)) 512 # check index values 513 ij0check = [(i1 - 1, j1 - 1) for i1, j1 in dfcc['ij1']] 514 self.assertEqual(ij0check, dfcc['ij0']) 515 # test valid element which is not present in the structure 516 dnone = self.P.bond_length_types('Ni', 'Au', 0.1, 5.0) 517 self.assertEqual(0, len(dnone['dij'])) 518 self.assertEqual(0, len(dnone['ddij'])) 519 self.assertEqual(0, len(dnone['ij0'])) 520 self.assertEqual(0, len(dnone['ij1'])) 521 return

522 523 # def test_show_scat(self): 524 # """check PdfFit.show_scat() 525 # """ 526 # return 527 # 528 # def test_get_scat_string(self): 529 # """check PdfFit.get_scat_string() 530 # """ 531 # return 532

533 - def test_get_scat(self):

534 """check PdfFit.get_scat() 535 """ 536 # x-ray scattering factors 537 fPb = self.P.get_scat('X', 'Pb') 538 self.assertEqual(82.0, fPb) 539 fTi = self.P.get_scat('X', 'tI') 540 self.assertEqual(22.0, fTi) 541 # neutron scattering lengths 542 bPb = self.P.get_scat('N', 'PB') 543 self.assertAlmostEqual(9.401, bPb, 3) 544 bTi = self.P.get_scat('N', 'ti') 545 self.assertAlmostEqual(-3.370, bTi, 3) 546 # exceptions 547 self.assertRaises(ValueError, self.P.get_scat, 'N', 'zz') 548 self.assertRaises(ValueError, self.P.get_scat, 'Z', 'Ti') 549 return

550

551 - def test_set_scat(self):

552 """check PdfFit.set_scat() 553 """ 554 # raises exception when no phase exists 555 self.assertRaises(pdffit2.unassignedError, 556 self.P.set_scat, 'N', 'Ti', -11) 557 # check if it is local to phase 558 fPb = self.P.get_scat('X', 'Pb') 559 bPb = self.P.get_scat('N', 'Pb') 560 self.P.read_struct(datafile('PbScW25TiO3.stru')) 561 self.P.set_scat('X', 'Pb', 142) 562 self.assertEqual(142, self.P.get_scat('X', 'Pb')) 563 self.assertEqual(bPb, self.P.get_scat('N', 'Pb')) 564 self.P.read_struct(datafile('PbScW25TiO3.stru')) 565 self.assertEqual(fPb, self.P.get_scat('X', 'Pb')) 566 self.P.setphase(1) 567 self.assertEqual(142, self.P.get_scat('X', 'Pb')) 568 self.P.setphase(2) 569 self.assertEqual(fPb, self.P.get_scat('X', 'Pb')) 570 # check exception for invalid inputs 571 self.assertRaises(ValueError, self.P.set_scat, 'Z', 'C', 123) 572 self.assertRaises(ValueError, self.P.set_scat, 'X', 'ZZ', 123) 573 return

574

575 - def test_reset_scat(self):

576 """check PdfFit.reset_scat() 577 """ 578 # raises exception when no phase exists 579 self.assertRaises(pdffit2.unassignedError, self.P.reset_scat, 'Ti') 580 # check if it is local to phase 581 fPb = self.P.get_scat('X', 'Pb') 582 bPb = self.P.get_scat('N', 'Pb') 583 self.P.read_struct(datafile('PbScW25TiO3.stru')) 584 self.P.set_scat('X', 'Pb', 142) 585 self.P.read_struct(datafile('PbScW25TiO3.stru')) 586 self.P.set_scat('N', 'Pb', -17) 587 self.P.setphase(1) 588 self.assertNotEqual(fPb, self.P.get_scat('X', 'Pb')) 589 self.P.reset_scat('Pb') 590 self.assertEqual(fPb, self.P.get_scat('X', 'Pb')) 591 self.P.setphase(2) 592 self.assertNotEqual(bPb, self.P.get_scat('N', 'Pb')) 593 self.P.reset_scat('Pb') 594 self.assertEqual(bPb, self.P.get_scat('N', 'Pb')) 595 # check exception for invalid inputs 596 self.assertRaises(ValueError, self.P.reset_scat, 'Zz') 597 return

598

599 - def test_num_atoms(self):

600 """check PdfFit.num_atoms() 601 """ 602 self.P.read_struct(datafile('Ni.stru')) 603 self.assertEqual(4, self.P.num_atoms()) 604 self.P.read_struct(datafile('PbScW25TiO3.stru')) 605 self.assertEqual(56, self.P.num_atoms()) 606 self.P.setphase(1) 607 self.assertEqual(4, self.P.num_atoms()) 608 self.P.setphase(2) 609 self.assertEqual(56, self.P.num_atoms()) 610 return

611 612 # def test_lat(self): 613 # """check PdfFit.lat() 614 # """ 615 # return 616 # 617 # def test_x(self): 618 # """check PdfFit.x() 619 # """ 620 # return 621 # 622 # def test_y(self): 623 # """check PdfFit.y() 624 # """ 625 # return 626 # 627 # def test_z(self): 628 # """check PdfFit.z() 629 # """ 630 # return 631 # 632 # def test_u11(self): 633 # """check PdfFit.u11() 634 # """ 635 # return 636 # 637 # def test_u22(self): 638 # """check PdfFit.u22() 639 # """ 640 # return 641 # 642 # def test_u33(self): 643 # """check PdfFit.u33() 644 # """ 645 # return 646 # 647 # def test_u12(self): 648 # """check PdfFit.u12() 649 # """ 650 # return 651 # 652 # def test_u13(self): 653 # """check PdfFit.u13() 654 # """ 655 # return 656 # 657 # def test_u23(self): 658 # """check PdfFit.u23() 659 # """ 660 # return 661 # 662 # def test_occ(self): 663 # """check PdfFit.occ() 664 # """ 665 # return 666 # 667 # def test_pscale(self): 668 # """check PdfFit.pscale() 669 # """ 670 # return 671 # 672 # def test_pscale(self): 673 # """check PdfFit.pscale() 674 # """ 675 # return 676 # 677 # def test_sratio(self): 678 # """check PdfFit.sratio() 679 # """ 680 # return 681 # 682 # def test_delta1(self): 683 # """check PdfFit.delta1() 684 # """ 685 # return 686 # 687 # def test_delta2(self): 688 # """check PdfFit.delta2() 689 # """ 690 # return 691 # 692 # def test_dscale(self): 693 # """check PdfFit.dscale() 694 # """ 695 # return 696 # 697 # def test_qdamp(self): 698 # """check PdfFit.qdamp() 699 # """ 700 # return 701 # 702 # def test_qbroad(self): 703 # """check PdfFit.qbroad() 704 # """ 705 # return 706 # 707 # def test_rcut(self): 708 # """check PdfFit.rcut() 709 # """ 710 # return 711 # 712 # def test___init__(self): 713 # """check PdfFit.__init__() 714 # """ 715 # return 716 # 717 # def test__PdfFit__getRef(self): 718 # """check PdfFit._PdfFit__getRef() 719 # """ 720 # return 721 722 # End of class TestPdfFit 723 724 if __name__ == '__main__': 725 unittest.main() 726 727 # End of file 728

Source Code for Module diffpy.pdffit2.tests.TestPdfFit