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 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_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(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_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_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_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 setUp(self):
MySawTooth()._registerThisType()
self.pc = PDFCalculator()
self.pc.peakprofile = 'mysawtooth'
self.pkf = self.pc.peakprofile
self.pkf.peakprecision = 0.0017
return
def __init__(self, name = "pdf"):
"""Initialize the generator.
"""
from diffpy.srreal.pdfcalculator import PDFCalculator
BasePDFGenerator.__init__(self, name)
self._setCalculator(PDFCalculator())
return
def __init__(self, name="pdf"):
"""Initialize the generator.
"""
BasePDFGenerator.__init__(self, name)
self._setCalculator(PDFCalculator())
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_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__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 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_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 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___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__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___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_parallel_evaluatortype(self):
"""check handling of the evaluatortype property
"""
from diffpy.srreal.pdfcalculator import PDFCalculator
pdfc = PDFCalculator()
self.assertEqual('OPTIMIZED', pdfc.evaluatortype)
ppdfc = createParallelCalculator(pdfc, 2, map)
self.assertEqual('BASIC', ppdfc.evaluatortype)
self.assertEqual('BASIC', pdfc.evaluatortype)
ppdfc.evaluatortype = 'BASIC'
self.assertRaises(ValueError, setattr, ppdfc, 'evaluatortype',
'OPTIMIZED')
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 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_nosymmetry(self):
'''check NoSymmetryStructureAdapter.
'''
pdfc0 = PDFCalculator()
r0, g0 = pdfc0(self.nickel)
rdf0 = pdfc0.rdf
niuc = nosymmetry(self.nickel)
self.assertTrue(niuc is nosymmetry(niuc))
pdfc1 = PDFCalculator()
r1, g1 = pdfc1(niuc)
self.assertTrue(numpy.array_equal(r0, r1))
self.assertFalse(numpy.allclose(g0, g1))
tail = (r0 > 5.0)
self.assertTrue(numpy.allclose(0.0 * g1[tail], g1[tail]))
rdf0 = pdfc0.rdf
rdf1 = pdfc1.rdf
head = r0 < 3.0
self.assertAlmostEqual(12.0, numpy.sum(rdf0[head] * pdfc0.rstep), 5)
self.assertAlmostEqual(3.0, numpy.sum(rdf1[head] * pdfc1.rstep), 5)
adpt0 = createStructureAdapter(self.nickel)
ra2, ga2 = PDFCalculator()(nosymmetry(adpt0))
self.assertTrue(numpy.array_equal(r0, ra2))
self.assertTrue(numpy.allclose(g1, ga2))
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 _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_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 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
