def test_read_data(self):
"""check PdfFitSandbox.read_data()
"""
fNi_data = datafile("Ni_2-8.chi.gr")
f300K_data = datafile("300K.gr")
sandbox = self.box.sandbox()
sandbox.update({"fNi_data": fNi_data, "f300K_data": f300K_data})
exec "read_data(fNi_data, X, 40.1, 0.05)" in sandbox
exec "read_data(f300K_data, N, 32.1, 0.05)" in sandbox
self.assertEqual(2, len(self.box._fits[-1].datasets))
self.assertEqual(1, self.box._curdataset)
d0 = self.box._fits[-1].datasets[0]
self.assertEqual('Ni_2-8.chi', d0.name)
self.assertEqual('X', d0.stype)
self.assertAlmostEqual(40.1, d0.qmax, 8)
self.assertAlmostEqual(0.05, d0.qdamp, 8)
self.assertEqual(2000, len(d0.robs))
d1 = self.box._fits[-1].datasets[1]
self.assertEqual('300K', d1.name)
self.assertEqual('N', d1.stype)
self.assertAlmostEqual(32.1, d1.qmax, 8)
self.assertAlmostEqual(0.05, d1.qdamp, 8)
self.assertEqual(2000, len(d1.robs))
self.assertEqual(None, self.box._curphase)
return
def test_read(self):
"""check PDFDataSet.read()
"""
# neutron data -------------------------------------------------
fn_550K = datafile('550K.gr')
self.pdfds.read(fn_550K)
self.assertEqual('N', self.pdfds.stype)
self.assertEqual(32.0, self.pdfds.qmax)
# there are 2000 points in the file
npts = len(self.pdfds.robs)
self.assertEqual(2000, npts)
# drobs are all zero
self.assertEqual(npts*[0.0], self.pdfds.drobs)
# dGobs should be defined
self.failUnless(min(self.pdfds.dGobs) > 0)
# x-ray data ---------------------------------------------------
fx_Ni = datafile('Ni_2-8.chi.gr')
self.pdfds.read(fx_Ni)
self.assertEqual('X', self.pdfds.stype)
self.assertEqual(40.0, self.pdfds.qmax)
# there are 2000 points in the file
npts = len(self.pdfds.robs)
self.assertEqual(2000, npts)
# drobs are all zero
self.assertEqual(npts*[0.0], self.pdfds.drobs)
# dGobs should be defined
self.failUnless(min(self.pdfds.dGobs) > 0)
return
def test_pdfrange(self):
"""check PdfFitSandbox.pdfrange()
"""
fNi_data = datafile("Ni_2-8.chi.gr")
f300K_data = datafile("300K.gr")
self.box.read_data(fNi_data, 'X', 40.1, 0.05)
self.box.read_data(f300K_data, 'N', 32.1, 0.05)
sandbox = self.box.sandbox()
exec "pdfrange(1, 2.3, 11.13)" in sandbox
exec "pdfrange(2, 5.7, 17.19)" in sandbox
self.assertEqual(2, len(self.box._fits[-1].datasets))
d0 = self.box._fits[-1].datasets[0]
d1 = self.box._fits[-1].datasets[1]
self.assertAlmostEqual(2.3, d0.fitrmin, 8)
self.assertAlmostEqual(11.13, d0.fitrmax, 8)
self.assertAlmostEqual(5.7, d1.fitrmin, 8)
self.assertAlmostEqual(17.19, d1.fitrmax, 8)
# exceptions for invalid ranges
self.assertRaises(ControlRuntimeError, self.box.pdfrange, 1, 10, 1)
self.assertRaises(ControlRuntimeError, self.box.pdfrange, 1, 0, 10)
self.assertRaises(ControlRuntimeError, self.box.pdfrange, 1, 1, 1000)
exec "pdfrange(ALL, 1.0, 7.0)" in sandbox
self.assertEqual(1.0, d0.fitrmin)
self.assertEqual(7.0, d0.fitrmax)
self.assertEqual(1.0, d1.fitrmin)
self.assertEqual(7.0, d1.fitrmax)
exec "pdfrange('ALL', 2.0, 9.0)" in sandbox
self.assertEqual(2.0, d0.fitrmin)
self.assertEqual(9.0, d0.fitrmax)
self.assertEqual(2.0, d1.fitrmin)
self.assertEqual(9.0, d1.fitrmax)
return
def test_refine(self):
"""check PdfFitSandbox.refine()
"""
fNi_stru = datafile('Ni.stru')
fNi_data = datafile("Ni_2-8.chi.gr")
sandbox = self.box.sandbox()
sandbox.update({ "fNi_stru" : fNi_stru, "fNi_data" : fNi_data })
exec "read_data(fNi_data, X, 40.1, 0.05)" in sandbox
exec "read_struct(fNi_stru)" in sandbox
exec "refine()" in sandbox
self.assertEqual(2, len(self.box._fits))
self.assertEqual(1, len(self.box._fits[0].strucs))
self.assertEqual(1, len(self.box._fits[0].datasets))
self.assertEqual(1, len(self.box._fits[1].strucs))
self.assertEqual(1, len(self.box._fits[1].datasets))
# check fit linking:
self.box._fits[-1].parameters[1] = Parameter(1, 0.05)
exec "refine(0.01)" in sandbox
self.assertEqual(3, len(self.box._fits))
names = [ f.name for f in self.box._fits ]
self.assertEqual('0', names[0])
self.assertEqual('1', names[1])
self.assertEqual('2', names[2])
self.assertEqual(0, self.box._curdataset)
self.assertEqual(0, self.box._curphase)
s = self.box._fits[-1].parameters[1].initialStr()
self.assertEqual("=1:1", s)
return
def test_read_data_string(self):
"""check PdfFitSandbox.read_data_string()
"""
fNi_data = datafile("Ni_2-8.chi.gr")
f300K_data = datafile("300K.gr")
sNi = open(fNi_data).read()
s300K = open(f300K_data).read()
sandbox = self.box.sandbox()
sandbox.update({"sNi": sNi, "s300K": s300K})
exec "read_data_string(sNi, X, 40.1, 0.05)" in sandbox
exec "read_data_string(s300K, N, 32.1, 0.05, 'LaMnO3')" in sandbox
self.assertEqual(2, len(self.box._fits[-1].datasets))
self.assertEqual(1, self.box._curdataset)
d0 = self.box._fits[-1].datasets[0]
self.assertEqual('', d0.name)
self.assertEqual('X', d0.stype)
self.assertAlmostEqual(40.1, d0.qmax, 8)
self.assertAlmostEqual(0.05, d0.qdamp, 8)
self.assertEqual(2000, len(d0.robs))
d1 = self.box._fits[-1].datasets[1]
self.assertEqual('LaMnO3', d1.name)
self.assertEqual('N', d1.stype)
self.assertAlmostEqual(32.1, d1.qmax, 8)
self.assertAlmostEqual(0.05, d1.qdamp, 8)
self.assertEqual(2000, len(d1.robs))
self.assertEqual(None, self.box._curphase)
return
def test_read(self):
"""check PDFDataSet.read()
"""
# neutron data -------------------------------------------------
fn_550K = datafile('550K.gr')
self.pdfds.read(fn_550K)
self.assertEqual('N', self.pdfds.stype)
self.assertEqual(32.0, self.pdfds.qmax)
# there are 2000 points in the file
npts = len(self.pdfds.robs)
self.assertEqual(2000, npts)
# drobs are all zero
self.assertEqual(npts*[0.0], self.pdfds.drobs)
# dGobs should be defined
self.assertTrue(min(self.pdfds.dGobs) > 0)
# x-ray data ---------------------------------------------------
fx_Ni = datafile('Ni_2-8.chi.gr')
self.pdfds.read(fx_Ni)
self.assertEqual('X', self.pdfds.stype)
self.assertEqual(40.0, self.pdfds.qmax)
# there are 2000 points in the file
npts = len(self.pdfds.robs)
self.assertEqual(2000, npts)
# drobs are all zero
self.assertEqual(npts*[0.0], self.pdfds.drobs)
# dGobs should be defined
self.assertTrue(min(self.pdfds.dGobs) > 0)
return
def test_refine(self):
"""check PdfFitSandbox.refine()
"""
fNi_stru = datafile('Ni.stru')
fNi_data = datafile("Ni_2-8.chi.gr")
sandbox = self.box.sandbox()
sandbox.update({"fNi_stru": fNi_stru, "fNi_data": fNi_data})
exec "read_data(fNi_data, X, 40.1, 0.05)" in sandbox
exec "read_struct(fNi_stru)" in sandbox
exec "refine()" in sandbox
self.assertEqual(2, len(self.box._fits))
self.assertEqual(1, len(self.box._fits[0].strucs))
self.assertEqual(1, len(self.box._fits[0].datasets))
self.assertEqual(1, len(self.box._fits[1].strucs))
self.assertEqual(1, len(self.box._fits[1].datasets))
# check fit linking:
self.box._fits[-1].parameters[1] = Parameter(1, 0.05)
exec "refine(0.01)" in sandbox
self.assertEqual(3, len(self.box._fits))
names = [f.name for f in self.box._fits]
self.assertEqual('0', names[0])
self.assertEqual('1', names[1])
self.assertEqual('2', names[2])
self.assertEqual(0, self.box._curdataset)
self.assertEqual(0, self.box._curphase)
s = self.box._fits[-1].parameters[1].initialStr()
self.assertEqual("=1:1", s)
return
def test_setpar(self):
"""check PdfFitSandbox.setpar()
"""
sandbox = self.box.sandbox()
curfit = self.box._fits[-1]
self.box.setpar(1, 5.0)
self.assertEqual(5.0, curfit.parameters[1].initialValue())
fNi_stru = datafile('Ni.stru')
fNi_data = datafile("Ni_2-8.chi.gr")
self.box.read_struct(fNi_stru)
self.box.read_data(fNi_data, "X", 40.1, 0.05)
exec 'constrain(dscale, 1)' in sandbox
exec 'constrain(lat(1), 3)' in sandbox
exec 'constrain(lat(2), 3)' in sandbox
exec 'constrain(lat(3), "@3")' in sandbox
exec 'setpar(1, 1.25)' in sandbox
exec 'setpar(3, 4.1)' in sandbox
self.assertEqual(1.25, curfit.parameters[1].initialValue())
self.assertEqual(4.1, curfit.parameters[3].initialValue())
exec 'setpar(1, dscale)' in sandbox
exec 'setpar(3, lat(1))' in sandbox
dscale = curfit.datasets[self.box._curdataset].dscale
a = curfit.strucs[self.box._curphase].lattice.a
self.assertEqual(dscale, curfit.parameters[1].initialValue())
self.assertEqual(a, curfit.parameters[3].initialValue())
return
def test_read_data(self):
"""check PdfFitSandbox.read_data()
"""
fNi_data = datafile("Ni_2-8.chi.gr")
f300K_data = datafile("300K.gr")
sandbox = self.box.sandbox()
sandbox.update({ "fNi_data" : fNi_data, "f300K_data" : f300K_data })
exec "read_data(fNi_data, X, 40.1, 0.05)" in sandbox
exec "read_data(f300K_data, N, 32.1, 0.05)" in sandbox
self.assertEqual(2, len(self.box._fits[-1].datasets))
self.assertEqual(1, self.box._curdataset)
d0 = self.box._fits[-1].datasets[0]
self.assertEqual('Ni_2-8.chi', d0.name)
self.assertEqual('X', d0.stype)
self.assertAlmostEqual(40.1, d0.qmax, 8)
self.assertAlmostEqual(0.05, d0.qdamp, 8)
self.assertEqual(2000, len(d0.robs))
d1 = self.box._fits[-1].datasets[1]
self.assertEqual('300K', d1.name)
self.assertEqual('N', d1.stype)
self.assertAlmostEqual(32.1, d1.qmax, 8)
self.assertAlmostEqual(0.05, d1.qdamp, 8)
self.assertEqual(2000, len(d1.robs))
self.assertEqual(None, self.box._curphase)
return
def test_read_data_string(self):
"""check PdfFitSandbox.read_data_string()
"""
fNi_data = datafile("Ni_2-8.chi.gr")
f300K_data = datafile("300K.gr")
sNi = open(fNi_data).read()
s300K = open(f300K_data).read()
sandbox = self.box.sandbox()
sandbox.update({ "sNi" : sNi, "s300K" : s300K })
exec "read_data_string(sNi, X, 40.1, 0.05)" in sandbox
exec "read_data_string(s300K, N, 32.1, 0.05, 'LaMnO3')" in sandbox
self.assertEqual(2, len(self.box._fits[-1].datasets))
self.assertEqual(1, self.box._curdataset)
d0 = self.box._fits[-1].datasets[0]
self.assertEqual('', d0.name)
self.assertEqual('X', d0.stype)
self.assertAlmostEqual(40.1, d0.qmax, 8)
self.assertAlmostEqual(0.05, d0.qdamp, 8)
self.assertEqual(2000, len(d0.robs))
d1 = self.box._fits[-1].datasets[1]
self.assertEqual('LaMnO3', d1.name)
self.assertEqual('N', d1.stype)
self.assertAlmostEqual(32.1, d1.qmax, 8)
self.assertAlmostEqual(0.05, d1.qdamp, 8)
self.assertEqual(2000, len(d1.robs))
self.assertEqual(None, self.box._curphase)
return
def test_setvar(self):
"""check PdfFitSandbox.setvar()
"""
sandbox = self.box.sandbox()
fNi_stru = datafile('Ni.stru')
fNi_data = datafile("Ni_2-8.chi.gr")
self.box.read_struct(fNi_stru)
self.box.read_data(fNi_data, "X", 40.1, 0.05)
curfit = self.box._fits[-1]
curdataset = curfit.datasets[self.box._curdataset]
curphase = curfit.strucs[self.box._curphase]
self.assertEqual(40.1, curdataset.qmax)
exec "setvar(qdamp, 0.007)" in sandbox
exec "setvar(lat(1), 3.75)" in sandbox
exec "setvar(x(4), 0.123)" in sandbox
exec "setvar(u13(1), 0.00123)" in sandbox
exec "setvar('pscale', 0.97)" in sandbox
self.assertEqual(0.007, curdataset.qdamp)
self.assertEqual(3.75, curphase.lattice.a)
self.assertEqual(0.123, curphase[3].xyz[0])
self.assertEqual(0.00123, curphase[0].U[0,2])
self.assertEqual(0.00123, curphase[0].U[2,0])
self.assertEqual(0.97, curphase.pdffit['scale'])
self.assertRaises(ControlKeyError, self.box.setvar, 'novar', 0.1)
return
def test_pdfrange(self):
"""check PdfFitSandbox.pdfrange()
"""
fNi_data = datafile("Ni_2-8.chi.gr")
f300K_data = datafile("300K.gr")
self.box.read_data(fNi_data, 'X', 40.1, 0.05)
self.box.read_data(f300K_data, 'N', 32.1, 0.05)
sandbox = self.box.sandbox()
exec "pdfrange(1, 2.3, 11.13)" in sandbox
exec "pdfrange(2, 5.7, 17.19)" in sandbox
self.assertEqual(2, len(self.box._fits[-1].datasets))
d0 = self.box._fits[-1].datasets[0]
d1 = self.box._fits[-1].datasets[1]
self.assertAlmostEqual(2.3, d0.fitrmin, 8)
self.assertAlmostEqual(11.13, d0.fitrmax, 8)
self.assertAlmostEqual(5.7, d1.fitrmin, 8)
self.assertAlmostEqual(17.19, d1.fitrmax, 8)
# exceptions for invalid ranges
self.assertRaises(ControlRuntimeError, self.box.pdfrange, 1, 10, 1)
self.assertRaises(ControlRuntimeError, self.box.pdfrange, 1, 0, 10)
self.assertRaises(ControlRuntimeError, self.box.pdfrange, 1, 1, 1000)
exec "pdfrange(ALL, 1.0, 7.0)" in sandbox
self.assertEqual(1.0, d0.fitrmin)
self.assertEqual(7.0, d0.fitrmax)
self.assertEqual(1.0, d1.fitrmin)
self.assertEqual(7.0, d1.fitrmax)
exec "pdfrange('ALL', 2.0, 9.0)" in sandbox
self.assertEqual(2.0, d0.fitrmin)
self.assertEqual(9.0, d0.fitrmax)
self.assertEqual(2.0, d1.fitrmin)
self.assertEqual(9.0, d1.fitrmax)
return
def test_setvar(self):
"""check PdfFitSandbox.setvar()
"""
sandbox = self.box.sandbox()
fNi_stru = datafile('Ni.stru')
fNi_data = datafile("Ni_2-8.chi.gr")
self.box.read_struct(fNi_stru)
self.box.read_data(fNi_data, "X", 40.1, 0.05)
curfit = self.box._fits[-1]
curdataset = curfit.datasets[self.box._curdataset]
curphase = curfit.strucs[self.box._curphase]
self.assertEqual(40.1, curdataset.qmax)
exec "setvar(qdamp, 0.007)" in sandbox
exec "setvar(lat(1), 3.75)" in sandbox
exec "setvar(x(4), 0.123)" in sandbox
exec "setvar(u13(1), 0.00123)" in sandbox
exec "setvar('pscale', 0.97)" in sandbox
self.assertEqual(0.007, curdataset.qdamp)
self.assertEqual(3.75, curphase.lattice.a)
self.assertEqual(0.123, curphase[3].xyz[0])
self.assertEqual(0.00123, curphase[0].U[0, 2])
self.assertEqual(0.00123, curphase[0].U[2, 0])
self.assertEqual(0.97, curphase.pdffit['scale'])
self.assertRaises(ControlKeyError, self.box.setvar, 'novar', 0.1)
return
def test_setpar(self):
"""check PdfFitSandbox.setpar()
"""
sandbox = self.box.sandbox()
curfit = self.box._fits[-1]
self.box.setpar(1, 5.0)
self.assertEqual(5.0, curfit.parameters[1].initialValue())
fNi_stru = datafile('Ni.stru')
fNi_data = datafile("Ni_2-8.chi.gr")
self.box.read_struct(fNi_stru)
self.box.read_data(fNi_data, "X", 40.1, 0.05)
exec 'constrain(dscale, 1)' in sandbox
exec 'constrain(lat(1), 3)' in sandbox
exec 'constrain(lat(2), 3)' in sandbox
exec 'constrain(lat(3), "@3")' in sandbox
exec 'setpar(1, 1.25)' in sandbox
exec 'setpar(3, 4.1)' in sandbox
self.assertEqual(1.25, curfit.parameters[1].initialValue())
self.assertEqual(4.1, curfit.parameters[3].initialValue())
exec 'setpar(1, dscale)' in sandbox
exec 'setpar(3, lat(1))' in sandbox
dscale = curfit.datasets[self.box._curdataset].dscale
a = curfit.strucs[self.box._curphase].lattice.a
self.assertEqual(dscale, curfit.parameters[1].initialValue())
self.assertEqual(a, curfit.parameters[3].initialValue())
return
def setUp(self):
# load project files once
if TestLoadProject.prj_lcmo is None:
TestLoadProject.prj_lcmo = LoadProject(datafile("lcmo.ddp"))
TestLoadProject.prj_lcmo_full = LoadProject(datafile("lcmo_full.ddp"))
TestLoadProject.prj_ni = LoadProject(datafile("ni.ddp"))
# assign them to this instance
self.prj_lcmo = TestLoadProject.prj_lcmo
self.prj_lcmo_full = TestLoadProject.prj_lcmo_full
self.prj_ni = TestLoadProject.prj_ni
return
def setUp(self):
# load project files once
if TestLoadProject.prj_lcmo is None:
TestLoadProject.prj_lcmo = LoadProject(datafile('lcmo.ddp'))
TestLoadProject.prj_lcmo_full = LoadProject(
datafile('lcmo_full.ddp'))
TestLoadProject.prj_ni = LoadProject(datafile('ni.ddp'))
# assign them to this instance
self.prj_lcmo = TestLoadProject.prj_lcmo
self.prj_lcmo_full = TestLoadProject.prj_lcmo_full
self.prj_ni = TestLoadProject.prj_ni
return
def test_getvar(self):
"""check PdfFitSandbox.getvar()
"""
sandbox = self.box.sandbox()
f300K_stru = datafile('300K.stru')
f300K_data = datafile("300K.gr")
sandbox.update({"f300K_stru": f300K_stru, "f300K_data": f300K_data})
exec "read_data(f300K_data, 'N', 32.1, 0.05)" in sandbox
exec "read_struct(f300K_stru)" in sandbox
self.assertEqual(0.05, eval("getvar(qdamp)", sandbox))
self.assertEqual(1.0, eval("getvar('dscale')", sandbox))
self.assertEqual(1.0, eval("getvar(dscale)", sandbox))
self.assertAlmostEqual(0.95182216, eval("getvar(y(3))", sandbox), 8)
self.assertAlmostEqual(0.00475572, eval("getvar(u22(4))", sandbox), 8)
self.assertRaises(ControlKeyError, self.box.getvar, 'novar')
return
def test_getvar(self):
"""check PdfFitSandbox.getvar()
"""
sandbox = self.box.sandbox()
f300K_stru = datafile('300K.stru')
f300K_data = datafile("300K.gr")
sandbox.update({"f300K_stru" : f300K_stru, "f300K_data" : f300K_data})
exec "read_data(f300K_data, 'N', 32.1, 0.05)" in sandbox
exec "read_struct(f300K_stru)" in sandbox
self.assertEqual(0.05, eval("getvar(qdamp)", sandbox))
self.assertEqual(1.0, eval("getvar('dscale')", sandbox))
self.assertEqual(1.0, eval("getvar(dscale)", sandbox))
self.assertAlmostEqual(0.95182216, eval("getvar(y(3))", sandbox), 8)
self.assertAlmostEqual(0.00475572, eval("getvar(u22(4))", sandbox), 8)
self.assertRaises(ControlKeyError, self.box.getvar, 'novar')
return
def test_getPairSelectionFlags(self):
"""check FitStructure.getPairSelectionFlags()
"""
cdse = self.stru
cdse.read(datafile('CdSe_bulk_wur.stru'), format='pdffit')
self.assertEqual('all-all', cdse.getSelectedPairs())
psf = cdse.getPairSelectionFlags()
self.assertEqual(4 * [True], psf['firstflags'])
self.assertEqual(4 * [True], psf['secondflags'])
psf = cdse.getPairSelectionFlags('Cd-Cd')
self.assertEqual(2 * [True] + 2 * [False], psf['firstflags'])
self.assertEqual(psf['firstflags'], psf['secondflags'])
psf = cdse.getPairSelectionFlags('all-all, !Cd-')
self.assertEqual(2 * [False] + 2 * [True], psf['firstflags'])
self.assertEqual(4 * [True], psf['secondflags'])
psf = cdse.getPairSelectionFlags('all-all, -!Cd')
self.assertEqual(4 * [True], psf['firstflags'])
self.assertEqual(2 * [False] + 2 * [True], psf['secondflags'])
psf = cdse.getPairSelectionFlags('Cd-3:4')
self.assertEqual(2 * [True] + 2 * [False], psf['firstflags'])
self.assertEqual(2 * [False] + 2 * [True], psf['secondflags'])
psf = cdse.getPairSelectionFlags('all-all, !Se-!Se')
self.assertEqual(2 * [True] + 2 * [False], psf['firstflags'])
self.assertEqual(2 * [True] + 2 * [False], psf['secondflags'])
psf = cdse.getPairSelectionFlags('all-all, !Se-, -!Se')
self.assertEqual(2 * [True] + 2 * [False], psf['firstflags'])
self.assertEqual(2 * [True] + 2 * [False], psf['secondflags'])
psf = cdse.getPairSelectionFlags('1-all')
self.assertEqual([True] + 3 * [False], psf['firstflags'])
self.assertEqual(4 * [True], psf['secondflags'])
return
def test_alloc(self):
"""check PdfFitSandbox.alloc()
"""
from diffpy.pdfgui.control.calculation import Calculation
from diffpy.pdfgui.control.fitting import Fitting
fNi_stru = datafile('Ni.stru')
sandbox = self.box.sandbox()
sandbox.update({"fNi_stru": fNi_stru})
exec "read_struct(fNi_stru)" in sandbox
self.assertEqual(1, len(self.box._fits))
self.assertEqual(1, len(self.box._fits[-1].strucs))
self.assertEqual(0, len(self.box._fits[-1].datasets))
self.assertTrue(isinstance(self.box._fits[-1], Fitting))
exec "alloc(N, 37.0, 0.07, 0.01, 10.0, 1000)" in sandbox
self.assertEqual(1, len(self.box._fits))
self.assertEqual(1, len(self.box._fits[-1].strucs))
self.assertTrue(isinstance(self.box._fits[-1], Calculation))
c = self.box._fits[-1]
self.assertEqual(37.0, c.qmax)
self.assertEqual(0.07, c.qdamp)
self.assertEqual(0.01, c.rmin)
self.assertAlmostEqual(0.01, c.rstep, 8)
self.assertAlmostEqual(10.0, c.rmax, 8)
self.assertEqual(1000, c.rlen)
return
def test_getPairSelectionFlags(self):
"""check FitStructure.getPairSelectionFlags()
"""
cdse = self.stru
cdse.read(datafile('CdSe_bulk_wur.stru'), format='pdffit')
self.assertEqual('all-all', cdse.getSelectedPairs())
psf = cdse.getPairSelectionFlags()
self.assertEqual(4 * [True], psf['firstflags'])
self.assertEqual(4 * [True], psf['secondflags'])
psf = cdse.getPairSelectionFlags('Cd-Cd')
self.assertEqual(2 * [True] + 2 * [False], psf['firstflags'])
self.assertEqual(psf['firstflags'], psf['secondflags'])
psf = cdse.getPairSelectionFlags('all-all, !Cd-')
self.assertEqual(2 * [False] + 2 * [True], psf['firstflags'])
self.assertEqual(4 * [True], psf['secondflags'])
psf = cdse.getPairSelectionFlags('all-all, -!Cd')
self.assertEqual(4 * [True], psf['firstflags'])
self.assertEqual(2 * [False] + 2 * [True], psf['secondflags'])
psf = cdse.getPairSelectionFlags('Cd-3:4')
self.assertEqual(2 * [True] + 2 * [False], psf['firstflags'])
self.assertEqual(2 * [False] + 2 * [True], psf['secondflags'])
psf = cdse.getPairSelectionFlags('all-all, !Se-!Se')
self.assertEqual(2 * [True] + 2 * [False], psf['firstflags'])
self.assertEqual(2 * [True] + 2 * [False], psf['secondflags'])
psf = cdse.getPairSelectionFlags('all-all, !Se-, -!Se')
self.assertEqual(2 * [True] + 2 * [False], psf['firstflags'])
self.assertEqual(2 * [True] + 2 * [False], psf['secondflags'])
psf = cdse.getPairSelectionFlags('1-all')
self.assertEqual([True] + 3 * [False], psf['firstflags'])
self.assertEqual(4 * [True], psf['secondflags'])
return
def setUp(self):
self.app = wx.App()
self.frame = wx.Frame(None)
self.panel = DopingSeriesPanel(self.frame)
self.panel.mainFrame = self._mockUpMainFrame()
self.panel.mainFrame.workpath = datafile('')
return
def test_alloc(self):
"""check PdfFitSandbox.alloc()
"""
from diffpy.pdfgui.control.calculation import Calculation
from diffpy.pdfgui.control.fitting import Fitting
fNi_stru = datafile('Ni.stru')
sandbox = self.box.sandbox()
sandbox.update({ "fNi_stru" : fNi_stru })
exec "read_struct(fNi_stru)" in sandbox
self.assertEqual(1, len(self.box._fits))
self.assertEqual(1, len(self.box._fits[-1].strucs))
self.assertEqual(0, len(self.box._fits[-1].datasets))
self.failUnless(isinstance(self.box._fits[-1], Fitting))
exec "alloc(N, 37.0, 0.07, 0.01, 10.0, 1000)" in sandbox
self.assertEqual(1, len(self.box._fits))
self.assertEqual(1, len(self.box._fits[-1].strucs))
self.failUnless(isinstance(self.box._fits[-1], Calculation))
c = self.box._fits[-1]
self.assertEqual(37.0, c.qmax)
self.assertEqual(0.07, c.qdamp)
self.assertEqual(0.01, c.rmin)
self.assertAlmostEqual(0.01, c.rstep, 8)
self.assertAlmostEqual(10.0, c.rmax, 8)
self.assertEqual(1000, c.rlen)
return
def test_read(self):
"""check PDFStructure.read()
"""
stru = self.stru
notastructurefile = datafile('300K.gr')
self.assertRaises(ControlFileError,
stru.read, notastructurefile, format='pdffit')
return
def test(self):
'''Testing code goes here'''
project = LoadProject(datafile('lcmo.ddp'))
fstru = project.getPhases()[0]
self.window.configuration = fstru
self.window.results = fstru.refined
self.window.constraints = fstru.constraints
self.window.refresh()
def test_read_struct(self):
"""check PdfFitSandbox.read_struct()
"""
fNi_stru = datafile('Ni.stru')
f300K_stru = datafile('300K.stru')
self.box.read_struct(fNi_stru)
self.box.read_struct(f300K_stru)
self.assertEqual(2, len(self.box._fits[-1].strucs))
self.assertEqual(1, self.box._curphase)
p0 = self.box._fits[-1].strucs[0]
p1 = self.box._fits[-1].strucs[1]
self.assertEqual(4, len(p0))
self.assertEqual('Ni', p0.name)
self.assertEqual(20, len(p1))
self.assertEqual('300K', p1.name)
self.assertEqual(None, self.box._curdataset)
return
def test_read_struct(self):
"""check PdfFitSandbox.read_struct()
"""
fNi_stru = datafile('Ni.stru')
f300K_stru = datafile('300K.stru')
self.box.read_struct(fNi_stru)
self.box.read_struct(f300K_stru)
self.assertEqual(2, len(self.box._fits[-1].strucs))
self.assertEqual(1, self.box._curphase)
p0 = self.box._fits[-1].strucs[0]
p1 = self.box._fits[-1].strucs[1]
self.assertEqual(4, len(p0))
self.assertEqual('Ni', p0.name)
self.assertEqual(20, len(p1))
self.assertEqual('300K', p1.name)
self.assertEqual(None, self.box._curdataset)
return
def test_read(self):
"""check PDFStructure.read()
"""
stru = self.stru
notastructurefile = datafile('300K.gr')
self.assertRaises(ControlFileError,
stru.read, notastructurefile, format='pdffit')
return
def test(self):
'''Testing code goes here'''
project = LoadProject(datafile('lcmo.ddp'))
fstru = project.getPhases()[0]
self.window.configuration = fstru
self.window.results = fstru.refined
self.window.constraints = fstru.constraints
self.window.refresh()
def test_num_atoms(self):
"""check PdfFitSandbox.num_atoms()
"""
self.assertRaises(ControlKeyError, self.box.num_atoms)
sandbox = self.box.sandbox()
fNi_stru = datafile('Ni.stru')
self.box.read_struct(fNi_stru)
self.assertEqual(4, eval('num_atoms()', sandbox))
return
def test_getpar(self):
"""check PdfFitSandbox.getpar()
"""
sandbox = self.box.sandbox()
curfit = self.box._fits[-1]
self.box.setpar(1, 5.0)
self.assertEqual(5.0, eval('getpar(1)', sandbox))
fNi_stru = datafile('Ni.stru')
fNi_data = datafile("Ni_2-8.chi.gr")
self.box.read_struct(fNi_stru)
self.box.read_data(fNi_data, "X", 40.1, 0.05)
exec 'setpar(1, dscale)' in sandbox
exec 'setpar(3, lat(1))' in sandbox
self.assertEqual(1.0, eval('getpar(1)', sandbox))
curphase = curfit.strucs[self.box._curphase]
a = curphase.lattice.a
self.assertEqual(a, eval('getpar(3)', sandbox))
return
def test_num_atoms(self):
"""check PdfFitSandbox.num_atoms()
"""
self.assertRaises(ControlKeyError, self.box.num_atoms)
sandbox = self.box.sandbox()
fNi_stru = datafile('Ni.stru')
self.box.read_struct(fNi_stru)
self.assertEqual(4, eval('num_atoms()', sandbox))
return
def setUpClass(cls):
GUITestCase.setUpClass()
GUITestCase.setCmdArgs([datafile("lcmo.ddp")])
cls.app = wx.App()
cls.frame = MainFrame(None, -1, "")
tree = cls.frame.treeCtrlMain
fits = tree.GetChildren(tree.root)
cls.frame.makeTreeSelection(fits[0])
return
def test_getpar(self):
"""check PdfFitSandbox.getpar()
"""
sandbox = self.box.sandbox()
curfit = self.box._fits[-1]
self.box.setpar(1, 5.0)
self.assertEqual(5.0, eval('getpar(1)', sandbox))
fNi_stru = datafile('Ni.stru')
fNi_data = datafile("Ni_2-8.chi.gr")
self.box.read_struct(fNi_stru)
self.box.read_data(fNi_data, "X", 40.1, 0.05)
exec 'setpar(1, dscale)' in sandbox
exec 'setpar(3, lat(1))' in sandbox
self.assertEqual(1.0, eval('getpar(1)', sandbox))
curphase = curfit.strucs[self.box._curphase]
a = curphase.lattice.a
self.assertEqual(a, eval('getpar(3)', sandbox))
return
def test_onAdd(self):
"Check TemperatureSeriesPanel.onAdd"
panel = self.panel
paths = ['T017K.gr', '137K.gr', 'lcmo_00.gr', 'lcmo_20.gr']
paths = [datafile(p) for p in paths]
with overridefiledialog(wx.ID_OK, paths):
panel.onAdd(None)
self.assertEqual(paths[-1], panel.fullpath)
self.assertEqual([17, 137, 10, 10], [tf[0] for tf in panel.datasets])
return
def test_allfits(self):
"""check PdfFitSandbox.allfits()
"""
self.assertEqual(0, len(self.box.allfits()))
fNi_stru = datafile('Ni.stru')
self.box.read_struct(fNi_stru)
self.assertEqual(0, len(self.box.allfits()))
self.box.refine()
self.assertEqual(1, len(self.box.allfits()))
return
def test_importPdffit2Script(self):
"""check PDFGuiControl.importPdffit2Script()
"""
self.assertEqual(0, len(self.control.fits))
fgoodNi = datafile('goodNiScript.py')
ftwophases = datafile('CdSe15_twophases.py')
fbadNi1 = datafile('badNiScript1.py')
fbadNi2 = datafile('badNiScript2.py')
newfits = self.control.importPdffit2Script(fgoodNi)
self.assertEqual(1, len(newfits))
self.assertEqual(1, len(self.control.fits))
newfits = self.control.importPdffit2Script(ftwophases)
self.assertEqual(5, len(newfits))
self.assertEqual(6, len(self.control.fits))
self.assertRaises(ControlRuntimeError,
self.control.importPdffit2Script, fbadNi1)
self.assertRaises(ControlRuntimeError,
self.control.importPdffit2Script, fbadNi2)
return
def test_importPdffit2Script(self):
"""check PDFGuiControl.importPdffit2Script()
"""
self.assertEqual(0, len(self.control.fits))
fgoodNi = datafile('goodNiScript.py')
ftwophases = datafile('CdSe15_twophases.py')
fbadNi1 = datafile('badNiScript1.py')
fbadNi2 = datafile('badNiScript2.py')
newfits = self.control.importPdffit2Script(fgoodNi)
self.assertEqual(1, len(newfits))
self.assertEqual(1, len(self.control.fits))
newfits = self.control.importPdffit2Script(ftwophases)
self.assertEqual(5, len(newfits))
self.assertEqual(6, len(self.control.fits))
self.assertRaises(ControlRuntimeError,
self.control.importPdffit2Script, fbadNi1)
self.assertRaises(ControlRuntimeError,
self.control.importPdffit2Script, fbadNi2)
return
def test_onAdd(self):
"Check DopingSeriesPanel.onAdd"
panel = self.panel
paths = ['x000.gr', 'x020.gr', 'lcmo_00.gr', 'lcmo_20.gr']
paths = [datafile(p) for p in paths]
with overridefiledialog(wx.ID_OK, paths):
panel.onAdd(None)
self.assertEqual(paths[-1], panel.fullpath)
self.assertEqual([0, 20, 0, 0.2], [xf[0] for xf in panel.datasets])
return
def test_read_struct_string(self):
"""check PdfFitSandbox.read_struct_string()
"""
fNi_stru = datafile('Ni.stru')
f300K_stru = datafile('300K.stru')
sNi = open(fNi_stru).read()
s300K = open(f300K_stru).read()
self.box.read_struct_string(sNi)
self.box.read_struct_string(s300K, 'LaMnO3 at 300K')
self.assertEqual(2, len(self.box._fits[-1].strucs))
self.assertEqual(1, self.box._curphase)
p0 = self.box._fits[-1].strucs[0]
p1 = self.box._fits[-1].strucs[1]
self.assertEqual(4, len(p0))
self.assertEqual('', p0.name)
self.assertEqual(20, len(p1))
self.assertEqual('LaMnO3 at 300K', p1.name)
self.assertEqual(None, self.box._curdataset)
return
def test_allfits(self):
"""check PdfFitSandbox.allfits()
"""
self.assertEqual(0, len(self.box.allfits()))
fNi_stru = datafile('Ni.stru')
self.box.read_struct(fNi_stru)
self.assertEqual(0, len(self.box.allfits()))
self.box.refine()
self.assertEqual(1, len(self.box.allfits()))
return
def test_read_struct_string(self):
"""check PdfFitSandbox.read_struct_string()
"""
fNi_stru = datafile('Ni.stru')
f300K_stru = datafile('300K.stru')
sNi = open(fNi_stru).read()
s300K = open(f300K_stru).read()
self.box.read_struct_string(sNi)
self.box.read_struct_string(s300K, 'LaMnO3 at 300K')
self.assertEqual(2, len(self.box._fits[-1].strucs))
self.assertEqual(1, self.box._curphase)
p0 = self.box._fits[-1].strucs[0]
p1 = self.box._fits[-1].strucs[1]
self.assertEqual(4, len(p0))
self.assertEqual('', p0.name)
self.assertEqual(20, len(p1))
self.assertEqual('LaMnO3 at 300K', p1.name)
self.assertEqual(None, self.box._curdataset)
return
def test_setphase(self):
"""check PdfFitSandbox.setphase()
"""
sandbox = self.box.sandbox()
fNi_stru = datafile('Ni.stru')
f300K_stru = datafile('300K.stru')
self.assertEqual(None, self.box._curphase)
self.box.read_struct(fNi_stru)
self.assertEqual(0, self.box._curphase)
self.box.read_struct(f300K_stru)
self.assertEqual(1, self.box._curphase)
self.assertEqual(20, eval("num_atoms()", sandbox))
exec "setphase(1)" in sandbox
self.assertEqual(0, self.box._curphase)
self.assertEqual(4, eval("num_atoms()", sandbox))
exec "setphase(2)" in sandbox
self.assertEqual(1, self.box._curphase)
self.assertEqual(20, eval("num_atoms()", sandbox))
self.assertRaises(IndexError, self.box.setphase, 3)
return
def test_setdata(self):
"""check PdfFitSandbox.setdata()
"""
sandbox = self.box.sandbox()
fNi_data = datafile("Ni_2-8.chi.gr")
f300K_data = datafile("300K.gr")
self.assertEqual(None, self.box._curdataset)
self.box.read_data(fNi_data, "X", 40.1, 0.05)
self.assertEqual(0, self.box._curdataset)
self.box.read_data(f300K_data, 'N', 32.1, 0.07)
self.assertEqual(1, self.box._curdataset)
self.assertEqual(0.07, eval("getvar('qdamp')", sandbox))
exec "setdata(1)" in sandbox
self.assertEqual(0, self.box._curdataset)
self.assertEqual(0.05, eval("getvar('qdamp')", sandbox))
exec "setdata(2)" in sandbox
self.assertEqual(1, self.box._curdataset)
self.assertEqual(0.07, eval("getvar('qdamp')", sandbox))
self.assertRaises(IndexError, self.box.setdata, 3)
return
def test_setphase(self):
"""check PdfFitSandbox.setphase()
"""
sandbox = self.box.sandbox()
fNi_stru = datafile('Ni.stru')
f300K_stru = datafile('300K.stru')
self.assertEqual(None, self.box._curphase)
self.box.read_struct(fNi_stru)
self.assertEqual(0, self.box._curphase)
self.box.read_struct(f300K_stru)
self.assertEqual(1, self.box._curphase)
self.assertEqual(20, eval("num_atoms()", sandbox))
exec "setphase(1)" in sandbox
self.assertEqual(0, self.box._curphase)
self.assertEqual(4, eval("num_atoms()", sandbox))
exec "setphase(2)" in sandbox
self.assertEqual(1, self.box._curphase)
self.assertEqual(20, eval("num_atoms()", sandbox))
self.assertRaises(IndexError, self.box.setphase, 3)
return
def test_setdata(self):
"""check PdfFitSandbox.setdata()
"""
sandbox = self.box.sandbox()
fNi_data = datafile("Ni_2-8.chi.gr")
f300K_data = datafile("300K.gr")
self.assertEqual(None, self.box._curdataset)
self.box.read_data(fNi_data, "X", 40.1, 0.05)
self.assertEqual(0, self.box._curdataset)
self.box.read_data(f300K_data, 'N', 32.1, 0.07)
self.assertEqual(1, self.box._curdataset)
self.assertEqual(0.07, eval("getvar('qdamp')", sandbox))
exec "setdata(1)" in sandbox
self.assertEqual(0, self.box._curdataset)
self.assertEqual(0.05, eval("getvar('qdamp')", sandbox))
exec "setdata(2)" in sandbox
self.assertEqual(1, self.box._curdataset)
self.assertEqual(0.07, eval("getvar('qdamp')", sandbox))
self.assertRaises(IndexError, self.box.setdata, 3)
return
def test_reset(self):
"""check PdfFitSandbox.reset()
"""
fNi_stru = datafile('Ni.stru')
fNi_data = datafile("Ni_2-8.chi.gr")
sandbox = self.box.sandbox()
sandbox.update({"fNi_stru": fNi_stru, "fNi_data": fNi_data})
exec "read_data(fNi_data, X, 40.1, 0.05)" in sandbox
exec "read_struct(fNi_stru)" in sandbox
self.assertEqual(1, len(self.box._fits))
self.assertEqual(1, len(self.box._fits[-1].strucs))
self.assertEqual(1, len(self.box._fits[-1].datasets))
self.assertEqual(0, self.box._curdataset)
self.assertEqual(0, self.box._curphase)
exec "reset()" in sandbox
self.assertEqual(1, len(self.box._fits))
self.assertEqual(0, len(self.box._fits[-1].strucs))
self.assertEqual(0, len(self.box._fits[-1].datasets))
self.assertEqual(None, self.box._curdataset)
self.assertEqual(None, self.box._curphase)
return
def test_reset(self):
"""check PdfFitSandbox.reset()
"""
fNi_stru = datafile('Ni.stru')
fNi_data = datafile("Ni_2-8.chi.gr")
sandbox = self.box.sandbox()
sandbox.update({ "fNi_stru" : fNi_stru, "fNi_data" : fNi_data })
exec "read_data(fNi_data, X, 40.1, 0.05)" in sandbox
exec "read_struct(fNi_stru)" in sandbox
self.assertEqual(1, len(self.box._fits))
self.assertEqual(1, len(self.box._fits[-1].strucs))
self.assertEqual(1, len(self.box._fits[-1].datasets))
self.assertEqual(0, self.box._curdataset)
self.assertEqual(0, self.box._curphase)
exec "reset()" in sandbox
self.assertEqual(1, len(self.box._fits))
self.assertEqual(0, len(self.box._fits[-1].strucs))
self.assertEqual(0, len(self.box._fits[-1].datasets))
self.assertEqual(None, self.box._curdataset)
self.assertEqual(None, self.box._curphase)
return
def test_constrain_calculation(self):
"""check exceptions when attempting to constrain Calculation
"""
fNi_stru = datafile('Ni.stru')
sandbox = self.box.sandbox()
sandbox.update({"fNi_stru": fNi_stru})
exec "read_struct(fNi_stru)" in sandbox
exec "alloc(N, 37.0, 0.07, 0.01, 10.0, 1000)" in sandbox
self.assertRaises(ControlRuntimeError, self.box.constrain, 'delta', 1)
self.assertRaises(ControlRuntimeError, self.box.constrain, 'qdamp',
"@3*@3")
self.assertRaises(ControlRuntimeError, self.box.constrain, 'delta', 1,
'FCOMP')
return
def test_constrain(self):
"""check PdfFitSandbox.constrain()
"""
sandbox = self.box.sandbox()
self.assertRaises(ControlKeyError, self.box.constrain, 'delta', 1)
fNi_stru = datafile('Ni.stru')
self.box.read_struct(fNi_stru)
exec 'constrain(delta, 1)' in sandbox
self.assertRaises(ControlKeyError, self.box.constrain, 'qdamp', 10)
fNi_data = datafile("Ni_2-8.chi.gr")
self.box.read_data(fNi_data, "X", 40.1, 0.05)
exec 'constrain(qdamp, 10)' in sandbox
exec 'constrain(dscale, 2)' in sandbox
exec 'constrain(lat(1), 3)' in sandbox
exec 'constrain(lat(2), 3)' in sandbox
exec 'constrain(lat(3), "@3")' in sandbox
exec 'constrain(occ(1), 4)' in sandbox
exec 'constrain(pfrac, 5)' in sandbox
exec 'constrain(u11(1), 6)' in sandbox
exec 'constrain(u22(1), 6)' in sandbox
exec 'constrain(u33(1), 6)' in sandbox
exec 'constrain(x(1), "@7+0.5")' in sandbox
cphase = self.box._fits[-1].strucs[self.box._curphase]
cdataset = self.box._fits[-1].datasets[self.box._curdataset]
self.assertEqual(10, len(cphase.constraints))
self.assertTrue('pscale' in cphase.constraints)
self.assertEqual('@6', cphase.constraints['u11(1)'].formula)
self.assertEqual('@7+0.5', cphase.constraints['x(1)'].formula)
self.assertEqual(2, len(cdataset.constraints))
self.assertEqual('@10', cdataset.constraints['qdamp'].formula)
exec 'constrain(x(2), 21, IDENT)' in sandbox
exec 'constrain(y(2), 22, FCOMP)' in sandbox
exec 'constrain(z(2), 23, FSQR)' in sandbox
self.assertEqual('@21', cphase.constraints['x(2)'].formula)
self.assertEqual('1.0-@22', cphase.constraints['y(2)'].formula)
self.assertEqual('@23*@23', cphase.constraints['z(2)'].formula)
return
def test_constrain(self):
"""check PdfFitSandbox.constrain()
"""
sandbox = self.box.sandbox()
self.assertRaises(ControlKeyError, self.box.constrain, 'delta', 1)
fNi_stru = datafile('Ni.stru')
self.box.read_struct(fNi_stru)
exec 'constrain(delta, 1)' in sandbox
self.assertRaises(ControlKeyError, self.box.constrain, 'qdamp', 10)
fNi_data = datafile("Ni_2-8.chi.gr")
self.box.read_data(fNi_data, "X", 40.1, 0.05)
exec 'constrain(qdamp, 10)' in sandbox
exec 'constrain(dscale, 2)' in sandbox
exec 'constrain(lat(1), 3)' in sandbox
exec 'constrain(lat(2), 3)' in sandbox
exec 'constrain(lat(3), "@3")' in sandbox
exec 'constrain(occ(1), 4)' in sandbox
exec 'constrain(pfrac, 5)' in sandbox
exec 'constrain(u11(1), 6)' in sandbox
exec 'constrain(u22(1), 6)' in sandbox
exec 'constrain(u33(1), 6)' in sandbox
exec 'constrain(x(1), "@7+0.5")' in sandbox
cphase = self.box._fits[-1].strucs[self.box._curphase]
cdataset = self.box._fits[-1].datasets[self.box._curdataset]
self.assertEqual(10, len(cphase.constraints))
self.failUnless('pscale' in cphase.constraints)
self.assertEqual('@6', cphase.constraints['u11(1)'].formula)
self.assertEqual('@7+0.5', cphase.constraints['x(1)'].formula)
self.assertEqual(2, len(cdataset.constraints))
self.assertEqual('@10', cdataset.constraints['qdamp'].formula)
exec 'constrain(x(2), 21, IDENT)' in sandbox
exec 'constrain(y(2), 22, FCOMP)' in sandbox
exec 'constrain(z(2), 23, FSQR)' in sandbox
self.assertEqual('@21', cphase.constraints['x(2)'].formula)
self.assertEqual('1.0-@22', cphase.constraints['y(2)'].formula)
self.assertEqual('@23*@23', cphase.constraints['z(2)'].formula)
return
def test_insertAtoms(self):
"""check FitStructure.insertAtoms()
"""
from diffpy.Structure import Atom
stru = self.stru
stru.read(datafile('Ni.stru'), format='pdffit')
cns = Constraint('@1')
stru.constraints['x(2)'] = cns
stru.insertAtoms(0, [Atom('Na', (0, 0, 0))])
self.assertEqual(5, len(stru))
self.assertEqual(1, len(stru.constraints))
self.failUnless(cns is stru.constraints['x(3)'])
stru.insertAtoms(5, [Atom('Cl', (0, 0, 0))])
self.failUnless(['x(3)'] == stru.constraints.keys())
return
def test_findParameters(self):
"""check FitStructure.findParameters()
"""
stru = self.stru
stru.read(datafile('Ni.stru'), format='pdffit')
for a in stru.initial: a.Uiso = 0.00126651
stru.constraints['lat(4)'] = Constraint('@1')
stru.constraints['y(2)'] = Constraint('@3 + 0.4')
stru.constraints['u11(3)'] = Constraint('@7 * 3.0')
pd = stru.findParameters()
self.assertEqual([1, 3, 7], sorted(pd.keys()))
self.assertEqual(90, pd[1].initialValue())
self.assertEqual(0.5 - 0.4, pd[3].initialValue())
self.assertEqual(0.00126651/3.0, pd[7].initialValue())
return
def test_constrain_calculation(self):
"""check exceptions when attempting to constrain Calculation
"""
fNi_stru = datafile('Ni.stru')
sandbox = self.box.sandbox()
sandbox.update({ "fNi_stru" : fNi_stru })
exec "read_struct(fNi_stru)" in sandbox
exec "alloc(N, 37.0, 0.07, 0.01, 10.0, 1000)" in sandbox
self.assertRaises(ControlRuntimeError,
self.box.constrain, 'delta', 1)
self.assertRaises(ControlRuntimeError,
self.box.constrain, 'qdamp', "@3*@3")
self.assertRaises(ControlRuntimeError,
self.box.constrain, 'delta', 1, 'FCOMP')
return
def test_readStr(self):
"""check PDFDataSet.readStr()
"""
# read Ni xray data, but invalidate the last dGobs
fx_Ni = datafile('Ni_2-8.chi.gr')
sNi = open(fx_Ni).read()
lastdGobs = sNi.rstrip().rindex(' ')
sNi_no_dGobs = sNi[:lastdGobs] + " -1.3e-3"
self.pdfds.readStr(sNi_no_dGobs)
# there are 2000 points in the file
npts = len(self.pdfds.robs)
self.assertEqual(2000, npts)
# dGobs should be all zero
self.assertEqual(npts*[0.0], self.pdfds.dGobs)
return
def test_readStr(self):
"""check PDFDataSet.readStr()
"""
# read Ni xray data, but invalidate the last dGobs
fx_Ni = datafile('Ni_2-8.chi.gr')
sNi = open(fx_Ni).read()
lastdGobs = sNi.rstrip().rindex(' ')
sNi_no_dGobs = sNi[:lastdGobs] + " -1.3e-3"
self.pdfds.readStr(sNi_no_dGobs)
# there are 2000 points in the file
npts = len(self.pdfds.robs)
self.assertEqual(2000, npts)
# dGobs should be all zero
self.assertEqual(npts*[0.0], self.pdfds.dGobs)
return
def test_insertAtoms(self):
"""check FitStructure.insertAtoms()
"""
from diffpy.Structure import Atom
stru = self.stru
stru.read(datafile('Ni.stru'), format='pdffit')
cns = Constraint('@1')
stru.constraints['x(2)'] = cns
stru.insertAtoms(0, [Atom('Na', (0, 0, 0))])
self.assertEqual(5, len(stru))
self.assertEqual(1, len(stru.constraints))
self.assertTrue(cns is stru.constraints['x(3)'])
stru.insertAtoms(5, [Atom('Cl', (0, 0, 0))])
self.assertTrue(['x(3)'] == stru.constraints.keys())
return
def test___del__(self):
"""check StructureViewer.__del__()
"""
import gc
from diffpy.pdfgui.control.fitstructure import FitStructure
sv = StructureViewer()
sv.executable = 'does/not/exist'
fs = FitStructure('s1')
fs.read(datafile('LaMnO3.stru'))
self.assertRaises(ControlConfigError, sv.plot, fs)
tmpd = sv._tmpdir
self.failUnless(os.path.isdir(tmpd))
del sv
gc.collect()
self.failIf(os.path.isdir(tmpd))
return
def test_deleteAtoms(self):
"""check FitStructure.deleteAtoms()
"""
stru = self.stru
stru.read(datafile('Ni.stru'), format='pdffit')
cns = Constraint('@1')
stru.constraints['x(2)'] = cns
stru.deleteAtoms([3])
self.assertEqual(['x(2)'], stru.constraints.keys())
self.assertTrue(cns is stru.constraints.values()[0])
stru.deleteAtoms([0])
self.assertEqual(['x(1)'], stru.constraints.keys())
self.assertTrue(cns is stru.constraints.values()[0])
stru.deleteAtoms([0])
self.assertEqual({}, stru.constraints)
return
def test_plot(self):
"""check StructureViewer.plot()
"""
from diffpy.pdfgui.control.fitstructure import FitStructure
sv = StructureViewer()
# default executable is empty string
self.assertEqual('', sv.executable)
# and so plot raises ControlConfigError
fs = FitStructure('s1')
fs.read(datafile('LaMnO3.stru'))
self.assertRaises(ControlConfigError, sv.plot, fs)
sv.executable = 'does/not/exist'
self.failUnless(None is sv._tmpdir)
self.assertEqual(0, sv._plotcount)
self.assertRaises(ControlConfigError, sv.plot, fs)
self.failUnless(os.path.isdir(sv._tmpdir))
self.assertEqual(1, sv._plotcount)
return
