def test_makePDFEnvelope(self):
'''check the makePDFEnvelope wrapper.
'''
pbl = makePDFEnvelope('parabolaenvelope',
parabola_envelope, a=1, b=2, c=3)
self.assertEqual(3, pbl(0))
self.assertEqual(6, pbl(1))
self.assertEqual(11, pbl(2))
pbl.b = 0
self.assertEqual([7, 3, 28], [pbl(x) for x in [-2, 0, 5]])
pbl2 = pbl.clone()
self.assertEqual(1, pbl2.a)
self.assertEqual(0, pbl2.b)
self.assertEqual(3, pbl2.c)
self.assertEqual([7, 3, 28], [pbl2(x) for x in [-2, 0, 5]])
pbl3 = PDFEnvelope.createByType('parabolaenvelope')
self.assertEqual(1, pbl3.a)
self.assertEqual(2, pbl3.b)
self.assertEqual(3, pbl3.c)
pbl3.a = 0
pbl3.foo = 'asdf'
pbl3cp = pickle.loads(pickle.dumps(pbl3))
self.assertEqual(0, pbl3cp.a)
self.assertEqual('asdf', pbl3cp.foo)
pc = PDFCalculator()
pc.envelopes = (pbl2,)
pc2 = pickle.loads(pickle.dumps(pc))
pbl2cp = pc2.envelopes[0]
self.assertEqual('parabolaenvelope', pbl2cp.type())
self.assertEqual(1, pbl2cp.a)
self.assertEqual(0, pbl2cp.b)
self.assertEqual(3, pbl2cp.c)
return
def test_picking_owned(self):
'''verify pickling of envelopes owned by PDF calculators.
'''
pbl = makePDFEnvelope('parabolaenvelope',
parabola_envelope, a=1, b=2, c=3)
pbl.a = 7
pbl.foobar = 'asdf'
pc = PDFCalculator()
pc.envelopes = (pbl,)
dbpc = DebyePDFCalculator()
dbpc.envelopes = (pbl,)
self.assertIs(pbl, pc.envelopes[0])
self.assertIs(pbl, dbpc.envelopes[0])
pc.addEnvelope(self.fscale)
dbpc.addEnvelope(self.fscale)
self.fscale.scale = 3.5
self.assertEqual(3.5, pc.scale)
self.assertEqual(3.5, dbpc.scale)
pc2 = pickle.loads(pickle.dumps(pc))
dbpc2 = pickle.loads(pickle.dumps(dbpc))
self.assertEqual(3.5, pc2.scale)
self.assertEqual(3.5, dbpc2.scale)
pblcopies = [pc2.getEnvelope("parabolaenvelope"),
dbpc2.getEnvelope("parabolaenvelope")]
for pbl2 in pblcopies:
self.assertEqual(7, pbl2.a)
self.assertEqual('asdf', pbl2.foobar)
self.assertEqual('parabolaenvelope', pbl2.type())
return
def test_makePDFEnvelope(self):
'''check the makePDFEnvelope wrapper.
'''
pbl = makePDFEnvelope('parabolaenvelope',
parabola_envelope, a=1, b=2, c=3)
self.assertEqual(3, pbl(0))
self.assertEqual(6, pbl(1))
self.assertEqual(11, pbl(2))
pbl.b = 0
self.assertEqual([7, 3, 28], map(pbl, [-2, 0, 5]))
pbl2 = pbl.clone()
self.assertEqual(1, pbl2.a)
self.assertEqual(0, pbl2.b)
self.assertEqual(3, pbl2.c)
self.assertEqual([7, 3, 28], map(pbl2, [-2, 0, 5]))
pbl3 = PDFEnvelope.createByType('parabolaenvelope')
self.assertEqual(1, pbl3.a)
self.assertEqual(2, pbl3.b)
self.assertEqual(3, pbl3.c)
pbl3.a = 0
pbl3.foo = 'asdf'
pbl3cp = cPickle.loads(cPickle.dumps(pbl3))
self.assertEqual(0, pbl3cp.a)
self.assertEqual('asdf', pbl3cp.foo)
pc = PDFCalculator()
pc.envelopes = (pbl2,)
pc2 = cPickle.loads(cPickle.dumps(pc))
pbl2cp = pc2.envelopes[0]
self.assertEqual('parabolaenvelope', pbl2cp.type())
self.assertEqual(1, pbl2cp.a)
self.assertEqual(0, pbl2cp.b)
self.assertEqual(3, pbl2cp.c)
return
def test_parallel_pdf(self):
"""check parallel PDFCalculator
"""
from diffpy.srreal.pdfcalculator import PDFCalculator
pdfc = PDFCalculator()
r0, g0 = pdfc(self.cdse)
ppdfc1 = createParallelCalculator(PDFCalculator(), 3, map)
r1, g1 = ppdfc1(self.cdse)
self.failUnless(numpy.array_equal(r0, r1))
self.failUnless(numpy.allclose(g0, g1))
ppdfc2 = createParallelCalculator(PDFCalculator(), self.ncpu,
self.pool.imap_unordered)
r2, g2 = ppdfc2(self.cdse)
self.failUnless(numpy.array_equal(r0, r2))
self.failUnless(numpy.allclose(g0, g2))
pdfc.rmax = ppdfc1.rmax = ppdfc2.rmax = 5
pdfc.qmax = ppdfc1.qmax = ppdfc2.qmax = 15
r0a, g0a = pdfc()
self.failUnless(numpy.all(r0a <= 5))
self.assertFalse(numpy.allclose(g0a, numpy.interp(r0a, r0, g0)))
r1a, g1a = ppdfc1()
self.failUnless(numpy.array_equal(r0a, r1a))
self.failUnless(numpy.allclose(g0a, g1a))
r2a, g2a = ppdfc2()
self.failUnless(numpy.array_equal(r0a, r2a))
self.failUnless(numpy.allclose(g0a, g2a))
return
def setUp(self):
self.pdfcalc = PDFCalculator()
if not self.nickel:
type(self).nickel = loadDiffPyStructure('Ni.stru')
if not self.tio2rutile:
type(self).tio2rutile = (
loadDiffPyStructure('TiO2_rutile-fit.stru'))
return
def test__setDoubleAttr(self):
"""check Attributes._setDoubleAttr()
"""
pdfc = PDFCalculator()
pdfc._setDoubleAttr('scale', 1.23)
self.assertFalse('scale' in pdfc.__dict__)
self.assertEqual(1.23, pdfc.scale)
return
def test___init__(self):
"""check PDFCalculator.__init__()
"""
pdfc = PDFCalculator(qmin=13, rmin=4, rmax=99)
self.assertEqual(13, pdfc.qmin)
self.assertEqual(4, pdfc.rmin)
self.assertEqual(99, pdfc.rmax)
self.assertEqual(99, pdfc._getDoubleAttr('rmax'))
return
def test___init__(self):
"""check PDFCalculator.__init__()
"""
pdfc = PDFCalculator(qmin=13, rmin=4, rmax=99)
self.assertEqual(13, pdfc.qmin)
self.assertEqual(4, pdfc.rmin)
self.assertEqual(99, pdfc.rmax)
self.assertEqual(99, pdfc._getDoubleAttr('rmax'))
return
def test_objcryst_pickling(self):
'''check pickling of the NoSymmetryStructureAdapter wrapper.
'''
r0, g0 = PDFCalculator()(self.rutile)
rutile1 = cPickle.loads(cPickle.dumps(self.rutile))
self.failIf(self.rutile is rutile1)
r1, g1 = PDFCalculator()(rutile1)
self.failUnless(numpy.array_equal(r0, r1))
self.failUnless(numpy.array_equal(g0, g1))
return
def test__customPQConfig(self):
"""check if DerivedCls._customPQConfig gets called.
"""
self.assertEqual(0, self.adpt.cpqcount)
pc = PDFCalculator()
pc.setStructure(self.adpt)
self.assertEqual(1, self.adpt.cpqcount)
pc(self.adpt)
self.assertEqual(2, self.adpt.cpqcount)
return
def test__customPQConfig(self):
"""check if DerivedCls._customPQConfig gets called.
"""
self.assertEqual(0, self.adpt.cpqcount)
pc = PDFCalculator()
pc.setStructure(self.adpt)
self.assertEqual(1, self.adpt.cpqcount)
pc(self.adpt)
self.assertEqual(2, self.adpt.cpqcount)
return
def test_objcryst_pickling(self):
'''check pickling of the NoSymmetryStructureAdapter wrapper.
'''
r0, g0 = PDFCalculator()(self.rutile)
rutile1 = pickle.loads(pickle.dumps(self.rutile))
self.assertFalse(self.rutile is rutile1)
r1, g1 = PDFCalculator()(rutile1)
self.assertTrue(numpy.array_equal(r0, r1))
self.assertTrue(numpy.array_equal(g0, g1))
return
def test_nosymmetry_pickling(self):
'''check pickling of the NoSymmetryStructureAdapter wrapper.
'''
ni1ns = nosymmetry(nickel)
r1, g1 = PDFCalculator()(ni1ns)
ni2ns = cPickle.loads(cPickle.dumps(ni1ns))
self.failIf(ni1ns is ni2ns)
r2, g2 = PDFCalculator()(ni2ns)
self.failUnless(numpy.array_equal(r1, r2))
self.failUnless(numpy.array_equal(g1, g2))
return
def test_nosymmetry_pickling(self):
'''check pickling of the NoSymmetryStructureAdapter wrapper.
'''
ni1ns = nosymmetry(self.nickel)
r1, g1 = PDFCalculator()(ni1ns)
ni2ns = pickle.loads(pickle.dumps(ni1ns))
self.assertFalse(ni1ns is ni2ns)
r2, g2 = PDFCalculator()(ni2ns)
self.assertTrue(numpy.array_equal(r1, r2))
self.assertTrue(numpy.array_equal(g1, g2))
return
def test___getattr__(self):
"""check Attributes.__getattr__()
"""
a = Attributes()
self.assertRaises(AttributeError, getattr, a, 'invalid')
a.x = 11
self.assertEqual(11, a.x)
pdfc = PDFCalculator()
pdfc._setDoubleAttr('rmax', 12.34)
self.assertEqual(12.34, pdfc.rmax)
return
def test_nometa_pickling(self):
'''check pickling of the NoMetaStructureAdapter wrapper.
'''
r0, g0 = PDFCalculator()(self.nickel)
ni1 = self.nickel.copy()
ni1.pdffit['scale'] = 2.0
ni1nm = pickle.loads(pickle.dumps(nometa(ni1)))
self.assertFalse(ni1nm is ni1)
r1nm, g1nm = PDFCalculator()(ni1nm)
self.assertTrue(numpy.array_equal(r0, r1nm))
self.assertTrue(numpy.array_equal(g0, g1nm))
return
def test_nometa_pickling(self):
'''check pickling of the NoMetaStructureAdapter wrapper.
'''
r0, g0 = PDFCalculator()(nickel)
ni1 = Structure(nickel)
ni1.pdffit['scale'] = 2.0
ni1nm = cPickle.loads(cPickle.dumps(nometa(ni1)))
self.failIf(ni1nm is ni1)
r1nm, g1nm = PDFCalculator()(ni1nm)
self.failUnless(numpy.array_equal(r0, r1nm))
self.failUnless(numpy.array_equal(g0, g1nm))
return
def test_pickling(self):
'''check pickling of DerivedCls instances.
'''
self.adpt.cpqcount = 1
adpt1 = cPickle.loads(cPickle.dumps(self.adpt))
self.assertTrue(self.DerivedCls is type(adpt1))
self.assertFalse(self.adpt is adpt1)
self.assertEqual(1, adpt1.cpqcount)
pc = PDFCalculator()
pc.setStructure(adpt1)
self.assertEqual(2, adpt1.cpqcount)
pc(adpt1)
self.assertEqual(3, adpt1.cpqcount)
return
def test_pickling(self):
"""check pickling of DerivedCls instances.
"""
self.adpt.cpqcount = 1
adpt1 = cPickle.loads(cPickle.dumps(self.adpt))
self.failUnless(self.DerivedCls is type(adpt1))
self.failIf(self.adpt is adpt1)
self.assertEqual(1, adpt1.cpqcount)
pc = PDFCalculator()
pc.setStructure(adpt1)
self.assertEqual(2, adpt1.cpqcount)
pc(adpt1)
self.assertEqual(3, adpt1.cpqcount)
return
def test_pickling(self):
'''check pickling of DerivedCls instances.
'''
self.adpt.cpqcount = 1
adpt1 = pickle.loads(pickle.dumps(self.adpt))
self.assertTrue(self.DerivedCls is type(adpt1))
self.assertFalse(self.adpt is adpt1)
self.assertEqual(1, adpt1.cpqcount)
pc = PDFCalculator()
pc.setStructure(adpt1)
self.assertEqual(2, adpt1.cpqcount)
pc(adpt1)
self.assertEqual(3, adpt1.cpqcount)
return
def setUp(self):
MySawTooth()._registerThisType()
self.pc = PDFCalculator()
self.pc.peakprofile = 'mysawtooth'
self.pkf = self.pc.peakprofile
self.pkf.peakprecision = 0.0017
return
def setUp(self):
self.pc = PDFCalculator()
self.dbpc = DebyePDFCalculator()
self.pwm = MyPWM()
self.pc.peakwidthmodel = self.pwm
self.dbpc.peakwidthmodel = self.pwm
return
def test_picking_owned(self):
'''verify pickling of PDFBaseline owned by PDF calculators.
'''
pbl = makePDFBaseline('parabolabaseline',
parabola_baseline, a=1, b=2, c=3)
pbl.a = 7
pbl.foobar = 'asdf'
pc = PDFCalculator()
pc.baseline = pbl
self.assertIs(pbl, pc.baseline)
pc2 = pickle.loads(pickle.dumps(pc))
pbl2 = pc2.baseline
self.assertEqual(7, pbl2.a)
self.assertEqual('asdf', pbl2.foobar)
self.assertEqual('parabolabaseline', pbl2.type())
return
def __init__(self, name="pdf"):
"""Initialize the generator.
"""
BasePDFGenerator.__init__(self, name)
self._setCalculator(PDFCalculator())
return
def _makePDFCalculator(crst, cfgdict):
'''Return a PDFCalculator object evaluated for a pyobjcryst.Crystal crst.
'''
inpdfcalc = lambda kv: kv[0] not in ('biso', 'type')
pdfcargs = dict(filter(inpdfcalc, cfgdict.items()))
pdfc = PDFCalculator(**pdfcargs)
if 'biso' in cfgdict:
setbiso = lambda sc: sc.mpScattPow.SetBiso(cfgdict['biso'])
map(setbiso, crst.GetScatteringComponentList())
if 'type' in cfgdict:
pdfc.scatteringfactortable = cfgdict['type']
pdfc.eval(crst)
# avoid metadata override by PDFFitStructure
for k, v in pdfcargs.items():
setattr(pdfc, k, v)
return pdfc
def __init__(self, name = "pdf"):
"""Initialize the generator.
"""
from diffpy.srreal.pdfcalculator import PDFCalculator
BasePDFGenerator.__init__(self, name)
self._setCalculator(PDFCalculator())
return
def test__namesOfWritableDoubleAttributes(self):
"""check Attributes._namesOfDoubleAttributes()
"""
a = Attributes()
self.assertEqual(0, len(a._namesOfDoubleAttributes()))
a._registerDoubleAttribute('bar', lambda obj: 13)
self.assertEqual(13, a._getDoubleAttr('bar'))
self.assertEqual(13, a.bar)
self.assertEqual(1, len(a._namesOfDoubleAttributes()))
self.assertEqual(0, len(a._namesOfWritableDoubleAttributes()))
pdfc = PDFCalculator()
self.failUnless('extendedrmin' in pdfc._namesOfDoubleAttributes())
self.failUnless('extendedrmax' in pdfc._namesOfDoubleAttributes())
self.failIf('extendedrmin' in pdfc._namesOfWritableDoubleAttributes())
self.failIf('extendedrmax' in pdfc._namesOfWritableDoubleAttributes())
return
def _makePDFCalculator(crst, cfgdict):
'''Return a PDFCalculator object evaluated for a pyobjcryst.Crystal crst.
'''
inpdfcalc = lambda kv: kv[0] not in ('biso', 'type')
pdfcargs = dict(filter(inpdfcalc, cfgdict.items()))
pdfc = PDFCalculator(**pdfcargs)
if 'biso' in cfgdict:
setbiso = lambda sc: sc.mpScattPow.SetBiso(cfgdict['biso'])
map(setbiso, crst.GetScatteringComponentList())
if 'type' in cfgdict:
pdfc.scatteringfactortable = cfgdict['type']
pdfc.eval(crst)
# avoid metadata override by PDFFitStructure
for k, v in pdfcargs.items():
setattr(pdfc, k, v)
return pdfc
def test__namesOfWritableDoubleAttributes(self):
"""check Attributes._namesOfDoubleAttributes()
"""
a = Attributes()
self.assertEqual(0, len(a._namesOfDoubleAttributes()))
a._registerDoubleAttribute('bar', lambda obj: 13)
self.assertEqual(13, a._getDoubleAttr('bar'))
self.assertEqual(13, a.bar)
self.assertEqual(1, len(a._namesOfDoubleAttributes()))
self.assertEqual(0, len(a._namesOfWritableDoubleAttributes()))
pdfc = PDFCalculator()
self.failUnless('extendedrmin' in pdfc._namesOfDoubleAttributes())
self.failUnless('extendedrmax' in pdfc._namesOfDoubleAttributes())
self.failIf('extendedrmin' in pdfc._namesOfWritableDoubleAttributes())
self.failIf('extendedrmax' in pdfc._namesOfWritableDoubleAttributes())
return
def testGenerator(self):
qmax = 27.0
gen = self.gen
gen.setScatteringType('N')
self.assertEqual('N', gen.getScatteringType())
gen.setQmax(qmax)
self.assertAlmostEqual(qmax, gen.getQmax())
from diffpy.Structure import PDFFitStructure
stru = PDFFitStructure()
ciffile = datafile("ni.cif")
stru.read(ciffile)
for i in range(4):
stru[i].Bisoequiv = 1
gen.setStructure(stru)
calc = gen._calc
# Test parameters
for par in gen.iterPars(recurse=False):
pname = par.name
defval = calc._getDoubleAttr(pname)
self.assertEquals(defval, par.getValue())
# Test setting values
par.setValue(1.0)
self.assertEquals(1.0, par.getValue())
par.setValue(defval)
self.assertEquals(defval, par.getValue())
r = numpy.arange(0, 10, 0.1)
y = gen(r)
# Now create a reference PDF. Since the calculator is testing its
# output, we just have to make sure we can calculate from the
# PDFGenerator interface.
from diffpy.srreal.pdfcalculator import PDFCalculator
calc = PDFCalculator()
calc.rstep = r[1] - r[0]
calc.rmin = r[0]
calc.rmax = r[-1] + 0.5 * calc.rstep
calc.qmax = qmax
calc.setScatteringFactorTableByType('N')
calc.eval(stru)
yref = calc.pdf
diff = y - yref
res = numpy.dot(diff, diff)
self.assertAlmostEquals(0, res)
return
def setUp(self):
self.pdfcalc = PDFCalculator()
if not self.nickel:
type(self).nickel = loadDiffPyStructure('Ni.stru')
if not self.tio2rutile:
type(self).tio2rutile = (
loadDiffPyStructure('TiO2_rutile-fit.stru'))
return
def _makePDFCalculator(crst, cfgdict):
'''Return a PDFCalculator object evaluated for a pyobjcryst.Crystal crst.
'''
pdfcargs = {k: v for k, v in cfgdict.items() if k not in ('biso', 'type')}
pdfc = PDFCalculator(**pdfcargs)
if 'biso' in cfgdict:
reg = crst.GetScatteringPowerRegistry()
for i in range(reg.GetNb()):
sp = reg.GetObj(i)
sp.SetBiso(cfgdict['biso'])
if 'type' in cfgdict:
pdfc.scatteringfactortable = cfgdict['type']
pdfc.eval(crst)
# avoid metadata override by PDFFitStructure
for k, v in pdfcargs.items():
setattr(pdfc, k, v)
return pdfc
def test__getDoubleAttr(self):
"""check Attributes._getDoubleAttr()
"""
pdfc = PDFCalculator()
pdfc.foo = 11
self.assertRaises(AttributeError, pdfc._getDoubleAttr, 'foo')
pdfc._registerDoubleAttribute('foo')
self.assertEqual(11, pdfc._getDoubleAttr('foo'))
pdfc.rmax = 22
self.assertEqual(22, pdfc._getDoubleAttr('rmax'))
setattr(pdfc, 'rmax', 23)
self.assertEqual(23, pdfc._getDoubleAttr('rmax'))
self.assertRaises(Exception, setattr, pdfc, 'rmax', 'xxx')
return
def test_nometa(self):
'''check NoMetaStructureAdapter.
'''
r0, g0 = PDFCalculator()(self.nickel)
ni1 = self.nickel.copy()
ni1.pdffit['scale'] = 2.0
r1, g1 = PDFCalculator()(ni1)
self.assertTrue(numpy.array_equal(r0, r1))
self.assertTrue(numpy.allclose(2 * g0, g1))
ni1nm = nometa(ni1)
self.assertTrue(ni1nm is nometa(ni1nm))
r1nm, g1nm = PDFCalculator()(ni1nm)
self.assertTrue(numpy.array_equal(r0, r1nm))
self.assertTrue(numpy.allclose(g0, g1nm))
ni2 = self.nickel.copy()
ni2.pdffit['delta2'] = 4
r2, g2 = PDFCalculator()(ni2)
r2, g2nm = PDFCalculator()(nometa(ni2))
self.assertFalse(numpy.allclose(g0, g2))
self.assertTrue(numpy.allclose(g0, g2nm))
adpt2 = createStructureAdapter(ni2)
ra2, ga2 = PDFCalculator()(adpt2)
ra2, ga2nm = PDFCalculator()(nometa(adpt2))
self.assertTrue(numpy.allclose(g2, ga2))
self.assertTrue(numpy.allclose(g0, ga2nm))
return
def _makePDFCalculator(crst, cfgdict):
'''Return a PDFCalculator object evaluated for a pyobjcryst.Crystal crst.
'''
pdfcargs = {k : v for k, v in cfgdict.items()
if k not in ('biso', 'type')}
pdfc = PDFCalculator(**pdfcargs)
if 'biso' in cfgdict:
reg = crst.GetScatteringPowerRegistry()
for i in range(reg.GetNb()):
sp = reg.GetObj(i)
sp.SetBiso(cfgdict['biso'])
if 'type' in cfgdict:
pdfc.scatteringfactortable = cfgdict['type']
pdfc.eval(crst)
# avoid metadata override by PDFFitStructure
for k, v in pdfcargs.items():
setattr(pdfc, k, v)
return pdfc
def test_PDF_C60bucky(self):
"""check DebyePDFCalculator.pdf for C60 Bucky ball.
"""
qmax = self.dpdfc.qmax
r0, g0 = PDFCalculator(qmax=qmax)(self.bucky)
r1, g1 = self.dpdfc(self.bucky)
mxnd = _maxNormDiff(g0, g1)
self.assertTrue(mxnd < 0.0006)
return
def test_ticker_override(self):
"""check PeakWidthModel.ticker override in a Python-derived class.
"""
pwm = MyPWM()
self.assertEqual(0, pwm.tcnt)
et0 = pwm.ticker()
self.assertEqual(1, pwm.tcnt)
et1 = PeakWidthModel.ticker(pwm)
self.assertEqual(1, pwm.tcnt)
self.assertEqual(et0, et1)
et0.click()
self.assertEqual(et0, et1)
# check that implicit ticker call from PDFCalculator is
# handled by the Python ticker override.
pc = PDFCalculator()
pc.peakwidthmodel = pwm
pc.ticker()
self.assertEqual(2, pwm.tcnt)
return
def test_ticker_override(self):
"""check PeakWidthModel.ticker override in a Python-derived class.
"""
pwm = MyPWM()
self.assertEqual(0, pwm.tcnt)
et0 = pwm.ticker()
self.assertEqual(1, pwm.tcnt)
et1 = PeakWidthModel.ticker(pwm)
self.assertEqual(1, pwm.tcnt)
self.assertEqual(et0, et1)
et0.click()
self.assertEqual(et0, et1)
# check that implicit ticker call from PDFCalculator is
# handled by the Python ticker override.
pc = PDFCalculator()
pc.peakwidthmodel = pwm
pc.ticker()
self.assertEqual(2, pwm.tcnt)
return
def test_ticker_override(self):
"""check method override for PeakProfile.ticker in a derived class.
"""
pkf = MySawTooth()
self.assertEqual(0, pkf.tcnt)
et0 = pkf.ticker()
self.assertEqual(1, pkf.tcnt)
et1 = PeakProfile.ticker(pkf)
self.assertEqual(1, pkf.tcnt)
self.assertEqual(et0, et1)
et0.click()
self.assertEqual(et0, et1)
# check that implicit ticker call from PDFCalculator is
# handled by the Python ticker override.
pc = PDFCalculator()
pc.peakprofile = pkf
pc.ticker()
self.assertEqual(2, pkf.tcnt)
return
def test_ticker_override(self):
"""check method override for PeakProfile.ticker in a derived class.
"""
pkf = MySawTooth()
self.assertEqual(0, pkf.tcnt)
et0 = pkf.ticker()
self.assertEqual(1, pkf.tcnt)
et1 = PeakProfile.ticker(pkf)
self.assertEqual(1, pkf.tcnt)
self.assertEqual(et0, et1)
et0.click()
self.assertEqual(et0, et1)
# check that implicit ticker call from PDFCalculator is
# handled by the Python ticker override.
pc = PDFCalculator()
pc.peakprofile = pkf
pc.ticker()
self.assertEqual(2, pkf.tcnt)
return
def test_picking_owned(self):
'''verify pickling of PDFBaseline owned by PDF calculators.
'''
pbl = makePDFBaseline('parabolabaseline',
parabola_baseline,
a=1,
b=2,
c=3)
pbl.a = 7
pbl.foobar = 'asdf'
pc = PDFCalculator()
pc.baseline = pbl
self.assertIs(pbl, pc.baseline)
pc2 = pickle.loads(pickle.dumps(pc))
pbl2 = pc2.baseline
self.assertEqual(7, pbl2.a)
self.assertEqual('asdf', pbl2.foobar)
self.assertEqual('parabolabaseline', pbl2.type())
return
def testGenerator(self):
qmax = 27.0
gen = PDFGenerator()
gen.setScatteringType('N')
self.assertEqual('N', gen.getScatteringType())
gen.setQmax(qmax)
self.assertAlmostEqual(qmax, gen.getQmax())
from diffpy.Structure import PDFFitStructure
stru = PDFFitStructure()
ciffile = datafile("ni.cif")
stru.read(ciffile)
for i in range(4):
stru[i].Bisoequiv = 1
gen.setStructure(stru)
calc = gen._calc
# Test parameters
for par in gen.iterPars(recurse = False):
pname = par.name
defval = calc._getDoubleAttr(pname)
self.assertEquals(defval, par.getValue())
# Test setting values
par.setValue(1.0)
self.assertEquals(1.0, par.getValue())
par.setValue(defval)
self.assertEquals(defval, par.getValue())
r = numpy.arange(0, 10, 0.1)
y = gen(r)
# Now create a reference PDF. Since the calculator is testing its
# output, we just have to make sure we can calculate from the
# PDFGenerator interface.
from diffpy.srreal.pdfcalculator import PDFCalculator
calc = PDFCalculator()
calc.rstep = r[1] - r[0]
calc.rmin = r[0]
calc.rmax = r[-1] + 0.5 * calc.rstep
calc.qmax = qmax
calc.setScatteringFactorTableByType('N')
calc.eval(stru)
yref = calc.pdf
diff = y - yref
res = numpy.dot(diff, diff)
self.assertAlmostEquals(0, res)
return
def test_evaluatortype(self):
"""check PairQuantity.evaluatortype property.
"""
pq = self.pq
self.assertTrue(pq.evaluatortype in ('BASIC', 'OPTIMIZED'))
pq.evaluatortype = 'BASIC'
self.assertEqual('BASIC', pq.evaluatortype)
self.assertRaises(ValueError, setattr, pq, 'evaluatortype', 'invalid')
self.assertRaises(ValueError, setattr, pq, 'evaluatortype', 'basic')
self.assertRaises(ValueError, setattr, pq, 'evaluatortype', 'BASic')
# check all supported evaluators in PDFCalculator
pdfc = PDFCalculator()
self.assertEqual('OPTIMIZED', pdfc.evaluatortype)
pdfc.evaluatortype = 'BASIC'
self.assertEqual('BASIC', pdfc.evaluatortype)
pdfc.evaluatortype = 'CHECK'
self.assertEqual('CHECK', pdfc.evaluatortype)
pdfc.evaluatortype = 'OPTIMIZED'
self.assertEqual('OPTIMIZED', pdfc.evaluatortype)
return
def test_ticker_override(self):
"""check Python override of ScatteringFactorTable.ticker.
"""
from diffpy.srreal.pdfcalculator import PDFCalculator
lsft = LocalTable()
self.assertEqual(0, lsft.tcnt)
et0 = lsft.ticker()
self.assertEqual(1, lsft.tcnt)
et1 = ScatteringFactorTable.ticker(lsft)
self.assertEqual(1, lsft.tcnt)
self.assertEqual(et0, et1)
et0.click()
self.assertEqual(et0, et1)
# check that implicit ticker call from PDFCalculator is
# handled by Python override of the ticker method.
pc = PDFCalculator()
pc.scatteringfactortable = lsft
pc.ticker()
self.assertEqual(2, lsft.tcnt)
return
def test_ticker_override(self):
"""check Python override of ScatteringFactorTable.ticker.
"""
from diffpy.srreal.pdfcalculator import PDFCalculator
lsft = LocalTable()
self.assertEqual(0, lsft.tcnt)
et0 = lsft.ticker()
self.assertEqual(1, lsft.tcnt)
et1 = ScatteringFactorTable.ticker(lsft)
self.assertEqual(1, lsft.tcnt)
self.assertEqual(et0, et1)
et0.click()
self.assertEqual(et0, et1)
# check that implicit ticker call from PDFCalculator is
# handled by Python override of the ticker method.
pc = PDFCalculator()
pc.scatteringfactortable = lsft
pc.ticker()
self.assertEqual(2, lsft.tcnt)
return
def test_evaluatortype(self):
"""check PairQuantity.evaluatortype property.
"""
pq = self.pq
self.assertTrue(pq.evaluatortype in ('BASIC', 'OPTIMIZED'))
pq.evaluatortype = 'BASIC'
self.assertEqual('BASIC', pq.evaluatortype)
self.assertRaises(ValueError, setattr, pq, 'evaluatortype', 'invalid')
self.assertRaises(ValueError, setattr, pq, 'evaluatortype', 'basic')
self.assertRaises(ValueError, setattr, pq, 'evaluatortype', 'BASic')
# check all supported evaluators in PDFCalculator
pdfc = PDFCalculator()
self.assertEqual('OPTIMIZED', pdfc.evaluatortype)
pdfc.evaluatortype = 'BASIC'
self.assertEqual('BASIC', pdfc.evaluatortype)
pdfc.evaluatortype = 'CHECK'
self.assertEqual('CHECK', pdfc.evaluatortype)
pdfc.evaluatortype = 'OPTIMIZED'
self.assertEqual('OPTIMIZED', pdfc.evaluatortype)
return
def test_picking_owned(self):
'''verify pickling of envelopes owned by PDF calculators.
'''
pc = PDFCalculator()
dbpc = DebyePDFCalculator()
ltb = LocalTable()
ltb.setCustomAs('Na', 'Na', 37)
ltb.foo = 'bar'
pc.scatteringfactortable = ltb
dbpc.scatteringfactortable = ltb
self.assertIs(ltb, pc.scatteringfactortable)
self.assertIs(ltb, dbpc.scatteringfactortable)
pc2 = pickle.loads(pickle.dumps(pc))
dbpc2 = pickle.loads(pickle.dumps(dbpc))
self.assertEqual('localtable', pc2.scatteringfactortable.type())
self.assertEqual('localtable', dbpc2.scatteringfactortable.type())
self.assertEqual(37, pc2.scatteringfactortable.lookup('Na'))
self.assertEqual(37, dbpc2.scatteringfactortable.lookup('Na'))
self.assertEqual('bar', pc2.scatteringfactortable.foo)
self.assertEqual('bar', dbpc2.scatteringfactortable.foo)
return
stru.loadStrufile('CdS.cif', 'diffpy', periodic=True)
# stru.loadStrufile('fitresult/test1/m.cif', 'objcryst', False)
# stru.loadStrufile('cd35se20.xyz', 'diffpy', periodic=False)
stru.parseDiffpyStru()
# stru.parseObjcrystStru()
stru.superCell([10, 10, 10], replace=True)
a = stru.convertPeriodicStru('xyz')
# b = stru.convertDiffpyStru('xyz')
# c = stru.convertObjcrystStru('xyz_c')
# d = stru.superCell([5,5,5])
# stru.exportStru('test.stru', 'pdb', 'diffpy')
pass
from diffpy.srreal.pdfcalculator import PDFCalculator, DebyePDFCalculator
from diffpy.srreal.bondcalculator import BondCalculator
from matplotlib.pyplot import plot, show
# stru = loadStructure('CdS.cif')
pc1 = PDFCalculator()
pc1.rmax = 20
r1, g1 = pc1(a)
plot(r1, g1)
# r2, g2 = pc1(b)
# plot(r2, g2)
# r3, g3 = pc1(c)
# plot(r3, g3)
show()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from matplotlib.pyplot import *
from diffpy.Structure import loadStructure
from diffpy.srreal.pdfcalculator import PDFCalculator
from rectangleprofile import RectangleProfile
ni = loadStructure('ni.cif')
# The CIF file had no displacement data so we supply them here:
ni.Uisoequiv = 0.005
# Calculate PDF with default profile function
pc1 = PDFCalculator()
r1, g1 = pc1(ni)
print "standard peakprofile:\n " + repr(pc1.peakprofile)
# Create new calculator that uses the custom profile function
pc2 = PDFCalculator()
pc2.peakprofile = RectangleProfile()
# Note: pc2.peakprofile = 'rectangleprofile'
# would do the same, because RectangleProfile class was registered
# under its 'rectangleprofile' identifier.
print "custom peakprofile:\n " + repr(pc1.peakprofile)
r2, g2 = pc2(ni)
# compare both simulated curves
plot(r1, g1, r2, g2)
draw()
show()
def gr_lib_build(self, cif_lib_path):
''' method to calculate G(r) based on path of cif library located at.
Paramters of G(r) calculation are set via glbl.<attribute>, one can tune it based on purpose of building library.
After entire method, text file contains all G(r), space_group_symbol and material name will be saved respectively
Parameters
----------
cif_lib_path : str
path to lib of cif files
'''
el_list = [] # data column
space_group_symbol_list = [] # reference for search have been done in the past
# set up calculation environment
#dbc = DebyePDFCalculator()
pdf = PDFCalculator()
pdf.rstep = glbl.rstep
cfg = {'qmin': glbl.q_min, 'qmax':glbl.q_max, 'rmin':glbl.r_min, 'rmax': glbl.r_max}
Bisoequiv = glbl.Bisoequiv #FIXME: current value = 0.5, need to figure out the most suitable value
print('====Parameter used in this PDF calculator is: {}===='.format(cfg))
print('====Bisoequiv used in this PDF calculator is: {}===='.format(Bisoequiv))
# step 1: list cif dir
output_dir = os.path.join(self.data_dir, 'lib_data')
self._makedirs(output_dir)
self.output_dir = output_dir
cif_f_list = [ f for f in os.listdir(self.cif_dir)]
# hidden step as numpy can't take an empty array and stack
struc = loadStructure(os.path.join(self.cif_dir, cif_f_list[0]))
struc.Bisoequiv = Bisoequiv
(r,g) = pdf(nosymmetry(struc), **cfg)
r_grid = np.array(r) # data x-axis
gr_list = np.empty_like(np.array(g)) # data y-axis
for cif in cif_f_list:
# part 2: calculate PDF with diffpy
struc = loadStructure(os.path.join(self.cif_dir, cif))
struc.Bisoequiv = Bisoequiv
#(r,g) = pdf(nosymmetry(struc), **cfg)
(r,g) = pdf(struc, **cfg)
print('Finished calculation of G(r) on {}'.format(cif))
sep = cif.index('_')
space_group_symbol = cif[:sep]
m_name = cif[sep+1:]
# part 3: save data
#if not gr_list.any():
#gr_list = np.append(gr_list, g)
gr_list = np.vstack((gr_list,g))
space_group_symbol_list.append(space_group_symbol)
el_list.append(m_name)
#print('size of gr_list = {}'.format(np.shape(gr_list)))
#space_group_symbol_list = np.concatenate([space_group_symbol_list, space_group_symbol], axis=0)
#el_list = np.concatenate([el_list, m_name], axis=0)
time_info = time.strftime('%Y-%m-%d')
gr_list_name = '{}_{}_Gr'.format(self.crystal_system, time_info)
gr_list_w_name = os.path.join(output_dir, gr_list_name)
print('Saving {}'.format(gr_list_w_name))
np.save(gr_list_w_name, gr_list)
r_grid_name = '{}_{}_rgrid'.format(self.crystal_system, time_info)
r_grid_w_name = os.path.join(output_dir, r_grid_name)
np.save(r_grid_w_name, r)
space_group_symbol_list_name = '{}_{}_SpaceGroupSymbol'.format(self.crystal_system, time_info)
space_group_symbol_list_w_name= os.path.join(output_dir, space_group_symbol_list_name)
np.save(space_group_symbol_list_w_name, space_group_symbol_list) #fmt="%s")
el_list_name = '{}_{}_Element'.format(self.crystal_system, time_info)
el_list_w_name = os.path.join(output_dir, el_list_name)
np.save(el_list_w_name, el_list) #fmt="%s")
print('''====SUMMARY====:
for {} cystsal sytem,
Number of cif pulled out and G(r) calculated is {}'''.format(self.crystal_system, np.shape(gr_list)))
return gr_list
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from diffpy.Structure import loadStructure
from diffpy.srreal.pdfcalculator import PDFCalculator
from matplotlib.pyplot import plot, show
cds = loadStructure('CdS_wurtzite.cif')
pc1 = PDFCalculator()
pc1.rmax = 20
pc1.scatteringfactortable.setCustomAs('S2-', 'S', 18)
pc1.scatteringfactortable.lookup('S2-')
r1, g1 = pc1(cds)
plot(r1, g1)
pc2 = pc1.copy()
cds2 = loadStructure('CdS_wurtzite.cif')
cds2.anisotropy = False
r2, g2 = pc2(cds2)
plot(r2, g2)
plot(r1, g1-g2)
show()
import datetime
import numpy as np
import pandas as pd
from time import strftime
from pprint import pprint
import matplotlib.pyplot as plt
from diffpy.Structure import loadStructure
from diffpy.Structure import StructureFormatError
from diffpy.srreal.structureadapter import nosymmetry
from diffpy.srreal.pdfcalculator import DebyePDFCalculator
from diffpy.srreal.pdfcalculator import PDFCalculator
from pdf_lib.glbl import pdfCal_cfg, Uiso, delta2
cal = PDFCalculator()
cal.delta2 = delta2
ni = loadStructure('ni.cif')
ni.Uisoequiv = Uiso
nacl = loadStructure('1000041.cif')
nacl.Uisoequiv = Uiso
print("Uiso = {}".format(Uiso))
def qdamp_test(struc, rmax_val, qdamp_array=None):
pdfCal_cfg['rmax'] = rmax_val
N = qdamp_array.size
fig, ax = plt.subplots(N, figsize=(20, 6),
sharex=True, sharey=True)
for _ax, qdamp_val in zip(ax, qdamp_array):
pdfCal_cfg['qdamp'] = qdamp_val
class TestPDFCalculator(unittest.TestCase):
nickel = None
tio2rutile = None
def setUp(self):
self.pdfcalc = PDFCalculator()
if not self.nickel:
type(self).nickel = loadDiffPyStructure('Ni.stru')
if not self.tio2rutile:
type(self).tio2rutile = (
loadDiffPyStructure('TiO2_rutile-fit.stru'))
return
def tearDown(self):
return
def test___init__(self):
"""check PDFCalculator.__init__()
"""
pdfc = PDFCalculator(qmin=13, rmin=4, rmax=99)
self.assertEqual(13, pdfc.qmin)
self.assertEqual(4, pdfc.rmin)
self.assertEqual(99, pdfc.rmax)
self.assertEqual(99, pdfc._getDoubleAttr('rmax'))
return
def test___call__(self):
"""Check PDFCalculator.__call__()
"""
from diffpy.Structure import Structure
r0, g0 = self.pdfcalc(self.tio2rutile, rmin=2)
self.assertEqual(2.0, r0[0])
r1, g1 = self.pdfcalc(self.tio2rutile, scale=7)
self.assertAlmostEqual(7.0, g1[0] / g0[0])
# check application of spdiameter
rutile2 = Structure(self.tio2rutile)
# work around Structure bug of shared pdffit dictionary
rutile2.pdffit = dict(self.tio2rutile.pdffit)
rutile2.pdffit['spdiameter'] = 5.0
r3, g3 = self.pdfcalc(rutile2)
self.assertEqual(0.0, sum(g3[r3 >= 5] ** 2))
r4, g4 = self.pdfcalc(rutile2, scale=1, spdiameter=0)
self.failUnless(numpy.all(r4 == r0))
self.failUnless(numpy.all(g4 == g0))
return
def test__getDoubleAttr(self):
"""check PDFCalculator._getDoubleAttr()
"""
gdba = self.pdfcalc._getDoubleAttr
self.assertEqual(1.0, gdba('scale'))
self.assertEqual(0.0, gdba('qdamp'))
self.assertRaises(Exception, gdba, 'notanattribute')
return
def test__hasDoubleAttr(self):
"""check PDFCalculator._hasDoubleAttr()
"""
self.failUnless(self.pdfcalc._hasDoubleAttr('scale'))
self.failIf(self.pdfcalc._hasDoubleAttr('notanattribute'))
return
def test__namesOfDoubleAttributes(self):
"""check PDFCalculator._namesOfDoubleAttributes()
"""
self.failUnless(type(self.pdfcalc._namesOfDoubleAttributes()) is set)
self.failUnless('qmax' in self.pdfcalc._namesOfDoubleAttributes())
return
def test__setDoubleAttr(self):
"""check PDFCalculator._setDoubleAttr()
"""
gdba = self.pdfcalc._getDoubleAttr
sdba = self.pdfcalc._setDoubleAttr
self.assertEqual(0.0, gdba('rmin'))
sdba('rmin', 3.0)
self.assertEqual(3.0, gdba('rmin'))
return
def test_eval_nickel(self):
"""check PDFCalculator.eval() on simple Nickel data
"""
fnipf2 = datafile('Ni-fit.fgr')
gpf2 = numpy.loadtxt(fnipf2, usecols=(1,))
self.pdfcalc._setDoubleAttr('rmax', 10.0001)
self.pdfcalc.eval(self.nickel)
gcalc = self.pdfcalc.pdf
self.failUnless(_maxNormDiff(gpf2, gcalc) < 0.0091)
return
def test_eval_rutile(self):
"""check PDFCalculator.eval() on anisotropic rutile data
"""
frutile = datafile('TiO2_rutile-fit.fgr')
gpf2 = numpy.loadtxt(frutile, usecols=(1,))
# configure calculator according to testdata/TiO2_ruitile-fit.fgr
self.pdfcalc.qmax = 26
self.pdfcalc.qdamp = 0.0665649
dscale = 0.655857
self.pdfcalc.rmin = 1
self.pdfcalc.rmax = 30.0001
# apply data scale
self.pdfcalc(self.tio2rutile)
self.pdfcalc.scale *= dscale
gcalc = self.pdfcalc.pdf
# termination at rmin is poorly cut in PDFfit2
mxnd = _maxNormDiff(gpf2, gcalc)
self.failUnless(mxnd < 0.057)
# more accurate from 1.5
mxnd1 = _maxNormDiff(gpf2[:500], gcalc[:500])
mxnd2 = _maxNormDiff(gpf2[500:], gcalc[500:])
self.failUnless(mxnd1 < 0.056)
self.failUnless(mxnd2 < 0.020)
return
def test_partial_pdfs(self):
"""Check calculation of partial PDFs.
"""
pdfc = self.pdfcalc
pdfc.rstep = 0.1
rutile = self.tio2rutile
atomtypes = [a.element for a in rutile]
r0, g0 = pdfc(rutile)
rdf0 = pdfc.rdf
# Ti-Ti
pdfc.maskAllPairs(False)
pdfc.setTypeMask("Ti", "Ti", True)
r1, g1 = pdfc(rutile)
rdf1 = pdfc.rdf
self.failUnless(numpy.array_equal(r0, r1))
pdfc.invertMask()
r1i, g1i = pdfc(rutile)
rdf1i = pdfc.rdf
self.failUnless(numpy.array_equal(r0, r1i))
self.failUnless(numpy.allclose(g0, g1 + g1i))
self.failUnless(numpy.allclose(rdf0, rdf1 + rdf1i))
# Ti-O
pdfc.maskAllPairs(True)
pdfc.setPairMask(range(2), range(2), False)
pdfc.setPairMask(range(2, 6), range(2, 6), False)
r2, g2 = pdfc(rutile)
rdf2 = pdfc.rdf
self.failUnless(numpy.array_equal(r0, r2))
pdfc.invertMask()
r2i, g2i = pdfc(rutile)
rdf2i = pdfc.rdf
self.failUnless(numpy.allclose(g0, g2 + g2i))
self.failUnless(numpy.allclose(rdf0, rdf2 + rdf2i))
# Ti-O using type mask
pdfc.maskAllPairs(True)
pdfc.setTypeMask("Ti", "Ti", False)
pdfc.setTypeMask("O", "O", False)
r2t, g2t = pdfc(rutile)
rdf2t = pdfc.rdf
self.failUnless(numpy.array_equal(r0, r2t))
self.failUnless(numpy.array_equal(g2, g2t))
self.failUnless(numpy.array_equal(rdf2, rdf2t))
pdfc.invertMask()
r2ti, g2ti = pdfc(rutile)
rdf2ti = pdfc.rdf
self.failUnless(numpy.array_equal(g2i, g2ti))
self.failUnless(numpy.array_equal(rdf2i, rdf2ti))
# O-O
pdfc.maskAllPairs(False)
for i, smbli in enumerate(atomtypes):
for j, smblj in enumerate(atomtypes):
if smbli == smblj == "O":
pdfc.setPairMask(i, j, True)
r3, g3 = pdfc(rutile)
rdf3 = pdfc.rdf
pdfc.invertMask()
r3i, g3i = pdfc(rutile)
rdf3i = pdfc.rdf
self.failUnless(numpy.allclose(g0, g3 + g3i))
self.failUnless(numpy.allclose(rdf0, rdf3 + rdf3i))
# check the sum of all partials
self.failUnless(numpy.allclose(g0, g1 + g2 + g3))
self.failUnless(numpy.allclose(rdf0, rdf1 + rdf2 + rdf3))
return
def test_full_mask(self):
'''Test PDFCalculator for a fully masked structure.
'''
pdfc = self.pdfcalc
pdfc.rstep = 0.1
rutile = self.tio2rutile
pdfc.maskAllPairs(True)
r0, g0 = pdfc(rutile)
pdfc.maskAllPairs(False)
r1, g1 = pdfc(rutile)
self.assertEqual(0.0, numpy.dot(g1, g1))
indices = range(len(rutile))
pdfc.setPairMask(indices, indices, True)
r2, g2 = pdfc(rutile)
self.failUnless(numpy.array_equal(g0, g2))
return
def test_zero_mask(self):
'''Test PDFCalculator with a totally masked out structure.
'''
pdfc = self.pdfcalc
pdfc.rstep = 0.1
rutile = self.tio2rutile
indices = range(len(rutile))
for i in indices:
for j in indices:
pdfc.setPairMask(i, j, False)
r, g = pdfc(rutile)
self.assertEqual(0.0, numpy.dot(g, g))
rdf = pdfc.rdf
self.assertEqual(0.0, numpy.dot(rdf, rdf))
return
def test_pickling(self):
'''check pickling and unpickling of PDFCalculator.
'''
pdfc = self.pdfcalc
pdfc.setScatteringFactorTableByType('N')
pdfc.scatteringfactortable.setCustomAs('Na', 'Na', 7)
pdfc.addEnvelopeByType('sphericalshape')
pdfc.delta1 = 0.2
pdfc.delta2 = 0.3
pdfc.maxextension = 10.1
pdfc.peakprecision = 5e-06
pdfc.qbroad = 0.01
pdfc.qdamp = 0.05
pdfc.qmax = 10
pdfc.qmin = 0.5
pdfc.rmax = 10.0
pdfc.rmin = 0.02
pdfc.rstep = 0.02
pdfc.scale = 1.1
pdfc.slope = 0.1
pdfc.spdiameter = 13.3
pdfc.foobar = 'asdf'
spkl = cPickle.dumps(pdfc)
pdfc1 = cPickle.loads(spkl)
sft = pdfc.scatteringfactortable
sft1 = pdfc1.scatteringfactortable
self.assertEqual(sft.type(), sft1.type())
self.assertEqual(7.0, sft1.lookup('Na'))
for a in pdfc._namesOfDoubleAttributes():
self.assertEqual(getattr(pdfc, a), getattr(pdfc1, a))
self.assertEqual(13.3,
pdfc1.getEnvelopeByType('sphericalshape').spdiameter)
self.assertEqual(pdfc._namesOfDoubleAttributes(),
pdfc1._namesOfDoubleAttributes())
self.assertEqual(pdfc.usedenvelopetypes, pdfc1.usedenvelopetypes)
self.assertEqual('asdf', pdfc1.foobar)
return
def test_mask_pickling(self):
'''Check if mask gets properly pickled and restored.
'''
self.pdfcalc.maskAllPairs(False)
self.pdfcalc.setPairMask(0, 1, True)
self.failUnless(False is self.pdfcalc.getPairMask(0, 0))
self.failUnless(True is self.pdfcalc.getPairMask(0, 1))
pdfcalc1 = cPickle.loads(cPickle.dumps(self.pdfcalc))
self.failUnless(False is pdfcalc1.getPairMask(0, 0))
self.failUnless(True is pdfcalc1.getPairMask(0, 1))
return
