RefinableObj.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
*/
/*
*  header file for the RefinablePar and RefinableObj classes
*
*
*/
 
#ifndef _VFN_REFINABLE_OBJ_H_
#define _VFN_REFINABLE_OBJ_H_
 
#include <string>
#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
 
#include "ObjCryst/CrystVector/CrystVector.h"
#include "ObjCryst/ObjCryst/General.h"
#include "ObjCryst/RefinableObj/IO.h"
 
#ifdef __WX__CRYST__
   class wxWindow;
namespace ObjCryst
{
   template<class T> class ObjRegistry;
   class RefObjOpt;
   template<class T> class RefObjOption;
   class RefinableObj;
}
#include "ObjCryst/wxCryst/wxRefinableObj.h"
#endif
 
namespace ObjCryst
{
enum  RefParDerivStepModel
{
   REFPAR_DERIV_STEP_ABSOLUTE,
   REFPAR_DERIV_STEP_RELATIVE
};
 
class RefParType
{
   public:
      RefParType(const string &name);
      RefParType(const RefParType *parent,const string &name);
      ~RefParType();
      bool IsDescendantFromOrSameAs(const RefParType *type) const;
      bool operator==(const RefParType *parent) const;
      const string& GetName() const;
   private:
      void InitId();
       const RefParType* mpParent;
      const string mName;
      unsigned long mId;
};
 
extern const RefParType *gpRefParTypeObjCryst;
class NiftyStaticGlobalObjectsInitializer_RefinableObj
{
   public:
      NiftyStaticGlobalObjectsInitializer_RefinableObj()
      {
         if (mCount++ == 0)
         {
            gpRefParTypeObjCryst=new RefParType("ObjCryst++");
         }
      }
      ~NiftyStaticGlobalObjectsInitializer_RefinableObj()
      {
         if (--mCount == 0)
         {
            delete gpRefParTypeObjCryst;
            gpRefParTypeObjCryst=0;
         }
      }
   private:
      static long mCount;
};
static NiftyStaticGlobalObjectsInitializer_RefinableObj NiftyStaticGlobalObjectsInitializer_RefinableObj_counter;
 
class RefinableObjClock
{
   public:
      RefinableObjClock();
      ~RefinableObjClock();
      bool operator< (const RefinableObjClock &rhs)const;
      bool operator<=(const RefinableObjClock &rhs)const;
      bool operator> (const RefinableObjClock &rhs)const;
      bool operator>=(const RefinableObjClock &rhs)const;
      void Click();
      void Reset();
      void Print()const;
      void PrintStatic()const;
      void AddChild(const RefinableObjClock &);
      void RemoveChild(const RefinableObjClock &);
      void AddParent(RefinableObjClock &)const;
      void RemoveParent(RefinableObjClock &)const;
      void operator=(const RefinableObjClock &rhs);
   private:
      bool HasParent(const RefinableObjClock &) const;
      unsigned long mTick0, mTick1;
      static unsigned long msTick0,msTick1;
      std::set<const RefinableObjClock*> mvChild;
      mutable std::set<RefinableObjClock*> mvParent;
};
 
class Restraint
{
   public:
      Restraint();
      Restraint(const RefParType *type);
      virtual ~Restraint();
      virtual const RefParType* GetType()const;
      virtual void SetType(const RefParType *type);
      virtual REAL GetLogLikelihood()const;
   private:
      const RefParType *mpRefParType;
};
 
class RefinablePar:public Restraint
{
   public:
 
 
      RefinablePar();
      RefinablePar(  const string &name,
                     REAL *refPar,
                     const REAL min,
                     const REAL max,
                     const RefParType *type,
                     RefParDerivStepModel derivMode=REFPAR_DERIV_STEP_RELATIVE,
                     const bool hasLimits=true,
                     const bool isFixed=false,
                     const bool isUsed=true,
                     const bool isPeriodic=false,
                     const REAL humanScale=1.,
                     REAL period=1.);
      RefinablePar(const RefinablePar &ref);
      ~RefinablePar();
      void Init(     const string &name,
                     REAL *refPar,
                     const REAL min,
                     const REAL max,
                     const RefParType *type,
                     RefParDerivStepModel derivMode=REFPAR_DERIV_STEP_RELATIVE,
                     const bool hasLimits=true,
                     const bool isFixed=false,
                     const bool isUsed=true,
                     const bool isPeriodic=false,
                     const REAL humanScale=1.,
                     REAL period=1.);
 
      void CopyAttributes(const RefinablePar&);
 
 
 
         REAL GetValue()const;
 
         const REAL* GetPointer()const;
 
         void SetValue(const REAL value);
 
         const REAL& GetHumanValue() const;
 
         void SetHumanValue(const REAL&) ;
 
         void Mutate(const REAL mutateValue);
         void MutateTo(const REAL newValue);
 
         REAL GetSigma()const;
         REAL GetHumanSigma()const;
         void SetSigma(const REAL);
 
 
         string GetName()const;
         void SetName(const string&);
 
         void Print() const;
 
         bool IsFixed()const;
         void SetIsFixed(const bool);
 
         bool IsLimited()const;
         void SetIsLimited(const bool);
 
         bool IsUsed()const;
         void SetIsUsed(const bool);
 
         bool IsPeriodic()const;
         void SetIsPeriodic(const bool,REAL period=1);
 
         REAL GetHumanScale()const;
         void SetHumanScale(const REAL);
 
 
 
         REAL GetMin()const;
         void  SetMin(const REAL);
 
         REAL GetHumanMin()const;
         void  SetHumanMin(const REAL);
 
         REAL GetMax()const;
         void  SetMax(const REAL);
 
         REAL GetHumanMax()const;
         void  SetHumanMax(const REAL);
 
         REAL GetPeriod()const;
         void  SetPeriod(const REAL);
 
 
         REAL GetDerivStep()const;
         void  SetDerivStep(const REAL);
 
         REAL GetGlobalOptimStep()const;
         void  SetGlobalOptimStep(const REAL);
 
 
      #if 0
 
         void SetUseEquation(const bool useItOrNot,const REAL c0=0.);
         void SetUseEquation(const bool useItOrNot,const REAL c0,
                             const REAL c1, const RefinablePar &refpar1);
 
         void SetUseEquation(const bool useItOrNot,const REAL c0,
                             const REAL c1, const RefinablePar &refpar1,
                             const REAL c2, const RefinablePar &refpar2);
         void SetUseEquation(const bool useItOrNot,const REAL c0,
                             const REAL c1, const RefinablePar &refpar1,
                             const REAL c2, const RefinablePar &refpar2,
                             const REAL c3, const RefinablePar &refpar3);
      #endif
 
      void AssignClock(RefinableObjClock &clock);
 
 
         void SetLimitsAbsolute(const REAL min, const REAL max);
         void SetLimitsRelative(const REAL min, const REAL max);
         void SetLimitsProportional(const REAL min, const REAL max);
 
      void XMLOutput(ostream &os,const string &name,int indent=0)const;
      void XMLOutput(ostream &os,int indent=0)const;
      void XMLInput(istream &is,const XMLCrystTag &tag);
   private:
      void Click();
      string mName;
      REAL *mpValue;
      REAL mMin,mMax;
      bool mHasLimits;
      bool mIsFixed;
      bool mIsUsed;
      bool mIsPeriodic;
      REAL mPeriod;
      REAL mGlobalOptimStep;
      REAL mDerivStep;
      RefParDerivStepModel mRefParDerivStepModel;
      REAL mSigma;
      REAL mHumanScale;
      #if 0
      // Parameter defined by equations ? :TODO:
         bool mUseEquation;
         static const int mEquationMaxRefPar=10;
         int mEquationNbRefPar;
         CrystVector_REAL mEquationCoeff;
         const RefinablePar *mEquationRefPar[10];
      #endif
         bool mHasAssignedClock;
         RefinableObjClock* mpClock;
 
   #ifdef __WX__CRYST__
   public:
      WXCrystObjBasic* WXCreate(wxWindow *parent);
      WXCrystObjBasic* WXGet();
      void             WXDelete();
      void             WXNotifyDelete();
   private:
      WXFieldRefPar * mpWXFieldRefPar;
   #endif
   friend class RefinableObj;
};
class RefObjOpt
{
   public:
      RefObjOpt();
      virtual ~RefObjOpt();
      void Init(const int nbChoice,const string *name,
                const string *choiceNames);
      int GetNbChoice()const;
      int GetChoice()const;
      virtual void SetChoice(const int choice);
      void SetChoice(const string &choiceName);
      const string& GetName()const;
      const string& GetClassName()const;
      const string& GetChoiceName(const int i)const;
      const RefinableObjClock& GetClock()const;
      void XMLOutput(ostream &os,int indent=0)const;
      void XMLInput(istream &is,const XMLCrystTag &tag);
   protected:
      int mNbChoice;
      int mChoice;
      const string* mpName;
      const string* mpChoiceName;
      RefinableObjClock mClock;
   #ifdef __WX__CRYST__
   public:
      WXCrystObjBasic* WXCreate(wxWindow *parent);
      WXCrystObjBasic* WXGet();
      void             WXDelete();
      void             WXNotifyDelete();
   private:
      WXFieldOption * mpWXFieldOption;
   #endif
};
 
 
template<class T> class RefObjOption:public RefObjOpt
{
   public:
      RefObjOption(T* obj);
      ~RefObjOption();
      void Init(const int nbChoice,const string *name,
                const string *choiceNames,
                void (T::*fp)(const int));
      virtual void SetChoice(const int choice);
   protected:
   private:
      T* mpObj;
      void (T::*mfpSetNewValue)(const int);
};
 
template<class T> class ObjRegistry
{
   public:
      ObjRegistry();
      ObjRegistry(const string &name);
      ~ObjRegistry();
      void Register(T &obj);
      void DeRegister(T &obj);
      void DeRegister(const string &objName);
      void DeRegisterAll();
      void DeleteAll();
      T& GetObj(const unsigned int i);
      const T& GetObj(const unsigned int i)const;
      T& GetObj(const string &objName);
      const T& GetObj(const string &objName)const;
      T& GetObj(const string &objName, const string& className);
      const T& GetObj(const string &objName, const string& className)const;
      long GetNb()const;
      void Print()const;
      void SetName(const string &);
      const string& GetName()const;
      long Find(const string &objName)const;
      long Find(const string &objName, const string& className,
                const bool nothrow=false)const;
      long Find(const T &obj)const;
      long Find(const T *pobj)const;
      const RefinableObjClock& GetRegistryClock()const;
      void AutoUpdateUI(const bool autoup=true);
      void UpdateUI();
      std::size_t size() const;
      typename vector<T*>::const_iterator begin() const;
      typename vector<T*>::const_iterator end() const;
      typename std::list<T*>::const_iterator list_begin() const;
      typename std::list<T*>::const_iterator list_end() const;
   private:
      vector<T*> mvpRegistry;
      std::list<T*> mvpRegistryList;
      string mName;
      RefinableObjClock mListClock;
      bool mAutoUpdateUI;
   #ifdef __WX__CRYST__
   public:
      WXRegistry<T>* WXCreate(wxWindow *parent);
      void             WXDelete();
      void             WXNotifyDelete();
   private:
      WXRegistry<T> * mpWXRegistry;
   #endif
};
 
class RefinableObj
{
   public:
      RefinableObj();
      RefinableObj(const bool internalUseOnly);
      RefinableObj(const RefinableObj &old);
      virtual ~RefinableObj();
      virtual const string& GetClassName() const;
      virtual const string& GetName() const;
      virtual void SetName(const string &name);
      void operator=(const RefinableObj &old);
 
      void PrepareForRefinement() const;
      void FixAllPar();
      void UnFixAllPar();
      void SetParIsFixed(const long parIndex,const bool fix);
      void SetParIsFixed(const string& parName,const bool fix);
      void SetParIsFixed(const RefParType *type,const bool fix);
      void SetParIsUsed(const string& parName,const bool use);
      void SetParIsUsed(const RefParType *type,const bool use);
      long GetNbPar()const;
      long GetNbParNotFixed()const;
 
      RefinablePar& GetPar(const long i);
      const RefinablePar& GetPar(const long i) const;
 
      RefinablePar& GetPar(const string & name);
      const RefinablePar& GetPar(const string & name) const;
 
      RefinablePar& GetPar(const REAL*);
      const RefinablePar& GetPar(const REAL*) const;
 
      RefinablePar& GetParNotFixed(const long i);
      const RefinablePar& GetParNotFixed(const long i)const;
      void AddPar(const RefinablePar &newRefPar);
      void AddPar(RefinablePar *newRefPar);
      void AddPar(RefinableObj &newRefParList, const bool copyParam=false);
      vector<RefinablePar *>::iterator RemovePar(RefinablePar *refPar);
 
      virtual void Print() const;
 
      unsigned long CreateParamSet(const string name="") const;
      void ClearParamSet(const unsigned long id)const;
      void SaveParamSet(const unsigned long id)const;
      void RestoreParamSet(const unsigned long id);
      const CrystVector_REAL& GetParamSet(const unsigned long setId)const;
      CrystVector_REAL& GetParamSet(const unsigned long setId);
      REAL GetParamSet_ParNotFixedHumanValue(const unsigned long setId,const long parNumber)const;
      const void EraseAllParamSet();
      const string& GetParamSetName(const unsigned long setId)const;
 
      void SetLimitsAbsolute(const string &parName, const REAL min, const REAL max);
      void SetLimitsAbsolute(const RefParType *type, const REAL min, const REAL max);
      void SetLimitsRelative(const string &parName, const REAL min, const REAL max);
      void SetLimitsRelative(const RefParType *type, const REAL min, const REAL max);
      void SetLimitsProportional(const string &parName, const REAL min, const REAL max);
      void SetLimitsProportional(const RefParType *type, const REAL min, const REAL max);
      void  SetGlobalOptimStep(const RefParType *type, const REAL step);
 
      ObjRegistry<RefinableObj>& GetSubObjRegistry();
      const ObjRegistry<RefinableObj>& GetSubObjRegistry()const;
 
      virtual void RegisterClient(RefinableObj &)const;
      virtual void DeRegisterClient(RefinableObj &)const;
      virtual const ObjRegistry<RefinableObj>& GetClientRegistry()const;
      virtual ObjRegistry<RefinableObj>& GetClientRegistry();
 
      bool IsBeingRefined()const;
 
      virtual void BeginOptimization(const bool allowApproximations=false,
                                     const bool enableRestraints=false);
      virtual void EndOptimization();
 
      virtual void SetApproximationFlag(const bool allow);
 
      virtual void RandomizeConfiguration();
 
      virtual void GlobalOptRandomMove(const REAL mutationAmplitude,
                                       const RefParType *type=gpRefParTypeObjCryst);
      void BeginGlobalOptRandomMove();
 
      // Likelihood
         virtual REAL GetLogLikelihood()const;
         /* Get log(likelihood) and all its first derivative versus a list of parameters.
         *
         *  \return: a map, with a RefinablePar pointer as key, and as value the corresponding
         * derivative. Note that the value of the map for the NULL key is the current value
         * for the log(likelihood), which is also returned. The map will include derivatives
         * only for parameters which have been supplied in vPar - but if a parameter
         * is listed in vPar and has a null derivative, it may be missing in the returned map.
         *
         * \warning: currently in development, to provide faster, analytic derivatives
         *
         * \note:ideally, this function should be const - but since numerical derivatives
         * may be used before all analytical formulas are entered, a non-const version is
         * required.
         * \todo
         */
         //virtual std::map<RefinablePar*, REAL>& GetLogLikelihood_FullDeriv(std::set<RefinablePar *> &vPar);
      //LSQ functions
         virtual unsigned int GetNbLSQFunction()const;
         // Get a Cost function name from its id#.
         //virtual const string& GetLSQFunctionName(const unsigned int)const;
         // Get the (short) description of a cost function
         //virtual const string& GetLSQFunctionDescription(const unsigned int)const;
         virtual const CrystVector_REAL& GetLSQCalc(const unsigned int) const;
         virtual const CrystVector_REAL& GetLSQObs(const unsigned int) const;
         virtual const CrystVector_REAL& GetLSQWeight(const unsigned int) const;
         virtual const CrystVector_REAL& GetLSQDeriv(const unsigned int, RefinablePar&);
         virtual std::map<RefinablePar*, CrystVector_REAL> & GetLSQ_FullDeriv(const unsigned int,std::set<RefinablePar *> &vPar);
 
      void ResetParList();
 
      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 void UpdateDisplay()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;
      // Genetic
         virtual void GetGeneGroup(const RefinableObj &obj,
                                   CrystVector_uint & groupIndex,
                                   unsigned int &firstGroup) const;
      void SetDeleteRefParInDestructor(const bool b);
      const RefinableObjClock& GetRefParListClock()const;
      // Restraints
         virtual REAL GetRestraintCost()const;
         void AddRestraint(Restraint *pNewRestraint);
         vector<Restraint*>::iterator RemoveRestraint(Restraint *pRestraint);
      virtual void TagNewBestConfig()const;
      const RefinableObjClock& GetClockMaster()const;
      size_t int_ptr() const;
   protected:
      long FindPar(const string &name) const;
      long FindPar(const REAL*) const;
 
      void AddSubRefObj(RefinableObj &);
      void RemoveSubRefObj(RefinableObj &);
 
      void AddOption(RefObjOpt *opt);
      virtual void Prepare();
 
      map<unsigned long,pair<CrystVector_REAL,string> >::iterator FindParamSet(unsigned long id)const;
 
      string mName;
      // Parameters
         vector<RefinablePar *> mvpRefPar;
      // Restraints
         vector<Restraint*> mvpRestraint;
 
      //Saved sets of parameters
         mutable map<unsigned long,pair<CrystVector_REAL,string> >  mvpSavedValuesSet;
 
      // Used during refinements, initialized by PrepareForRefinement()
         mutable long mNbRefParNotFixed;
         mutable CrystVector_long mRefparNotFixedIndex;
         int mOptimizationDepth;
 
         ObjRegistry<RefinableObj> mSubObjRegistry;
         mutable ObjRegistry<RefinableObj> mClientObjRegistry;
 
      // Options for this object
         ObjRegistry<RefObjOpt> mOptionRegistry;
      bool mDeleteRefParInDestructor;
      RefinableObjClock mRefParListClock;
      bool mRandomMoveIsDone;
      mutable CrystVector_REAL mLSQDeriv;
      mutable std::map< unsigned int,std::map<RefinablePar*, CrystVector_REAL> > mLSQ_FullDeriv;
      // Temporary map to return the derivative of log(likelihood) versus a list of parameters
      //
      // \todo In development
      //mutable std::map<RefinablePar*, REAL> mLogLikelihood_FullDeriv;
 
 
      RefinableObjClock mClockMaster;
   #ifdef __WX__CRYST__
   public:
      virtual WXCrystObjBasic* WXCreate(wxWindow*);
      WXCrystObjBasic* WXGet();
      void WXDelete();
      void WXNotifyDelete();
   protected:
      WXCrystObjBasic *mpWXCrystObj;
   #endif
};
void GetRefParListClockRecursive(ObjRegistry<RefinableObj> &reg,RefinableObjClock &clock);
template<class T> void RefObjRegisterRecursive(T &obj,ObjRegistry<T> &reg);
void GetSubRefObjListClockRecursive(ObjRegistry<RefinableObj> &reg,RefinableObjClock &clock);
 
extern ObjRegistry<RefinableObj> gRefinableObjRegistry;
extern ObjRegistry<RefinableObj> gTopRefinableObjRegistry;
}//namespace
 
#endif// _VFN_REFINABLE_OBJ_H_