Use "BASIC" evaluatortype for parallel calculations.

Problem: Parallel calculation currently does not properly support the
OPTIMIZED evaluator.
Solution: Allow only BASIC evaluatortype for parallel calculations.

This resolves #8.

Author: pavoljuhas

src/diffpy/srreal/parallel.py

@@ -35,6 +35,9 @@ def createParallelCalculator(pqobj, ncpu, pmap):
     ncpu     -- number of parallel jobs
     pmap     -- a parallel map function used to submit job to workers
 
+    The ``pqobj.evaluatortype`` is reset to 'BASIC' because other
+    evaluator types are not supported within parallel calculations.
+
     Return a proxy calculator instance that has the same interface,
     but executes the calculation in parallel split among ncpu jobs.
     '''
@@ -63,6 +66,8 @@ def __init__(self, pqobj, ncpu, pmap):
             object.__setattr__(self, 'pqobj', pqobj)
             object.__setattr__(self, 'ncpu', ncpu)
             object.__setattr__(self, 'pmap', pmap)
+            # parallel calculations support only the BASIC evaluation
+            self.pqobj.evaluatortype = 'BASIC'
             return
 
 
@@ -116,6 +121,23 @@ def parallel_eval(stru):
                 restore_eval()
             return rv
 
+
+        @property
+        def evaluatortype(self):
+            """str : Type of evaluation procedure.
+
+            Parallel calculations allow only the 'BASIC' type.
+            """
+            return self.pqobj.evaluatortype
+
+        @evaluatortype.setter
+        def evaluatortype(self, value):
+            if value != "BASIC":
+                emsg = "Parallel calculations require 'BASIC' evaluatortype."
+                raise ValueError(emsg)
+            self.pqobj.evaluatortype = value
+            return
+
     # class ParallelPairQuantity
 
     # Create proxy method and properties to the wrapped PairQuantity
@@ -167,8 +189,6 @@ def _parallelData(kwd):
     '''Helper for calculating and fetching raw results from a worker node.
     '''
     pqobj = kwd['pqobj']
-    if pqobj.evaluatortype == 'OPTIMIZED':
-        pqobj = copy.copy(pqobj)
     pqobj._setupParallelRun(kwd['cpuindex'], kwd['ncpu'])
     pqobj.eval()
     return pqobj._getParallelData()

src/diffpy/srreal/tests/testparallel.py

@@ -40,6 +40,22 @@ def pool(self):
             self._pool = multiprocessing.Pool(processes=self.ncpu)
         return self._pool
 
+
+    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_pdf(self):
         """check parallel PDFCalculator
         """
@@ -68,6 +84,7 @@ def test_parallel_pdf(self):
         self.assertTrue(numpy.allclose(g0a, g2a))
         return
 
+
     def test_parallel_bonds(self):
         """check parallel BondCalculator
         """