示例#1
0
 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.assertTrue(numpy.array_equal(r0, r1))
     self.assertTrue(numpy.allclose(g0, g1))
     ppdfc2 = createParallelCalculator(PDFCalculator(),
             self.ncpu, self.pool.imap_unordered)
     r2, g2 = ppdfc2(self.cdse)
     self.assertTrue(numpy.array_equal(r0, r2))
     self.assertTrue(numpy.allclose(g0, g2))
     pdfc.rmax = ppdfc1.rmax = ppdfc2.rmax = 5
     pdfc.qmax = ppdfc1.qmax = ppdfc2.qmax = 15
     r0a, g0a = pdfc()
     self.assertTrue(numpy.all(r0a <= 5))
     self.assertFalse(numpy.allclose(g0a, numpy.interp(r0a, r0, g0)))
     r1a, g1a = ppdfc1()
     self.assertTrue(numpy.array_equal(r0a, r1a))
     self.assertTrue(numpy.allclose(g0a, g1a))
     r2a, g2a = ppdfc2()
     self.assertTrue(numpy.array_equal(r0a, r2a))
     self.assertTrue(numpy.allclose(g0a, g2a))
     return
示例#2
0
 def test_parallel_bonds(self):
     """check parallel BondCalculator
     """
     from diffpy.srreal.bondcalculator import BondCalculator
     nickel = self.nickel
     bc = BondCalculator()
     d0 = bc(nickel)
     pbc1 = createParallelCalculator(BondCalculator(), 3, map)
     d1 = pbc1(nickel)
     self.assertTrue(numpy.array_equal(d0, d1))
     pbc2 = createParallelCalculator(BondCalculator(),
             self.ncpu, self.pool.imap_unordered)
     d2 = pbc2(nickel)
     self.assertTrue(numpy.array_equal(d0, d2))
     bc.rmax = pbc1.rmax = pbc2.rmax = 2.5
     for bci in (bc, pbc1, pbc2):
         bci.maskAllPairs(False)
         bci.setPairMask(0, 'all', True)
         bci.filterCone([1, 0, 0], 48)
     d0a = bc(nickel)
     self.assertEqual(8, len(d0a))
     d1a = pbc1(nickel)
     self.assertTrue(numpy.array_equal(d0a, d1a))
     d2a = pbc2(nickel)
     self.assertTrue(numpy.array_equal(d0a, d2a))
     return
示例#3
0
 def test_parallel_bonds(self):
     """check parallel BondCalculator
     """
     from diffpy.srreal.bondcalculator import BondCalculator
     nickel = self.nickel
     bc = BondCalculator()
     d0 = bc(nickel)
     pbc1 = createParallelCalculator(BondCalculator(), 3, map)
     d1 = pbc1(nickel)
     self.failUnless(numpy.array_equal(d0, d1))
     pbc2 = createParallelCalculator(BondCalculator(), self.ncpu,
                                     self.pool.imap_unordered)
     d2 = pbc2(nickel)
     self.failUnless(numpy.array_equal(d0, d2))
     bc.rmax = pbc1.rmax = pbc2.rmax = 2.5
     for bci in (bc, pbc1, pbc2):
         bci.maskAllPairs(False)
         bci.setPairMask(0, 'all', True)
         bci.filterCone([1, 0, 0], 48)
     d0a = bc(nickel)
     self.assertEqual(8, len(d0a))
     d1a = pbc1(nickel)
     self.failUnless(numpy.array_equal(d0a, d1a))
     d2a = pbc2(nickel)
     self.failUnless(numpy.array_equal(d0a, d2a))
     return
示例#4
0
 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 parallel(self, ncpu, mapfunc = None):
        """Run calculation in parallel.

        ncpu    -- Number of parallel processes.  Revert to serial mode when 1.
        mapfunc -- A mapping function to use. If this is None (default),
                   multiprocessing.Pool.imap_unordered will be used.

        No return value.
        """
        from diffpy.srreal.parallel import createParallelCalculator
        calc_serial = self._calc
        if hasattr(calc_serial, 'pqobj'):
            calc_serial = calc_serial.pqobj
        # revert to serial calculator for ncpu <= 1
        if ncpu <= 1:
            self._calc = calc_serial
            self._pool = None
            return
        # Why don't we let the user shoot his foot or test on single CPU?
        # ncpu = min(ncpu, multiprocessing.cpu_count())
        if mapfunc is None:
            import multiprocessing
            self._pool = multiprocessing.Pool(ncpu)
            mapfunc = self._pool.imap_unordered

        self._calc = createParallelCalculator(calc_serial, ncpu, mapfunc)
        return
示例#6
0
    def parallel(self, ncpu, mapfunc=None):
        """Run calculation in parallel.

        ncpu    -- Number of parallel processes.  Revert to serial mode when 1.
        mapfunc -- A mapping function to use. If this is None (default),
                   multiprocessing.Pool.imap_unordered will be used.

        No return value.
        """
        from diffpy.srreal.parallel import createParallelCalculator
        calc_serial = self._calc
        if hasattr(calc_serial, 'pqobj'):
            calc_serial = calc_serial.pqobj
        # revert to serial calculator for ncpu <= 1
        if ncpu <= 1:
            self._calc = calc_serial
            self._pool = None
            return
        # Why don't we let the user shoot his foot or test on single CPU?
        # ncpu = min(ncpu, multiprocessing.cpu_count())
        if mapfunc is None:
            import multiprocessing
            self._pool = multiprocessing.Pool(ncpu)
            mapfunc = self._pool.imap_unordered

        self._calc = createParallelCalculator(calc_serial, ncpu, mapfunc)
        return
示例#7
0
 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
示例#8
0
 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_parallel(self):
     """check parallel run of OverlapCalculator
     """
     import multiprocessing
     from diffpy.srreal.parallel import createParallelCalculator
     ncpu = 4
     self.pool = multiprocessing.Pool(processes=ncpu)
     olc = self.olc
     polc = createParallelCalculator(OverlapCalculator(),
             ncpu, self.pool.imap_unordered)
     olc.atomradiitable.fromString('Ti:1.6, O:0.66')
     polc.atomradiitable = olc.atomradiitable
     self.assertTrue(numpy.array_equal(olc(self.rutile), polc(self.rutile)))
     self.assertTrue(olc.totalsquareoverlap > 0.0)
     self.assertEqual(olc.totalsquareoverlap, polc.totalsquareoverlap)
     self.assertEqual(sorted(zip(olc.sites0, olc.sites1)),
             sorted(zip(polc.sites0, polc.sites1)))
     olc.atomradiitable.resetAll()
     self.assertEqual(0.0, sum(olc(self.rutile)))
     self.assertEqual(0.0, sum(polc(self.rutile)))
     return
 def test_parallel(self):
     """check parallel run of OverlapCalculator
     """
     import multiprocessing
     from diffpy.srreal.parallel import createParallelCalculator
     ncpu = 4
     self.pool = multiprocessing.Pool(processes=ncpu)
     olc = self.olc
     polc = createParallelCalculator(OverlapCalculator(), ncpu,
                                     self.pool.imap_unordered)
     olc.atomradiitable.fromString('Ti:1.6, O:0.66')
     polc.atomradiitable = olc.atomradiitable
     self.assertTrue(numpy.array_equal(olc(self.rutile), polc(self.rutile)))
     self.assertTrue(olc.totalsquareoverlap > 0.0)
     self.assertEqual(olc.totalsquareoverlap, polc.totalsquareoverlap)
     self.assertEqual(sorted(zip(olc.sites0, olc.sites1)),
                      sorted(zip(polc.sites0, polc.sites1)))
     olc.atomradiitable.resetAll()
     self.assertEqual(0.0, sum(olc(self.rutile)))
     self.assertEqual(0.0, sum(polc(self.rutile)))
     return
示例#11
0
# number of CPUs for parallel calculation
ncpu = multiprocessing.cpu_count()

# calculate PDF on a single core
t0 = time.time()
pc0 = PDFCalculator(**cfg)
r0, g0 = pc0(menthol)
t0 = time.time() - t0
print "Calculation time on 1 CPU: %g" % t0

# create a pool of workers
pool = multiprocessing.Pool(processes=ncpu)

t1 = time.time()
# create a proxy parrallel calculator to PDFCalculator pc0,
# that uses ncpu parallel jobs submitted via pool.imap_unordered
pc1 = createParallelCalculator(pc0, ncpu, pool.imap_unordered)
r1, g1 = pc1(menthol)
t1 = time.time() - t1
print "Calculation time on %i CPUs: %g" % (ncpu, t1)
print "Time ratio: %g" % (t0 / t1)

# plot both results and the difference curve
from pylab import plot, show, clf, draw

clf()
gd = g0 - g1
plot(r0, g0, r1, g1, r0, gd - 3)
show()
示例#12
0
}

# number of CPUs for parallel calculation
ncpu = multiprocessing.cpu_count()

# calculate PDF on a single core
t0 = time.time()
pc0 = PDFCalculator(**cfg)
r0, g0 = pc0(menthol)
t0 = time.time() - t0
print "Calculation time on 1 CPU: %g" % t0

# create a pool of workers
pool = multiprocessing.Pool(processes=ncpu)

t1 = time.time()
# create a proxy parrallel calculator to PDFCalculator pc0,
# that uses ncpu parallel jobs submitted via pool.imap_unordered
pc1 = createParallelCalculator(pc0, ncpu, pool.imap_unordered)
r1, g1 = pc1(menthol)
t1 = time.time() - t1
print "Calculation time on %i CPUs: %g" % (ncpu, t1)
print "Time ratio: %g" % (t0 / t1)

# plot both results and the difference curve
from matplotlib.pyplot import plot, show, clf, draw
clf()
gd = g0 - g1
plot(r0, g0, r1, g1, r0, gd - 3)
show()