ScatteringPower.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_SCATTPOWER_H_
#define _OBJCRYST_SCATTPOWER_H_
 
#include "ObjCryst/CrystVector/CrystVector.h"
#include "ObjCryst/ObjCryst/General.h"
#include "ObjCryst/RefinableObj/RefinableObj.h"
 
 
//#include <stdlib.h>
//#include <string>
//#include <iomanip>
//#include <cmath>
//#include <typeinfo>
//#include <fstream>
//#include <ctime>
 
// forward declaration to avoid including boost headers
namespace cctbx { namespace eltbx { namespace xray_scattering {class gaussian;}}}
 
namespace ObjCryst
{
extern const RefParType *gpRefParTypeScattPow;
extern const RefParType *gpRefParTypeScattPowResonant;
extern const RefParType *gpRefParTypeScattPowTemperature;
extern const RefParType *gpRefParTypeScattPowTemperatureIso;
extern const RefParType *gpRefParTypeScattPowTemperatureAniso;
class NiftyStaticGlobalObjectsInitializer_ScatteringPower
{
   public:
      NiftyStaticGlobalObjectsInitializer_ScatteringPower()
      {
         if (mCount++ == 0)
         {
            gpRefParTypeScattPow=new RefParType(gpRefParTypeObjCryst,"Scattering Power");
            gpRefParTypeScattPowResonant=new RefParType(gpRefParTypeScattPow,"Resonant Scatt.");
            gpRefParTypeScattPowTemperature=new RefParType(gpRefParTypeScattPow,"Temperature");
            gpRefParTypeScattPowTemperatureIso=new RefParType(gpRefParTypeScattPowTemperature,"Isotropic");
            gpRefParTypeScattPowTemperatureAniso=new RefParType(gpRefParTypeScattPowTemperatureIso,"Anisotropic");
         }
      }
      ~NiftyStaticGlobalObjectsInitializer_ScatteringPower()
      {
         if (--mCount == 0)
         {
            delete gpRefParTypeScattPow;
            delete gpRefParTypeScattPowResonant;
            delete gpRefParTypeScattPowTemperature;
            delete gpRefParTypeScattPowTemperatureIso;
            delete gpRefParTypeScattPowTemperatureAniso;
            gpRefParTypeScattPow=0;
            gpRefParTypeScattPowResonant=0;
            gpRefParTypeScattPowTemperature=0;
            gpRefParTypeScattPowTemperatureIso=0;
            gpRefParTypeScattPowTemperatureAniso=0;
         }
      }
   private:
      static long mCount;
};
static NiftyStaticGlobalObjectsInitializer_ScatteringPower NiftyStaticGlobalObjectsInitializer_ScatteringPower_counter;
 
   class ScatteringData;//forward declaration :KLUDGE: ?
//######################################################################
//
//      SCATTERING POWER
//######################################################################
class ScatteringPower:virtual public RefinableObj
{
   public:
      ScatteringPower();
      ScatteringPower(const ScatteringPower& old);
      virtual ~ScatteringPower();
      virtual const string& GetClassName() const;
      virtual void operator=(const ScatteringPower& rhs);
      virtual bool operator==(const ScatteringPower& rhs) const;
      virtual bool operator!=(const ScatteringPower& rhs) const;
      virtual CrystVector_REAL GetScatteringFactor(const ScatteringData &data,
                                                     const int spgSymPosIndex=-1) const=0;
      virtual REAL GetForwardScatteringFactor(const RadiationType) const=0;
      virtual CrystVector_REAL GetTemperatureFactor(const ScatteringData &data,
                                                      const int spgSymPosIndex=-1) const=0;
      virtual CrystMatrix_REAL GetResonantScattFactReal(const ScatteringData &data,
                                                          const int spgSymPosIndex=-1) const=0;
      virtual CrystMatrix_REAL GetResonantScattFactImag(const ScatteringData &data,
                                                          const int spgSymPosIndex=-1) const=0;
      virtual bool IsScatteringFactorAnisotropic()const;
      virtual bool IsTemperatureFactorAnisotropic()const;
      virtual bool IsResonantScatteringAnisotropic()const;
      virtual const string& GetSymbol() const;
      REAL GetBiso() const;
      REAL& GetBiso();
      virtual void SetBiso(const REAL newB);
      REAL GetBij(const size_t &i, const size_t &j) const;
      REAL GetBij(const size_t &idx) const;
      virtual void SetBij(const size_t &i, const size_t &j, const REAL newB);
      virtual void SetBij(const size_t &idx, const REAL newB);
      bool IsIsotropic()const ;
      long GetDynPopCorrIndex()const;
      long GetNbScatteringPower()const;
      const RefinableObjClock& GetLastChangeClock()const;
      const string& GetColourName()const;
      const float* GetColourRGB()const;
      void SetColour(const string& colorName);
      void SetColour(const float r,const float g,const float b);
      virtual REAL GetRadius()const=0;
      virtual void GetGeneGroup(const RefinableObj &obj,
                                CrystVector_uint & groupIndex,
                                unsigned int &firstGroup) const;
      REAL GetMaximumLikelihoodPositionError()const;
      void SetMaximumLikelihoodPositionError(const REAL mle);
      REAL GetMaximumLikelihoodNbGhostAtom()const;
      void SetMaximumLikelihoodNbGhostAtom(const REAL nb);
      const RefinableObjClock& GetMaximumLikelihoodParClock()const;
      virtual REAL GetFormalCharge()const;
      virtual void SetFormalCharge(const REAL charge);
   protected:
      virtual void InitRefParList()=0;
      virtual void Init();
      virtual void InitRGBColour();
      long mDynPopCorrIndex;
      REAL mBiso;
      bool mIsIsotropic;
      mutable CrystVector_REAL mBeta;
      CrystVector_REAL mB;
      RefinableObjClock mClock;
      string mColourName;
      float mColourRGB[3];
      // Maximum Likelihood
         REAL mMaximumLikelihoodPositionError;
         RefinableObjClock mMaximumLikelihoodParClock;
         REAL mMaximumLikelihoodNbGhost;
      REAL mFormalCharge;
};
 
extern ObjRegistry<ScatteringPower> gScatteringPowerRegistry;
 
//######################################################################
//
//      SCATTERING POWER ATOM
//######################################################################
 
class ScatteringPowerAtom:virtual public ScatteringPower
{
   public:
      ScatteringPowerAtom();
      ScatteringPowerAtom(const string &name,const string &symbol,const REAL bIso=1.0);
      ScatteringPowerAtom(const ScatteringPowerAtom& old);
      ~ScatteringPowerAtom();
      virtual const string& GetClassName() const;
      void Init(const string &name,const string &symbol,const REAL bIso=1.0);
      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;
      void SetSymbol(const string &symbol) ;
      virtual const string& GetSymbol() const;
      string GetElementName() const;
      int GetAtomicNumber() const;
      REAL GetAtomicWeight() const;
      REAL GetRadius() const;
      REAL GetCovalentRadius() const;
      unsigned int GetMaxCovBonds() const;
      virtual void Print()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);
   protected:
      void InitAtScattCoeffsWK95();
      void InitAtNeutronScattCoeffs();
      virtual void InitRefParList();
      string mSymbol;
      int mAtomicNumber;
      REAL mAtomicWeight;
 
      cctbx::eltbx::xray_scattering::gaussian *mpGaussian;
 
      REAL mNeutronScattLengthReal,mNeutronScattLengthImag;
 
      REAL mRadius;
      REAL mCovalentRadius;
      unsigned int mMaxCovBonds;
 
      REAL mNeutronAbsCrossSection;
   private:
      // Avoid compiler warnings.  Explicitly hide the base-class method.
      void Init();
   #ifdef __WX__CRYST__
   public:
      virtual WXCrystObjBasic* WXCreate(wxWindow*);
   friend class WXScatteringPowerAtom;
   #endif
};
extern ObjRegistry<ScatteringPowerAtom> gScatteringPowerAtomRegistry;
 
//######################################################################
//
//      SCATTERING COMPONENT
//######################################################################
struct ScatteringComponent
{
   // Default Constructor
   ScatteringComponent();
   bool operator==(const ScatteringComponent& rhs)const;
   bool operator!=(const ScatteringComponent& rhs)const;
   void Print() const;
   REAL mX,mY,mZ,mOccupancy;
   const ScatteringPower *mpScattPow;
 
   mutable REAL mDynPopCorr;
   // The scatterer to which this component is associated
   // Scatterer *mScatterer;
};
 
//######################################################################
//
//      SCATTERING COMPONENT LIST
//######################################################################
class ScatteringComponentList
{
   public:
      ScatteringComponentList();
      ScatteringComponentList(const long nbComponent);
      ScatteringComponentList(const ScatteringComponentList &old);
      ~ScatteringComponentList();
      void Reset();
      const ScatteringComponent& operator()(const long i) const;
      ScatteringComponent& operator()(const long i);
      long GetNbComponent() const;
      void operator=(const ScatteringComponentList &rhs);
      bool operator==(const ScatteringComponentList &rhs)const;
      void operator+=(const ScatteringComponentList &rhs);
      void operator+=(const ScatteringComponent &rhs);
      void operator++();
      void operator--();
      void Print() const;
   protected:
      vector<ScatteringComponent>  mvScattComp;
};
 
}//namespace
#include "ObjCryst/ObjCryst/ScatteringData.h"
 
#endif //_OBJCRYST_SCATTPOWER_H_