All population based methods are parallelized and ready for testing.

Author: shoops

copasi/OpenMP/CMethodContext.h

@@ -6,9 +6,58 @@
 #ifndef COPASI_CMethodContext
 #define COPASI_CMethodContext
 
-#include "copasi/OpenMP/CPointerMathContext.h"
-#include "copasi/utilities/CCopasiMethod.h"
+#include "copasi/OpenMP/CProblemContext.h"
 
-typedef CPointerMathContext< CMathContainer > CMethodContext;
+template < class Method >
+class CMethodContext : public CPointerMathContext< Method >
+{
+public:
+  typedef CPointerMathContext< Method > Base;
+
+  CMethodContext() = delete;
+
+  CMethodContext(const CMethodContext & src) = delete;
+
+  CMethodContext(const bool & parallel, CDataContainer * pParent);
+
+  ~CMethodContext();
+
+  /**
+   * Set the pointer to problem used for calculations
+   * @param CProblemContext * pContext
+   */
+  template < class Problem >
+  bool setProblemContext(CProblemContext< Problem > & Context);
+};
+
+template < class Method >
+CMethodContext< Method >::CMethodContext(const bool & parallel, CDataContainer * pParent)
+  : Base(parallel, pParent)
+{}
+
+template < class Method >
+CMethodContext< Method >::~CMethodContext()
+{}
+
+template < class Method >
+template < class Problem >
+bool CMethodContext< Method >::setProblemContext(CProblemContext< Problem > & Context)
+{
+  bool success = false;
+
+  if (Base::master() != NULL)
+    {
+      success = true;
+
+      success &= Base::master()->setProblem(Context.master());
+
+      if (Base::size() > 1)
+#pragma omp parallel for reduce(&: success)
+        for (size_t i = 0; i < Base::size(); ++i)
+          success &= Base::threadData()[i]->setProblem(Context.threadData()[i]);
+    }
+
+  return success;
+}
 
 #endif // COPASI_CMethodContext

copasi/OpenMP/CProblemContext.h

@@ -9,6 +9,28 @@
 #include "copasi/OpenMP/CPointerMathContext.h"
 #include "copasi/utilities/CCopasiProblem.h"
 
-typedef CPointerMathContext< CCopasiProblem > CProblemContext;
+template < class Problem > 
+class CProblemContext : public CPointerMathContext< Problem >
+{
+public:
+  typedef CPointerMathContext< Problem > Base;
+
+  CProblemContext() = delete;
+
+  CProblemContext(const CProblemContext & src) = delete;
+
+  CProblemContext(const bool & parallel, CDataContainer * pParent);
+
+  ~CProblemContext();
+};
+
+template < class Problem >
+CProblemContext< Problem >::CProblemContext(const bool & parallel, CDataContainer * pParent)
+  : Base(parallel, pParent)
+{}
+
+template < class Problem >
+CProblemContext< Problem >::~CProblemContext()
+{}
 
 #endif // COPASI_CProblemContext

copasi/lyap/CLyapMethod.cpp

@@ -95,8 +95,12 @@ CLyapMethod::~CLyapMethod()
  *  This method is used by CLyap
  *  @param "CLyapProblem *" problem
  */
-void CLyapMethod::setProblem(CLyapProblem * problem)
-{mpProblem = problem;}
+bool CLyapMethod::setProblem(CCopasiProblem * pProblem)
+{
+  mpProblem = dynamic_cast< CLyapProblem * >(pProblem);
+
+  return mpProblem != nullptr;
+}
 
 /**
  *  This instructs the method to calculate a a time step of deltaT

copasi/lyap/CLyapMethod.h

@@ -120,7 +120,7 @@ class CLyapMethod : public CCopasiMethod
    *  This method is used by CLyap
    *  @param "CLyapProblem *" problem
    */
-  void setProblem(CLyapProblem * problem);
+  virtual bool setProblem(CCopasiProblem * pProblem) override;
 
   /**
    *  This instructs the method to calculate a time step of deltaT

copasi/moieties/CMoietiesMethod.cpp

@@ -57,7 +57,9 @@ bool CMoietiesMethod::process()
   return true;
 }
 
-void CMoietiesMethod::setProblem(CMoietiesProblem * pProblem)
+bool CMoietiesMethod::setProblem(CCopasiProblem * pProblem)
 {
-  mpProblem = pProblem;
+  mpProblem = dynamic_cast< CMoietiesProblem * >(pProblem);
+
+  return mpProblem != nullptr;
 }

copasi/moieties/CMoietiesMethod.h

@@ -67,7 +67,7 @@ class CMoietiesMethod : public CCopasiMethod
    * Set the problem
    * @param CMoietiesProblem * pProblem
    */
-  void setProblem(CMoietiesProblem * pProblem);
+  virtual bool setProblem(CCopasiProblem * pProblem) override;
 
   // Attributes
 protected:

copasi/optimization/COptMethod.cpp

@@ -59,10 +59,11 @@ COptMethod::COptMethod(const CDataContainer * pParent,
 }
 
 COptMethod::COptMethod(const COptMethod & src,
-                       const CDataContainer * pParent)
+                       const CDataContainer * pParent,
+                       const bool & parallel)
   : CCopasiMethod(src, pParent)
   , mpParentTask(src.mpParentTask)
-  , mParallel(src.mParallel)
+  , mParallel(parallel)
   , mMathContext(src.mParallel)
   , mProblemContext(src.mParallel, this)
   , mLogVerbosity(src.mLogVerbosity)
@@ -104,10 +105,12 @@ void COptMethod::reflect(COptProblem * pProblem, const C_FLOAT64 & bestValue, C_
 }
  */
 
-void COptMethod::setProblem(COptProblem * pProblem)
+bool COptMethod::setProblem(CCopasiProblem * pProblem)
 {
-  mProblemContext.setMaster(pProblem);
+  mProblemContext.setMaster(dynamic_cast< COptProblem * >(pProblem));
   mProblemContext.setMathContext(mMathContext);
+
+  return mProblemContext.master() != nullptr;
 }
 
 //virtual C_INT32 COptMethod::Optimise(C_FLOAT64 (*func) (void))

copasi/optimization/COptMethod.h

@@ -42,7 +42,7 @@
 
 #include <string>
 
-#include "copasi/OpenMP/CPointerMathContext.h"
+#include "copasi/OpenMP/CProblemContext.h"
 #include "copasi/utilities/CCopasiMethod.h"
 #include "copasi/optimization/COptLog.h"
 
@@ -51,7 +51,6 @@ class COptItem;
 class COptTask;
 template < class CType > class CVector;
 
-typedef CPointerMathContext< COptProblem > COptProblemContext;
 
 // YOHE: this is an abstract class that contains many virtual functions
 // without definitions
@@ -92,7 +91,7 @@ class COptMethod : public CCopasiMethod
   /**
    * A thread specific problem
    */
-  COptProblemContext mProblemContext;
+  CProblemContext< COptProblem > mProblemContext;
 
   /**
    * Define the current verbosity for the log
@@ -130,7 +129,8 @@ class COptMethod : public CCopasiMethod
    * @param const CDataContainer * pParent (default: NULL)
    */
   COptMethod(const COptMethod & src,
-             const CDataContainer * pParent);
+             const CDataContainer * pParent,
+             const bool & parallel);
 
   /**
    * Destructor
@@ -149,7 +149,7 @@ class COptMethod : public CCopasiMethod
    * Set the problem to be optimized
    * @param "COptProblem *" problem
    */
-  void setProblem(COptProblem * problem);
+  virtual bool setProblem(CCopasiProblem * pProblem) override;
 
   /**
    * Initialize arrays and pointer.

copasi/optimization/COptMethodCoranaWalk.cpp

@@ -60,7 +60,7 @@ COptMethodCoranaWalk::COptMethodCoranaWalk(const CDataContainer * pParent,
 
 COptMethodCoranaWalk::COptMethodCoranaWalk(const COptMethodCoranaWalk & src,
     const CDataContainer * pParent)
-  : COptMethod(src, pParent)
+  : COptMethod(src, pParent, false)
   , mTemperature(src.mTemperature)
   , mhIterations(C_INVALID_INDEX)
   , mIterations(src.mIterations)
@@ -102,7 +102,7 @@ bool COptMethodCoranaWalk::optimise()
   C_FLOAT64 xc, p, c, New, minstep;
   bool processing;
 
-  const std::vector< COptItem * > & OptItemList = mProblemContext.master()->getOptItemList(true);
+  const std::vector< COptItem * > & OptItemList = mProblemContext.active()->getOptItemList(true);
 
   // set the minimum step size as being the average of step sizes
   // or 100*DBL_EPSILON if average is zero
@@ -190,7 +190,7 @@ bool COptMethodCoranaWalk::optimise()
                 signalStop();
 
               // Check all functional constraints
-              if (!mProblemContext.master()->checkFunctionalConstraints())
+              if (!mProblemContext.active()->checkFunctionalConstraints())
                 {
                   // Undo since not accepted
                   OptItem.setItemValue(mCurrent[h], COptItem::CheckPolicyFlag::None);
@@ -253,10 +253,10 @@ bool COptMethodCoranaWalk::optimise()
 
       if (processing)
         {
-          mCurrent = mProblemContext.master()->getSolutionVariables(true);
+          mCurrent = mProblemContext.active()->getSolutionVariables(true);
 
           for (a = 0; a < mVariableSize; a++)
-            mProblemContext.master()->getOptItemList(true)[a]->setItemValue(mCurrent[a], COptItem::CheckPolicyFlag::None);
+            mProblemContext.active()->getOptItemList(true)[a]->setItemValue(mCurrent[a], COptItem::CheckPolicyFlag::None);
 
           mCurrentValue = getBestValue();
         }
@@ -304,7 +304,7 @@ bool COptMethodCoranaWalk::initialize()
       mProcessReport.addItem("Iterations",
                              mCurrentIteration, &mIterations);
 
-  mVariableSize = mProblemContext.master()->getOptItemList(true).size();
+  mVariableSize = mProblemContext.active()->getOptItemList(true).size();
 
   mCurrent.resize(mVariableSize);
   mStep.resize(mVariableSize);

copasi/optimization/COptMethodDE.cpp

@@ -52,8 +52,9 @@ COptMethodDE::COptMethodDE(const CDataContainer * pParent,
 }
 
 COptMethodDE::COptMethodDE(const COptMethodDE & src,
-                           const CDataContainer * pParent)
-  : COptPopulationMethod(src, pParent)
+                           const CDataContainer * pParent,
+                           const bool & parallel)
+  : COptPopulationMethod(src, pParent, parallel)
   , mpPermutation(NULL)
   , mMutationVariance(0.1)
   , mStopAfterStalledGenerations(0)
@@ -70,12 +71,13 @@ bool COptMethodDE::replicate()
   size_t i, j;
   size_t a, b, c;
 
-  const std::vector< COptItem * > & OptItemList = mProblemContext.master()->getOptItemList(true);
   mpPermutation->shuffle();
 
 #pragma omp parallel for schedule(runtime)
   for (i = mPopulationSize; i < 2 * mPopulationSize; i++)
     {
+      const std::vector< COptItem * > & OptItemList = mProblemContext.active()->getOptItemList(true);
+
       // MUTATION a, b, c in [0, mPopulationSize - 1]
       a = mpPermutation->pick();
       // b is guaranteed to be different from a
@@ -100,17 +102,20 @@ bool COptMethodDE::replicate()
 #pragma omp parallel for schedule(runtime)
   for (i = 2 * mPopulationSize; i < 3 * mPopulationSize; i++)
     {
+      const std::vector< COptItem * > & OptItemList = mProblemContext.active()->getOptItemList(true);
+      CRandom * pRandom = mRandomContext.active();
+      
       for (j = 0; j < mVariableSize; j++)
         {
           COptItem & OptItem = *OptItemList[j];
           C_FLOAT64 & mut = (*mIndividuals[i])[j];
 
-          size_t r = mRandomContext.master()->getRandomU(mPopulationSize - 1);
+          size_t r = pRandom->getRandomU(mPopulationSize - 1);
 
           if (r < 0.6 * mPopulationSize)
             {
               mut = (*mIndividuals[i - mPopulationSize])[j] *
-                    mRandomContext.master()->getRandomNormal(1, mMutationVariance);
+                    pRandom->getRandomNormal(1, mMutationVariance);
             }
           else
             mut = (*mIndividuals[i - 2 * mPopulationSize])[j];