GlobalOptimObj.h

/*  ObjCryst++ Object-Oriented Crystallographic Library
    (c) 2000-2002 Vincent Favre-Nicolin vincefn@users.sourceforge.net
        2000-2001 University of Geneva (Switzerland)
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
/*   OptimizationObj.h
*  header file for the Global Optimization object
*
*/
#ifndef _GLOBALOPTIMOBJ_H
#define _GLOBALOPTIMOBJ_H
 
#include <map>
#include "ObjCryst/ObjCryst/General.h"
 
namespace ObjCryst
{
   class OptimizationObj;
   class MonteCarloObj;
}
 
#include "ObjCryst/RefinableObj/RefinableObj.h"
#include "ObjCryst/RefinableObj/LSQNumObj.h"
#include "ObjCryst/RefinableObj/IO.h"
#include "ObjCryst/RefinableObj/Tracker.h"
#include <string>
#include <iostream>
#ifdef __WX__CRYST__
   //#undef GetClassName // Conflict from wxMSW headers ? (cygwin)
#include "ObjCryst/wxCryst/wxGlobalOptimObj.h"
#endif
 
namespace ObjCryst
{
enum AnnealingSchedule
{
   ANNEALING_CONSTANT,
   ANNEALING_BOLTZMANN,
   ANNEALING_CAUCHY,
//   ANNEALING_QUENCHING,
   ANNEALING_EXPONENTIAL,
   ANNEALING_SMART,
   ANNEALING_GAMMA
};
 
enum GlobalOptimType
{
   GLOBAL_OPTIM_SIMULATED_ANNEALING,
   GLOBAL_OPTIM_PARALLEL_TEMPERING,
   GLOBAL_OPTIM_RANDOM_LSQ,
   GLOBAL_OPTIM_SIMULATED_ANNEALING_MULTI,
   GLOBAL_OPTIM_PARALLEL_TEMPERING_MULTI,
};
 
class OptimizationObj
{
   public:
      OptimizationObj();
      OptimizationObj(const string name);
      OptimizationObj(const OptimizationObj &old);
      virtual ~OptimizationObj();
 
      virtual void RandomizeStartingConfig();
      virtual void Optimize(long &nbSteps,const bool silent=false,const REAL finalcost=0,
                            const REAL maxTime=-1)=0;
      virtual void MultiRunOptimize(long &nbCycle,long &nbSteps,const bool silent=false,const REAL finalcost=0,
                                    const REAL maxTime=-1)=0;
   //Set Refinable parameters status
      void FixAllPar();
      void SetParIsFixed(const string& parName,const bool fix);
      void SetParIsFixed(const RefParType *type,const bool fix);
      void UnFixAllPar();
      void SetParIsUsed(const string& parName,const bool use);
      void SetParIsUsed(const RefParType *type,const bool use);
      void SetLimitsRelative(const string &parName, const REAL min, const REAL max);
      void SetLimitsRelative(const RefParType *type, const REAL min, const REAL max);
      void SetLimitsAbsolute(const string &parName, const REAL min, const REAL max);
      void SetLimitsAbsolute(const RefParType *type, const REAL min, const REAL max);
 
      virtual REAL GetLogLikelihood()const;
 
      void StopAfterCycle();
      virtual void DisplayReport();
 
      void AddRefinableObj(RefinableObj &);
      RefinableObj& GetFullRefinableObj(const bool rebuild=true);
      virtual void XMLOutput(ostream &os,int indent=0)const=0;
      virtual void XMLInput(istream &is,const XMLCrystTag &tag)=0;
      //virtual void XMLInputOld(istream &is,const IOCrystTag &tag);
      const string& GetName()const;
      void SetName(const string&);
      virtual const string GetClassName()const;
      virtual void Print()const;
      void RestoreBestConfiguration();
      bool IsOptimizing()const;
      void TagNewBestConfig();
      REAL GetLastOptimElapsedTime()const;
      MainTracker& GetMainTracker();
      const MainTracker& GetMainTracker()const;
      RefObjOpt& GetXMLAutoSaveOption();
      const RefObjOpt& GetXMLAutoSaveOption()const;
      const REAL& GetBestCost()const;
      REAL& GetBestCost();
      virtual void BeginOptimization(const bool allowApproximations=false,
                                     const bool enableRestraints=false);
      virtual void EndOptimization();
      virtual long& NbTrialPerRun();
      virtual const long& NbTrialPerRun() const;
      long GetTrial() const;
      long GetRun() const;
      //Options
      ObjRegistry<RefObjOpt>& GetOptionList();
      unsigned int GetNbOption()const;
      RefObjOpt& GetOption(const unsigned int i);
      RefObjOpt& GetOption(const string & name);
      const RefObjOpt& GetOption(const unsigned int i)const;
      const RefObjOpt& GetOption(const string & name)const;
      const ObjRegistry<RefinableObj>& GetRefinedObjList() const;
      virtual void UpdateDisplay() const;
      unsigned int GetNbParamSet() const;
      long GetParamSetIndex(const unsigned int i) const;
      long GetParamSetCost(const unsigned int i) const;
      void RestoreParamSet(const unsigned int i, const bool update_display=true);
   protected:
      void PrepareRefParList();
 
      virtual void InitOptions();
      void BuildRecursiveRefObjList();
      void AddOption(RefObjOpt *opt);
      mutable RefinableObj mRefParList;
      string mName;
      string mSaveFileName;
 
      //Status of optimization
         long mNbTrialPerRun;
         long mNbTrial;
         long mRun;
         REAL mBestCost;
         long mBestParSavedSetIndex;
         unsigned long mContext;
         struct LogLikelihoodStats
         {
            REAL mLastLogLikelihood;
            REAL mTotalLogLikelihood;
            REAL mTotalLogLikelihoodDeltaSq;
         };
         mutable map <unsigned long, map<const RefinableObj*,LogLikelihoodStats> > mvContextObjStats;
      // Dynamic weights (EXPERIMENTAL!)
         struct DynamicObjWeight
         {
            DynamicObjWeight():mWeight(1.){};
            REAL mWeight;
         };
         mutable map<const RefinableObj*,DynamicObjWeight> mvObjWeight;
 
         std::vector<pair<long,REAL> > mvSavedParamSet;
 
      bool mIsOptimizing;
      bool mStopAfterCycle;
 
      // Refined objects
         mutable ObjRegistry<RefinableObj> mRefinedObjList;
         mutable ObjRegistry<RefinableObj> mRecursiveRefinedObjList;
 
         RefObjOpt mXMLAutoSave;
 
         REAL mLastOptimTime;
      MainTracker mMainTracker;
      ObjRegistry<RefObjOpt> mOptionRegistry;
   private:
   #ifdef __WX__CRYST__
   public:
      virtual WXCrystObjBasic* WXCreate(wxWindow*)=0;
      virtual WXOptimizationObj* WXGet()=0;
      virtual void WXDelete()=0;
      virtual void WXNotifyDelete()=0;
   protected:
      //:TODO: remove this !
      friend class ObjCryst::WXOptimizationObj;
      //friend class ObjCryst::WXMonteCarloObj;
      //friend class ObjCryst::WXGeneticAlgorithm;
      wxMutex mMutexStopAfterCycle;
   #endif
};
 
class MonteCarloObj:public OptimizationObj
{
   public:
      MonteCarloObj();
      MonteCarloObj(const string name);
      MonteCarloObj(const MonteCarloObj &old);
      MonteCarloObj(const bool internalUseOnly);
      virtual ~MonteCarloObj();
 
      void SetAlgorithmSimulAnnealing(const AnnealingSchedule scheduleTemp,
                                 const REAL tMax, const REAL tMin,
                                 const AnnealingSchedule scheduleMutation=ANNEALING_CONSTANT,
                                 const REAL mutMax=16., const REAL mutMin=.125,
                                 const long nbTrialRetry=0,const REAL minCostRetry=0.);
      void SetAlgorithmParallTempering(const AnnealingSchedule scheduleTemp,
                                 const REAL tMax, const REAL tMin,
                                 const AnnealingSchedule scheduleMutation=ANNEALING_CONSTANT,
                                 const REAL mutMax=16., const REAL mutMin=.125);
 
      virtual void Optimize(long &nbSteps,const bool silent=false,const REAL finalcost=0,
                            const REAL maxTime=-1);
      virtual void MultiRunOptimize(long &nbCycle,long &nbSteps,const bool silent=false,const REAL finalcost=0,
                                    const REAL maxTime=-1);
 
      void RunSimulatedAnnealing(long &nbSteps,const bool silent=false,const REAL finalcost=0,
                                 const REAL maxTime=-1);
      void RunParallelTempering(long &nbSteps,const bool silent=false,const REAL finalcost=0,
                                const REAL maxTime=-1);
 
      void RunRandomLSQMethod(long &nbCycle);
 
      //Parameter Access by name
      //RefinablePar& GetPar(const string& parName);
 
      // Print information about the current state of optimization (parameters value,
      // characteristic figures...)
      //virtual ostream& operator<<(ostream& os)const;
      virtual void XMLOutput(ostream &os,int indent=0)const;
      virtual void XMLInput(istream &is,const XMLCrystTag &tag);
      //virtual void XMLInputOld(istream &is,const IOCrystTag &tag);
      virtual const string GetClassName()const;
      LSQNumObj & GetLSQObj();
      const LSQNumObj & GetLSQObj() const;
 
      virtual void InitLSQ(const bool useFullPowderPatternProfile=true);
      virtual void UpdateDisplay() const;
   protected:
 
      virtual void NewConfiguration(const RefParType *type=gpRefParTypeObjCryst);
 
      virtual void InitOptions();
 
      RefObjOpt mGlobalOptimType;
 
      //Status of optimization
         REAL mCurrentCost;
 
      // History, for experimental purposes only !
         RefObjOpt mSaveTrackedData;
 
      // Annealing parameters
         REAL mTemperature;
         REAL mTemperatureMax;
         REAL mTemperatureMin;
         RefObjOpt mAnnealingScheduleTemp;
         REAL mTemperatureGamma;
      //Parameters to create new configurations
         REAL mMutationAmplitude;
         REAL mMutationAmplitudeMax;
         REAL mMutationAmplitudeMin;
         RefObjOpt mAnnealingScheduleMutation;
         REAL mMutationAmplitudeGamma;
      //Automatic retry
         long mNbTrialRetry;
         REAL mMinCostRetry;
      LSQNumObj mLSQ;
      RefObjOpt mAutoLSQ;
   private:
   #ifdef __WX__CRYST__
   public:
      virtual WXCrystObjBasic* WXCreate(wxWindow*);
      virtual WXOptimizationObj* WXGet();
      virtual void WXDelete();
      virtual void WXNotifyDelete();
   protected:
      WXMonteCarloObj* mpWXCrystObj;
      friend class ObjCryst::WXMonteCarloObj;
   #endif
};
 
extern ObjRegistry<OptimizationObj> gOptimizationObjRegistry;
 
}// namespace
 
#endif //_GLOBALOPTIMOBJ_H