Validate if optimized evaluation is supported.

PairQuantity.setEvaluatorType(OPTIMIZED) now throws exception
if optimized evaluation is not supported.  Do not delay until
the first calculation call.

Author: pavoljuhas

src/diffpy/srreal/PQEvaluator.cpp

@@ -86,6 +86,12 @@ PQEvaluatorType PQEvaluatorBasic::typeintused() const
 }
 
 
+void PQEvaluatorBasic::validate(PairQuantity& pq) const
+{
+    return;
+}
+
+
 void PQEvaluatorBasic::updateValue(
         PairQuantity& pq, StructureAdapterPtr stru)
 {
@@ -162,6 +168,14 @@ PQEvaluatorType PQEvaluatorOptimized::typeint() const
 }
 
 
+void PQEvaluatorOptimized::validate(PairQuantity& pq) const
+{
+    // Check if PairQuantity provides stashPartialValue.
+    pq.stashPartialValue();
+    pq.restorePartialValue();
+}
+
+
 void PQEvaluatorOptimized::updateValue(
         PairQuantity& pq, StructureAdapterPtr stru)
 {

src/diffpy/srreal/PQEvaluator.hpp

@@ -65,6 +65,7 @@ class PQEvaluatorBasic
         virtual PQEvaluatorType typeint() const;
         PQEvaluatorType typeintused() const;
         virtual void updateValue(PairQuantity&, StructureAdapterPtr);
+        virtual void validate(PairQuantity&) const;
         void setFlag(PQEvaluatorFlag flag, bool value);
         bool getFlag(PQEvaluatorFlag flag) const;
         void setupParallelRun(int cpuindex, int ncpu);
@@ -103,6 +104,7 @@ class PQEvaluatorOptimized : public PQEvaluatorBasic
 
         // methods
         virtual PQEvaluatorType typeint() const;
+        virtual void validate(PairQuantity&) const;
         virtual void updateValue(PairQuantity&, StructureAdapterPtr);
 
     private:

src/diffpy/srreal/PairQuantity.cpp

@@ -143,7 +143,20 @@ const double& PairQuantity::getRmax() const
 void PairQuantity::setEvaluatorType(PQEvaluatorType evtp)
 {
     if (mevaluator.get() && mevaluator->typeint() == evtp)  return;
-    mevaluator = createPQEvaluator(evtp, mevaluator);
+    PQEvaluatorPtr pqev = createPQEvaluator(evtp, mevaluator);
+    // validate the new evaluator object
+    try
+    {
+        pqev->validate(*this);
+    }
+    catch (logic_error e)
+    {
+        string emsg("EvaluatorType not supported.  ");
+        emsg += e.what();
+        throw invalid_argument(emsg);
+    }
+    // validator is good here, use it now.
+    mevaluator = pqev;
     this->resetValue();
 }
 

src/tests/TestPQEvaluator.hpp

@@ -25,6 +25,7 @@
 #include <diffpy/srreal/PQEvaluator.hpp>
 #include <diffpy/srreal/AtomicStructureAdapter.hpp>
 #include <diffpy/srreal/PDFCalculator.hpp>
+#include <diffpy/srreal/OverlapCalculator.hpp>
 
 namespace diffpy {
 namespace srreal {
@@ -70,6 +71,7 @@ class TestPQEvaluator : public CxxTest::TestSuite
             mstru9->erase(9);
         }
 
+
         void test_PDF_change_atom()
         {
             PDFCalculator pdfcb;
@@ -148,6 +150,16 @@ class TestPQEvaluator : public CxxTest::TestSuite
             TS_ASSERT(allclose(gb, go));
         }
 
+
+        void test_optimized_unsupported()
+        {
+            OverlapCalculator olc;
+            TS_ASSERT_EQUALS(BASIC, olc.getEvaluatorType());
+            TS_ASSERT_THROWS(
+                    olc.setEvaluatorType(OPTIMIZED), invalid_argument);
+            TS_ASSERT_EQUALS(BASIC, olc.getEvaluatorType());
+        }
+
 };  // class TestPQEvaluator
 
 }   // namespace srreal