ZScatterer.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
*/
#ifndef _OBJCRYST_ZSCATTERER_H_
#define _OBJCRYST_ZSCATTERER_H_

#include "ObjCryst/CrystVector/CrystVector.h"

#include "ObjCryst/ObjCryst/General.h"

#include "ObjCryst/ObjCryst/ScatteringPower.h"
#include "ObjCryst/ObjCryst/Scatterer.h"
#include "ObjCryst/RefinableObj/GlobalOptimObj.h"

#include <string>

namespace ObjCryst
{
class ZScatterer;
//######################################################################
//
//      GLOBAL SCATTERING POWER
//######################################################################

class GlobalScatteringPower:virtual public ScatteringPower
{
   public:
      GlobalScatteringPower();
      GlobalScatteringPower(const ZScatterer &scatt);
      GlobalScatteringPower(const GlobalScatteringPower& old);
      ~GlobalScatteringPower();
      void Init(const ZScatterer &scatt);
      virtual CrystVector_REAL GetScatteringFactor(const ScatteringData &data,
                                                     const int spgSymPosIndex=0) const;
      virtual REAL GetForwardScatteringFactor(const RadiationType) const;
      virtual CrystVector_REAL GetTemperatureFactor(const ScatteringData &data,
                                                          const int spgSymPosIndex=0) const;
      virtual CrystMatrix_REAL GetResonantScattFactReal(const ScatteringData &data,
                                                          const int spgSymPosIndex=0) const;
      virtual CrystMatrix_REAL GetResonantScattFactImag(const ScatteringData &data,
                                                          const int spgSymPosIndex=0) const;
      virtual REAL GetRadius()const;
   protected:
      virtual void InitRefParList();
      ZScatterer *mpZScatterer;
   private:
      // Avoid compiler warnings.  Explicitly hide the base-class method.
      void Init();
};

//######################################################################
//######################################################################

class ZAtom
{
   public:
      ZAtom(ZScatterer &scatt,const ScatteringPower *pow,
            const long atomBond=0, const REAL bondLength=1,
            const long atomAngle=0, const REAL bondAngle=M_PI,
            const long atomDihedral=0, const REAL dihedralAngle=M_PI,
            const REAL popu=1., const string &name="");
      ~ZAtom();
      const string& GetClassName()const;
      const string& GetName()const;
      void SetName(const string&);
      const ZScatterer& GetZScatterer()const;
      ZScatterer& GetZScatterer();

      long GetZBondAtom()const;
      long GetZAngleAtom()const;
      long GetZDihedralAngleAtom()const;

      const REAL& GetZBondLength()const;
      const REAL& GetZAngle()const;
      const REAL& GetZDihedralAngle()const;
      const REAL& GetOccupancy()const;
      const ScatteringPower* GetScatteringPower()const;

      void SetZBondLength(const REAL);
      void SetZAngle(const REAL);
      void SetZDihedralAngle(const REAL);
      void SetOccupancy(const REAL);
      void SetScatteringPower(const ScatteringPower*);
      void XMLOutput(ostream &os,int indent=0)const;
      void XMLInput(istream &is,const XMLCrystTag &tag);
   private:
      const ScatteringPower *mpScattPow;
      long mAtomBond,mAtomAngle,mAtomDihed;
      REAL mBondLength,mAngle,mDihed,mOccupancy;
      string mName;
      ZScatterer *mpScatt;

      friend class ZScatterer; //So that RefinablePar can be declared in ZScatterer

   #ifdef __WX__CRYST__
   public:
      WXCrystObjBasic* WXCreate(wxWindow *parent);
      WXCrystObjBasic* WXGet();
      void WXDelete();
      void WXNotifyDelete();
   private:
      WXCrystObjBasic *mpWXCrystObj;
      friend class WXZAtom;
   #endif
};
//######################################################################
//######################################################################
class ZMoveMinimizer:public RefinableObj
{
   public:
      ZMoveMinimizer(ZScatterer &scatt);
      ~ZMoveMinimizer();
      virtual REAL GetLogLikelihood()const;
      void RecordConformation();
      void SetZAtomWeight(const CrystVector_REAL weight);
      void MinimizeChange(long nbTrial=10000);
   private:
      ZScatterer *mpZScatt;
      MonteCarloObj mOptimObj;
      CrystVector_REAL mXCoord0,mYCoord0,mZCoord0;
      CrystVector_REAL mAtomWeight;
};

//######################################################################
//######################################################################

class ZScatterer: public Scatterer
{
   public:
      ZScatterer(const string &name,Crystal &cryst,
                 const REAL x=0.,const REAL y=0.,const REAL z=0.,
                 const REAL phi=0.,const REAL chi=0., const REAL psi=0.);
      ZScatterer(const ZScatterer &old);
     ~ZScatterer();
      virtual ZScatterer* CreateCopy() const;
      virtual const string& GetClassName() const;
      void AddAtom(const string &name,const ScatteringPower *pow,
                   const long atomBond, const REAL bondLength,
                   const long atomAngle, const REAL bondAngle,
                   const long atomDihedral, const REAL dihedralAngle,
                   const REAL popu=1.);

      virtual int GetNbComponent() const;
      virtual const ScatteringComponentList& GetScatteringComponentList() const;
      virtual string GetComponentName(const int i) const;

      void Print() const;

      REAL GetPhi()const;
      REAL GetChi()const;
      REAL GetPsi()const;
      void SetPhi(const REAL);
      void SetChi(const REAL);
      void SetPsi(const REAL);

      REAL GetZAtomX(const int i)const;
      REAL GetZAtomY(const int i)const;
      REAL GetZAtomZ(const int i)const;
      long GetZBondAtom(const int i)const;
      long GetZAngleAtom(const int i)const;
      long GetZDihedralAngleAtom(const int i)const;

      REAL GetZBondLength(const int i)const;
      REAL GetZAngle(const int i)const;
      REAL GetZDihedralAngle(const int i)const;

      void SetZBondLength(const int i,const REAL);
      void SetZAngle(const int i,const REAL);
      void SetZDihedralAngle(const int i,const REAL);

      const ObjRegistry<ZAtom>& GetZAtomRegistry()const;
      virtual ostream& POVRayDescription(ostream &os,
                                         const CrystalPOVRayOptions &options)const;

      virtual void GLInitDisplayList(const bool onlyIndependentAtoms=false,
                                     const REAL xMin=-.1,const REAL xMax=1.1,
                                     const REAL yMin=-.1,const REAL yMax=1.1,
                                     const REAL zMin=-.1,const REAL zMax=1.1,
                                     const bool displayEnantiomer=false,
                                     const bool displayNames=false,
                                     const bool hideHydrogens=false)const;
      virtual void SetUseGlobalScatteringPower(const bool useIt);
      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 GetGeneGroup(const RefinableObj &obj,
                                CrystVector_uint & groupIndex,
                                unsigned int &firstGroup) const;
      virtual void GlobalOptRandomMove(const REAL mutationAmplitude,
                                       const RefParType *type=gpRefParTypeObjCryst);
      const CrystVector_REAL& GetXCoord() const;
      const CrystVector_REAL& GetYCoord() const;
      const CrystVector_REAL& GetZCoord() const;
      virtual void EndOptimization();
      void ImportFenskeHallZMatrix(istream &is,bool named=false);
      void ExportFenskeHallZMatrix(ostream &os);
      void SetCenterAtomIndex(const unsigned int);
      unsigned int GetCenterAtomIndex()const;
   protected:
      void UpdateCoordinates() const;
      void UpdateScattCompList() const;
      CrystMatrix_long m3DDisplayIndex;
      mutable ScatteringComponentList mScattCompList;
      long mNbAtom;
   private:
      virtual void InitRefParList();

      long mNbDummyAtom;

      CrystVector_int mComponentIndex;

      REAL mPhi,mChi,mPsi;

      ObjRegistry<ZAtom> mZAtomRegistry;
      long mCenterAtomIndex;

      mutable CrystMatrix_REAL mPhiChiPsiMatrix;

      bool mUseGlobalScattPow;

      GlobalScatteringPower* mpGlobalScattPow;

      mutable CrystVector_REAL mXCoord,mYCoord,mZCoord;
      mutable RefinableObjClock mClockCoord;
      ZMoveMinimizer *mpZMoveMinimizer;
   #ifdef __WX__CRYST__
   public:
      virtual WXCrystObjBasic* WXCreate(wxWindow*);
   friend class WXZScatterer;
   #endif
};

//######################################################################
//
//    Different types of regular polyhedra
//
//######################################################################

enum RegularPolyhedraType { TETRAHEDRON, OCTAHEDRON, SQUARE_PLANE, CUBE, ANTIPRISM_TETRAGONAL,
                            PRISM_TETRAGONAL_MONOCAP, PRISM_TETRAGONAL_DICAP,
                            PRISM_TRIGONAL,PRISM_TRIGONAL_TRICAPPED,
                            ICOSAHEDRON, TRIANGLE_PLANE};

//######################################################################
//######################################################################
class ZPolyhedron: public ZScatterer
{
   public:
      ZPolyhedron( const RegularPolyhedraType type, Crystal &cryst,
            const REAL x, const REAL y, const REAL z,
            const string &name, const ScatteringPower *centralAtomPow,
            const ScatteringPower *periphAtomPow,const REAL centralPeriphDist,
            const REAL ligandPopu=1,
            const REAL phi=0., const REAL chi=0., const REAL psi=0.);
      ZPolyhedron(const ZPolyhedron&);
      virtual ZPolyhedron* CreateCopy() const;

      /* \brief Copy constructor
      *
      ZPolyhedron(const ZPolyhedron &old);
      */
   protected:
   private:
      //Prepare refinable parameters for the scatterer object
      //virtual void InitRefParList();

      RegularPolyhedraType mPolyhedraType;
};

}//namespace
#include "ObjCryst/ObjCryst/Crystal.h"

#endif //_OBJCRYST_ZSCATTERER_H_