Add default and copy constructors to OptimizationObj and MonteCarloObj. Small const-correctness fixes

Author: vincefn

ObjCryst/RefinableObj/GlobalOptimObj.cpp

@@ -65,6 +65,31 @@ void CompareWorlds(const CrystVector_long &idx,const CrystVector_long &swap, con
 //#################################################################################
 ObjRegistry<OptimizationObj> gOptimizationObjRegistry("List of all Optimization objects");
 
+OptimizationObj::OptimizationObj():
+mName(""),mSaveFileName("GlobalOptim.save"),
+mNbTrialPerRun(10000000),mNbTrial(0),mRun(0),mBestCost(-1),
+mBestParSavedSetIndex(-1),
+mContext(0),
+mIsOptimizing(false),mStopAfterCycle(false),
+mRefinedObjList("OptimizationObj: "+mName+" RefinableObj registry"),
+mRecursiveRefinedObjList("OptimizationObj: "+mName+" recursive RefinableObj registry"),
+mLastOptimTime(0)
+{
+   VFN_DEBUG_ENTRY("OptimizationObj::OptimizationObj()",5)
+   // This must be done in a real class to avoid calling a pure virtual method
+   // if a graphical representation is automatically called upon registration.
+   //  gOptimizationObjRegistry.Register(*this);
+
+   static bool need_initRandomSeed=true;
+   if(need_initRandomSeed==true)
+   {
+      srand(time(NULL));
+      need_initRandomSeed=false;
+   }
+   // We only copy parameters, so do not delete them !
+   mRefParList.SetDeleteRefParInDestructor(false);
+   VFN_DEBUG_EXIT("OptimizationObj::OptimizationObj()",5)
+}
 
 OptimizationObj::OptimizationObj(const string name):
 mName(name),mSaveFileName("GlobalOptim.save"),
@@ -92,6 +117,36 @@ mLastOptimTime(0)
    VFN_DEBUG_EXIT("OptimizationObj::OptimizationObj()",5)
 }
 
+OptimizationObj::OptimizationObj(const OptimizationObj &old):
+mName(old.mName),mSaveFileName(old.mSaveFileName),
+mNbTrialPerRun(old.mNbTrialPerRun),mNbTrial(old.mNbTrial),mRun(old.mRun),mBestCost(old.mBestCost),
+mBestParSavedSetIndex(-1),
+mContext(0),
+mIsOptimizing(false),mStopAfterCycle(false),
+mRefinedObjList("OptimizationObj: "+mName+" RefinableObj registry"),
+mRecursiveRefinedObjList("OptimizationObj: "+mName+" recursive RefinableObj registry"),
+mLastOptimTime(0)
+{
+   VFN_DEBUG_ENTRY("OptimizationObj::OptimizationObj(&old)",5)
+   // This must be done in a real class to avoid calling a pure virtual method
+   // if a graphical representation is automatically called upon registration.
+   //  gOptimizationObjRegistry.Register(*this);
+
+   static bool need_initRandomSeed=true;
+   if(need_initRandomSeed==true)
+   {
+      srand(time(NULL));
+      need_initRandomSeed=false;
+   }
+   // We only copy parameters, so do not delete them !
+   mRefParList.SetDeleteRefParInDestructor(false);
+
+   for(unsigned int i=0;i<old.mRefinedObjList.GetNb();i++)
+      this->AddRefinableObj(old.mRefinedObjList.GetObj(i));
+
+   VFN_DEBUG_EXIT("OptimizationObj::OptimizationObj(&old)",5)
+}
+
 OptimizationObj::~OptimizationObj()
 {
    VFN_DEBUG_ENTRY("OptimizationObj::~OptimizationObj()",5)
@@ -366,7 +421,7 @@ long OptimizationObj::GetParamSetIndex(const unsigned int i) const
 {
    if(i>=mvSavedParamSet.size())
       throw ObjCrystException("OptimizationObj::GetSavedParamSetIndex(i): i > nb saved param set");
-   
+
    return mvSavedParamSet[i].first;
 }
 
@@ -463,16 +518,14 @@ void OptimizationObj::InitOptions()
    VFN_DEBUG_MESSAGE("OptimizationObj::InitOptions():End",5)
 }
 
-void OptimizationObj::UpdateDisplay()
+void OptimizationObj::UpdateDisplay() const
 {
    Chronometer chrono;
-   #ifdef __WX__CRYST__
-   if(0!=this->WXGet()) this->WXGet()->CrystUpdate(true,true);
-   #endif
    for(int i=0;i<mRefinedObjList.GetNb();i++)
       mRefinedObjList.GetObj(i).UpdateDisplay();
    mMainTracker.UpdateDisplay();
 }
+
 void OptimizationObj::BuildRecursiveRefObjList()
 {
    // First check if anything has changed (ie if a sub-object has been
@@ -501,6 +554,27 @@ void OptimizationObj::AddOption(RefObjOpt *opt)
 //       MonteCarloObj
 //
 //#################################################################################
+MonteCarloObj::MonteCarloObj():
+OptimizationObj(""),
+mCurrentCost(-1),
+mTemperatureMax(1e6),mTemperatureMin(.001),mTemperatureGamma(1.0),
+mMutationAmplitudeMax(8.),mMutationAmplitudeMin(.125),mMutationAmplitudeGamma(1.0),
+mNbTrialRetry(0),mMinCostRetry(0)
+#ifdef __WX__CRYST__
+,mpWXCrystObj(0)
+#endif
+{
+   VFN_DEBUG_ENTRY("MonteCarloObj::MonteCarloObj()",5)
+   this->InitOptions();
+   mGlobalOptimType.SetChoice(GLOBAL_OPTIM_PARALLEL_TEMPERING);
+   mAnnealingScheduleTemp.SetChoice(ANNEALING_SMART);
+   mAnnealingScheduleMutation.SetChoice(ANNEALING_EXPONENTIAL);
+   mXMLAutoSave.SetChoice(5);//Save after each Run
+   mAutoLSQ.SetChoice(0);
+   gOptimizationObjRegistry.Register(*this);
+   VFN_DEBUG_EXIT("MonteCarloObj::MonteCarloObj()",5)
+}
+
 MonteCarloObj::MonteCarloObj(const string name):
 OptimizationObj(name),
 mCurrentCost(-1),
@@ -522,6 +596,27 @@ mNbTrialRetry(0),mMinCostRetry(0)
    VFN_DEBUG_EXIT("MonteCarloObj::MonteCarloObj()",5)
 }
 
+MonteCarloObj::MonteCarloObj(const MonteCarloObj &old):
+OptimizationObj(old),
+mCurrentCost(old.mCurrentCost),
+mTemperatureMax(old.mTemperatureMax),mTemperatureMin(old.mTemperatureMin),
+mTemperatureGamma(old.mTemperatureGamma),
+mMutationAmplitudeMax(old.mMutationAmplitudeMax),mMutationAmplitudeMin(old.mMutationAmplitudeMin),
+mMutationAmplitudeGamma(old.mMutationAmplitudeGamma),
+mNbTrialRetry(old.mNbTrialRetry),mMinCostRetry(old.mMinCostRetry)
+#ifdef __WX__CRYST__
+,mpWXCrystObj(0)
+#endif
+{
+   VFN_DEBUG_ENTRY("MonteCarloObj::MonteCarloObj(&old)",5)
+   this->InitOptions();
+   for(unsigned int i=0;i<this->GetNbOption();i++)
+      this->GetOption(i).SetChoice(old.GetOption(i).GetChoice());
+
+   gOptimizationObjRegistry.Register(*this);
+   VFN_DEBUG_EXIT("MonteCarloObj::MonteCarloObj(&old)",5)
+}
+
 MonteCarloObj::MonteCarloObj(const bool internalUseOnly):
 OptimizationObj(""),
 mCurrentCost(-1),
@@ -2221,6 +2316,15 @@ void MonteCarloObj::InitLSQ(const bool useFullPowderPatternProfile)
    mLSQ.SetParIsFixed(gpRefParTypeRadiation,true);
 }
 
+void MonteCarloObj::UpdateDisplay() const
+{
+   Chronometer chrono;
+   #ifdef __WX__CRYST__
+   if(0!=mpWXCrystObj) mpWXCrystObj->CrystUpdate(true,true);
+   #endif
+   this->OptimizationObj::UpdateDisplay();
+}
+
 #ifdef __WX__CRYST__
 WXCrystObjBasic* MonteCarloObj::WXCreate(wxWindow *parent)
 {

ObjCryst/RefinableObj/GlobalOptimObj.h

@@ -102,8 +102,12 @@ enum GlobalOptimType
 class OptimizationObj
 {
    public:
+      /// Default constructor
+      OptimizationObj();
       /// Constructor
-      OptimizationObj(const string name="");
+      OptimizationObj(const string name);
+      /// Copy constructor
+      OptimizationObj(const OptimizationObj &old);
       /// Destructor
       virtual ~OptimizationObj();
 
@@ -243,7 +247,7 @@ class OptimizationObj
       const ObjRegistry<RefinableObj>& GetRefinedObjList() const;
       /// Update Display (if any display is available), when a new 'relevant' configuration
       /// is reached. This calls all RefinableObj::UpdateDisplay()
-      virtual void UpdateDisplay();
+      virtual void UpdateDisplay() const;
       /// Get the number of saved parameters set
       unsigned int GetNbParamSet() const;
       /// Get the index of a saved parameters set in the compiled RefinableObj.
@@ -328,8 +332,10 @@ class OptimizationObj
       bool mStopAfterCycle;
 
       // Refined objects
-         /// The refined objects
-         ObjRegistry<RefinableObj> mRefinedObjList;
+         /// The refined objects. This is mutable to allow a copy constructor for
+         /// the OptimizationObj, and because the objects are not owned
+         /// but rather referenced here.
+         mutable ObjRegistry<RefinableObj> mRefinedObjList;
          /// The refined objects, recursively including all sub-objects.
          /// This is mutable, since it is a function of mRefinedObjList only.
          mutable ObjRegistry<RefinableObj> mRecursiveRefinedObjList;
@@ -374,8 +380,12 @@ class OptimizationObj
 class MonteCarloObj:public OptimizationObj
 {
    public:
+      /// Default Constructor
+      MonteCarloObj();
       /// Constructor
-      MonteCarloObj(const string name="");
+      MonteCarloObj(const string name);
+      /// Copy constructor
+      MonteCarloObj(const MonteCarloObj &old);
       /// Constructor. Using internalUseOnly=true will avoid registering the
       /// the object to any registry, and thus (for example) no display will be created,
       /// nor will this object be automatically be saved.
@@ -478,6 +488,9 @@ class MonteCarloObj:public OptimizationObj
       * will be used (faster).
       */
       virtual void InitLSQ(const bool useFullPowderPatternProfile=true);
+      /// Update Display (if any display is available), when a new 'relevant' configuration
+      /// is reached. This calls all RefinableObj::UpdateDisplay()
+      virtual void UpdateDisplay() const;
    protected:
 
       /** \brief Make a random change in the configuration.