class TestPDFGenerator(testoptional(TestCaseStructure, TestCasePDF)):
def setUp(self):
global PDFGenerator
from diffpy.srfit.pdf import PDFGenerator
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
class TestCreateSpaceGroup(testoptional(TestCaseObjCryst)):
"""Test space group creation from pyobjcryst structures.
This makes sure that the space groups created by the structure parameter
set are correct.
"""
def setUp(self):
global ObjCrystCrystalParSet, SpaceGroups
from diffpy.srfit.structure.objcrystparset import ObjCrystCrystalParSet
from diffpy.Structure import SpaceGroups
@staticmethod
def getObjCrystParSetSpaceGroup(sg):
"""Make an ObjCrystCrystalParSet with the proper space group."""
from pyobjcryst.spacegroup import SpaceGroup
sgobjcryst = SpaceGroup(sg.short_name)
sgnew = ObjCrystCrystalParSet._createSpaceGroup(sgobjcryst)
return sgnew
@staticmethod
def hashDiffPySpaceGroup(sg):
lines = [str(sg.number % 1000)] + sorted(map(str, sg.iter_symops()))
s = '\n'.join(lines)
return s
def sgsEquivalent(self, sg1, sg2):
"""Check to see if two space group objects are the same."""
hash1 = self.hashDiffPySpaceGroup(sg1)
hash2 = self.hashDiffPySpaceGroup(sg2)
return hash1 == hash2
# FIXME: only about 50% of the spacegroups pass the assertion
# test disabled even if cctbx is installed
def xtestCreateSpaceGroup(self):
"""Check all sgtbx space groups for proper conversion to SpaceGroup."""
try:
from cctbx import sgtbx
except ImportError:
return
for smbls in sgtbx.space_group_symbol_iterator():
shn = smbls.hermann_mauguin()
short_name = shn.replace(' ', '')
if SpaceGroups.IsSpaceGroupIdentifier(short_name):
sg = SpaceGroups.GetSpaceGroup(shn)
sgnew = self.getObjCrystParSetSpaceGroup(sg)
# print "dbsg: " + repr(self.sgsEquivalent(sg, sgnew))
self.assertTrue(self.sgsEquivalent(sg, sgnew))
return
class TestPDFContribution(testoptional(TestCaseStructure, TestCasePDF)):
def setUp(self):
global PDFContribution
from diffpy.srfit.pdf import PDFContribution
self.pc = PDFContribution('pdf')
return
def test_setQmax(self):
"""check PDFContribution.setQmax()
"""
from diffpy.Structure import Structure
pc = self.pc
pc.setQmax(21)
pc.addStructure('empty', Structure())
self.assertEqual(21, pc.empty.getQmax())
pc.setQmax(22)
self.assertEqual(22, pc.getQmax())
self.assertEqual(22, pc.empty.getQmax())
return
def test_getQmax(self):
"""check PDFContribution.getQmax()
"""
from diffpy.Structure import Structure
# cover all code branches in PDFContribution._getMetaValue
# (1) contribution metadata
pc1 = self.pc
self.assertIsNone(pc1.getQmax())
pc1.setQmax(17)
self.assertEqual(17, pc1.getQmax())
# (2) contribution metadata
pc2 = PDFContribution('pdf')
pc2.addStructure('empty', Structure())
pc2.empty.setQmax(18)
self.assertEqual(18, pc2.getQmax())
# (3) profile metadata
pc3 = PDFContribution('pdf')
pc3.profile.meta['qmax'] = 19
self.assertEqual(19, pc3.getQmax())
return
class TestPDFParset(testoptional(TestCasePDF)):
def setUp(self):
global PDFParser
from diffpy.srfit.pdf import PDFParser
def testParser1(self):
data = datafile("ni-q27r100-neutron.gr")
parser = PDFParser()
parser.parseFile(data)
meta = parser._meta
self.assertEqual(data, meta['filename'])
self.assertEqual(1, meta['nbanks'])
self.assertEqual('N', meta['stype'])
self.assertEqual(27, meta['qmax'])
self.assertEquals(300, meta.get('temperature'))
self.assertEquals(None, meta.get('qdamp'))
self.assertEquals(None, meta.get('qbroad'))
self.assertEquals(None, meta.get('spdiameter'))
self.assertEquals(None, meta.get('scale'))
self.assertEquals(None, meta.get('doping'))
x, y, dx, dy = parser.getData()
self.assertTrue(dx is None)
self.assertTrue(dy is None)
testx = numpy.linspace(0.01, 100, 10000)
diff = testx - x
res = numpy.dot(diff, diff)
self.assertAlmostEqual(0, res)
testy = numpy.array([1.144, 2.258, 3.312, 4.279, 5.135, 5.862, 6.445,
6.875, 7.150, 7.272])
diff = testy - y[:10]
res = numpy.dot(diff, diff)
self.assertAlmostEqual(0, res)
return
def testParser2(self):
data = datafile("si-q27r60-xray.gr")
parser = PDFParser()
parser.parseFile(data)
meta = parser._meta
self.assertEqual(data, meta['filename'])
self.assertEqual(1, meta['nbanks'])
self.assertEqual('X', meta['stype'])
self.assertEqual(27, meta['qmax'])
self.assertEquals(300, meta.get('temperature'))
self.assertEquals(None, meta.get('qdamp'))
self.assertEquals(None, meta.get('qbroad'))
self.assertEquals(None, meta.get('spdiameter'))
self.assertEquals(None, meta.get('scale'))
self.assertEquals(None, meta.get('doping'))
x, y, dx, dy = parser.getData()
testx = numpy.linspace(0.01, 60, 5999, endpoint=False)
diff = testx - x
res = numpy.dot(diff, diff)
self.assertAlmostEqual(0, res)
testy = numpy.array([0.1105784, 0.2199684, 0.3270088, 0.4305913,
0.5296853, 0.6233606, 0.7108060, 0.7913456, 0.8644501, 0.9297440])
diff = testy - y[:10]
res = numpy.dot(diff, diff)
self.assertAlmostEqual(0, res)
testdy = numpy.array([0.001802192, 0.003521449, 0.005079115,
0.006404892, 0.007440527, 0.008142955, 0.008486813, 0.008466340,
0.008096858, 0.007416456])
diff = testdy - dy[:10]
res = numpy.dot(diff, diff)
self.assertAlmostEqual(0, res)
self.assertTrue(dx is None)
return
class TestSASCF(testoptional(TestCaseSaS, TestCasePDF)):
def setUp(self):
global cf
import diffpy.srfit.pdf.characteristicfunctions as cf
def testSphere(self):
radius = 25
# Calculate sphere cf from SphereModel
from sans.models.SphereModel import SphereModel
model = SphereModel()
model.setParam("radius", radius)
ff = cf.SASCF("sphere", model)
r = numpy.arange(1, 60, 0.1, dtype = float)
fr1 = ff(r)
# Calculate sphere cf analytically
fr2 = cf.sphericalCF(r, 2*radius)
diff = fr1 - fr2
res = numpy.dot(diff, diff)
res /= numpy.dot(fr2, fr2)
self.assertAlmostEqual(0, res, 4)
return
def testSpheroid(self):
prad = 20.9
erad = 33.114
# Calculate cf from EllipsoidModel
from sans.models.EllipsoidModel import EllipsoidModel
model = EllipsoidModel()
model.setParam("radius_a", prad)
model.setParam("radius_b", erad)
ff = cf.SASCF("spheroid", model)
r = numpy.arange(0, 100, 1/numpy.pi, dtype = float)
fr1 = ff(r)
# Calculate cf analytically
fr2 = cf.spheroidalCF(r, erad, prad)
diff = fr1 - fr2
res = numpy.dot(diff, diff)
res /= numpy.dot(fr2, fr2)
self.assertAlmostEqual(0, res, 4)
return
def testShell(self):
radius = 19.2
thickness = 7.8
# Calculate cf from VesicleModel
from sans.models.VesicleModel import VesicleModel
model = VesicleModel()
model.setParam("radius", radius)
model.setParam("thickness", thickness)
ff = cf.SASCF("vesicle", model)
r = numpy.arange(0, 99.45, 0.1, dtype = float)
fr1 = ff(r)
# Calculate sphere cf analytically
fr2 = cf.shellCF(r, radius, thickness)
diff = fr1 - fr2
res = numpy.dot(diff, diff)
res /= numpy.dot(fr2, fr2)
self.assertAlmostEqual(0, res, 4)
return
def testCylinder(self):
"""Make sure cylinder works over different r-ranges"""
radius = 100
length = 30
from sans.models.CylinderModel import CylinderModel
model = CylinderModel()
model.setParam("radius", radius)
model.setParam("length", length)
ff = cf.SASCF("cylinder", model)
r1 = numpy.arange(0, 10, 0.1, dtype = float)
r2 = numpy.arange(0, 50, 0.1, dtype = float)
r3 = numpy.arange(0, 100, 0.1, dtype = float)
r4 = numpy.arange(0, 500, 0.1, dtype = float)
fr1 = ff(r1)
fr2 = ff(r2)
fr3 = ff(r3)
fr4 = ff(r4)
d = fr1 - numpy.interp(r1, r2, fr2)
res12 = numpy.dot(d,d)
res12 /= numpy.dot(fr1, fr1)
self.assertAlmostEqual(0, res12, 4)
d = fr1 - numpy.interp(r1, r3, fr3)
res13 = numpy.dot(d,d)
res13 /= numpy.dot(fr1, fr1)
self.assertAlmostEqual(0, res13, 4)
d = fr1 - numpy.interp(r1, r4, fr4)
res14 = numpy.dot(d,d)
res14 /= numpy.dot(fr1, fr1)
self.assertAlmostEqual(0, res14, 4)
d = fr2 - numpy.interp(r2, r3, fr3)
res23 = numpy.dot(d,d)
res23 /= numpy.dot(fr2, fr2)
self.assertAlmostEqual(0, res23, 4)
d = fr2 - numpy.interp(r2, r4, fr4)
res24 = numpy.dot(d,d)
res24 /= numpy.dot(fr2, fr2)
self.assertAlmostEqual(0, res24, 4)
d = fr3 - numpy.interp(r3, r4, fr4)
res34 = numpy.dot(d,d)
res34 /= numpy.dot(fr3, fr3)
self.assertAlmostEqual(0, res34, 4)
return
class TestParameterAdapter(testoptional(TestCaseStructure)):
def setUp(self):
global Atom, Lattice, Structure, DiffpyStructureParSet
from diffpy.Structure import Atom, Lattice, Structure
from diffpy.srfit.structure.diffpyparset import DiffpyStructureParSet
def testDiffpyStructureParSet(self):
"""Test the structure conversion."""
a1 = Atom("Cu", xyz = numpy.array([.0, .1, .2]), Uisoequiv = 0.003)
a2 = Atom("Ag", xyz = numpy.array([.3, .4, .5]), Uisoequiv = 0.002)
l = Lattice(2.5, 2.5, 2.5, 90, 90, 90)
dsstru = Structure([a1,a2], l)
# Structure makes copies
a1 = dsstru[0]
a2 = dsstru[1]
s = DiffpyStructureParSet("CuAg", dsstru)
self.assertEquals(s.name, "CuAg")
def _testAtoms():
# Check the atoms thoroughly
self.assertEquals(a1.element, s.Cu0.element)
self.assertEquals(a2.element, s.Ag0.element)
self.assertEquals(a1.Uisoequiv, s.Cu0.Uiso.getValue())
self.assertEquals(a2.Uisoequiv, s.Ag0.Uiso.getValue())
self.assertEquals(a1.Bisoequiv, s.Cu0.Biso.getValue())
self.assertEquals(a2.Bisoequiv, s.Ag0.Biso.getValue())
for i in xrange(1,4):
for j in xrange(i,4):
uijstru = getattr(a1, "U%i%i"%(i,j))
uij = getattr(s.Cu0, "U%i%i"%(i,j)).getValue()
uji = getattr(s.Cu0, "U%i%i"%(j,i)).getValue()
self.assertEquals(uijstru, uij)
self.assertEquals(uijstru, uji)
bijstru = getattr(a1, "B%i%i"%(i,j))
bij = getattr(s.Cu0, "B%i%i"%(i,j)).getValue()
bji = getattr(s.Cu0, "B%i%i"%(j,i)).getValue()
self.assertEquals(bijstru, bij)
self.assertEquals(bijstru, bji)
self.assertEquals(a1.xyz[0], s.Cu0.x.getValue())
self.assertEquals(a1.xyz[1], s.Cu0.y.getValue())
self.assertEquals(a1.xyz[2], s.Cu0.z.getValue())
return
def _testLattice():
# Test the lattice
self.assertEquals(dsstru.lattice.a, s.lattice.a.getValue())
self.assertEquals(dsstru.lattice.b, s.lattice.b.getValue())
self.assertEquals(dsstru.lattice.c, s.lattice.c.getValue())
self.assertEquals(dsstru.lattice.alpha, s.lattice.alpha.getValue())
self.assertEquals(dsstru.lattice.beta, s.lattice.beta.getValue())
self.assertEquals(dsstru.lattice.gamma, s.lattice.gamma.getValue())
_testAtoms()
_testLattice()
# Now change some values from the diffpy Structure
a1.xyz[1] = 0.123
a1.U11 = 0.321
a1.B32 = 0.111
dsstru.lattice.setLatPar(a=3.0, gamma=121)
_testAtoms()
_testLattice()
# Now change values from the srfit DiffpyStructureParSet
s.Cu0.x.setValue(0.456)
s.Cu0.U22.setValue(0.441)
s.Cu0.B13.setValue(0.550)
d = dsstru.lattice.dist(a1.xyz, a2.xyz)
s.lattice.b.setValue(4.6)
s.lattice.alpha.setValue(91.3)
_testAtoms()
_testLattice()
# Make sure the distance changed
self.assertNotEquals(d, dsstru.lattice.dist(a1.xyz, a2.xyz))
return
class TestSGConstraints(testoptional(TestCaseStructure, TestCaseObjCryst)):
def setUp(self):
global ObjCrystCrystalParSet, DiffpyStructureParSet
from diffpy.srfit.structure.objcrystparset import ObjCrystCrystalParSet
from diffpy.srfit.structure.diffpyparset import DiffpyStructureParSet
def testConstrainSpaceGroup(self):
"""Make sure that all Parameters are constrained properly.
This tests constrainSpaceGroup from
diffpy.srfit.structure.sgconstraints, which is performed automatically
when an ObjCrystCrystalParSet is created.
"""
pi = numpy.pi
occryst = makeLaMnO3()
stru = ObjCrystCrystalParSet(occryst.GetName(), occryst)
# Make sure we actually create the constraints
stru._constrainSpaceGroup()
# Make the space group parameters individually
stru.sgpars.latpars
stru.sgpars.xyzpars
stru.sgpars.adppars
# Check the orthorhombic lattice
l = stru.getLattice()
self.assertTrue( l.alpha.const )
self.assertTrue( l.beta.const )
self.assertTrue( l.gamma.const )
self.assertEquals(pi/2, l.alpha.getValue())
self.assertEquals(pi/2, l.beta.getValue())
self.assertEquals(pi/2, l.gamma.getValue())
self.assertFalse( l.a.const )
self.assertFalse( l.b.const )
self.assertFalse( l.c.const )
self.assertEquals(0, len(l._constraints))
# Now make sure the scatterers are constrained properly
scatterers = stru.getScatterers()
la = scatterers[0]
self.assertFalse(la.x.const)
self.assertFalse(la.y.const)
self.assertTrue(la.z.const)
self.assertEquals(0, len(la._constraints))
mn = scatterers[1]
self.assertTrue(mn.x.const)
self.assertTrue(mn.y.const)
self.assertTrue(mn.z.const)
self.assertEquals(0, len(mn._constraints))
o1 = scatterers[2]
self.assertFalse(o1.x.const)
self.assertFalse(o1.y.const)
self.assertTrue(o1.z.const)
self.assertEquals(0, len(o1._constraints))
o2 = scatterers[3]
self.assertFalse(o2.x.const)
self.assertFalse(o2.y.const)
self.assertFalse(o2.z.const)
self.assertEquals(0, len(o2._constraints))
# Make sure we can't constrain these
self.assertRaises(ValueError, mn.constrain, mn.x, "y")
self.assertRaises(ValueError, mn.constrain, mn.y, "z")
self.assertRaises(ValueError, mn.constrain, mn.z, "x")
# Nor can we make them into variables
from diffpy.srfit.fitbase.fitrecipe import FitRecipe
f = FitRecipe()
self.assertRaises(ValueError, f.addVar, mn.x)
return
def testConstrainAsSpaceGroup(self):
"""Test the constrainAsSpaceGroup function."""
from diffpy.srfit.structure.sgconstraints import constrainAsSpaceGroup
stru = makeLaMnO3_P1()
parset = DiffpyStructureParSet("LaMnO3", stru)
sgpars = constrainAsSpaceGroup(parset, "P b n m",
scatterers = parset.getScatterers()[::2],
constrainadps = True)
# Make sure that the new parameters were created
for par in sgpars:
self.assertNotEquals(None, par)
self.assertNotEquals(None, par.getValue() )
# Test the unconstrained atoms
for scatterer in parset.getScatterers()[1::2]:
self.assertFalse(scatterer.x.const)
self.assertFalse(scatterer.y.const)
self.assertFalse(scatterer.z.const)
self.assertFalse(scatterer.U11.const)
self.assertFalse(scatterer.U22.const)
self.assertFalse(scatterer.U33.const)
self.assertFalse(scatterer.U12.const)
self.assertFalse(scatterer.U13.const)
self.assertFalse(scatterer.U23.const)
self.assertEquals(0, len(scatterer._constraints))
proxied = [p.par for p in sgpars]
def _consttest(par):
return par.const
def _constrainedtest(par):
return par.constrained
def _proxytest(par):
return par in proxied
def _alltests(par):
return _consttest(par) or _constrainedtest(par) or _proxytest(par)
for idx, scatterer in enumerate(parset.getScatterers()[::2]):
# Under this scheme, atom 6 is free to vary
test = False
for par in [scatterer.x, scatterer.y, scatterer.z]:
test |= _alltests(par)
self.assertTrue(test)
test = False
for par in [scatterer.U11, scatterer.U22, scatterer.U33,
scatterer.U12, scatterer.U13, scatterer.U23]:
test |= _alltests(par)
self.assertTrue(test)
return
