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