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 <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();
   private:
      vector<T*> mvpRegistry;
      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
         unsigned int GetNbOption()const;
         RefObjOpt& GetOption(const unsigned int i);
         const RefObjOpt& GetOption(const unsigned int i)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;
   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_