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