Scatterer.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_SCATTERER_H_
#define _OBJCRYST_SCATTERER_H_
 
#include "ObjCryst/CrystVector/CrystVector.h"
 
#include "ObjCryst/ObjCryst/General.h"
 
#include "ObjCryst/ObjCryst/ScatteringPower.h"
 
#include <string>
 
namespace ObjCryst
{
class Crystal ; //forward declaration.:KLUDGE: ?
extern const RefParType *gpRefParTypeScatt;
extern const RefParType *gpRefParTypeScattTransl;
extern const RefParType *gpRefParTypeScattTranslX;
extern const RefParType *gpRefParTypeScattTranslY;
extern const RefParType *gpRefParTypeScattTranslZ;
extern const RefParType *gpRefParTypeScattOrient;
extern const RefParType *gpRefParTypeScattConform;
extern const RefParType *gpRefParTypeScattConformBondLength;
extern const RefParType *gpRefParTypeScattConformBondAngle;
extern const RefParType *gpRefParTypeScattConformDihedAngle;
extern const RefParType *gpRefParTypeScattConformX;
extern const RefParType *gpRefParTypeScattConformY;
extern const RefParType *gpRefParTypeScattConformZ;
extern const RefParType *gpRefParTypeScattOccup;
class NiftyStaticGlobalObjectsInitializer_Scatterer
{
   public:
      NiftyStaticGlobalObjectsInitializer_Scatterer()
      {
         if (mCount++ == 0)
         {
            gpRefParTypeScatt=new RefParType(gpRefParTypeObjCryst,"Scatterer");
            gpRefParTypeScattTransl=new RefParType(gpRefParTypeScatt,"Translation");
            gpRefParTypeScattTranslX=new RefParType(gpRefParTypeScattTransl,"Translation along X");
            gpRefParTypeScattTranslY=new RefParType(gpRefParTypeScattTransl,"Translation along Y");
            gpRefParTypeScattTranslZ=new RefParType(gpRefParTypeScattTransl,"Translation along Z");
            gpRefParTypeScattOrient=new RefParType(gpRefParTypeScatt,"Orientation");
            gpRefParTypeScattConform=new RefParType(gpRefParTypeScatt,"Conformation");
            gpRefParTypeScattConformBondLength=new RefParType(gpRefParTypeScattConform,"BondLengths");
            gpRefParTypeScattConformBondAngle=new RefParType(gpRefParTypeScattConform,"Bond Angles");
            gpRefParTypeScattConformDihedAngle=new RefParType(gpRefParTypeScattConform,"Dihedral Angles ");
            gpRefParTypeScattConformX=new RefParType(gpRefParTypeScattConform,"Orth. X coordinates");
            gpRefParTypeScattConformY=new RefParType(gpRefParTypeScattConform,"Orth. Y coordinates");
            gpRefParTypeScattConformZ=new RefParType(gpRefParTypeScattConform,"Orth. Z coordinates");
            gpRefParTypeScattOccup=new RefParType(gpRefParTypeScatt,"Occupancy");
         }
      }
      ~NiftyStaticGlobalObjectsInitializer_Scatterer()
      {
         if (--mCount == 0)
         {
            delete gpRefParTypeScatt;
            delete gpRefParTypeScattTransl;
            delete gpRefParTypeScattTranslX;
            delete gpRefParTypeScattTranslY;
            delete gpRefParTypeScattTranslZ;
            delete gpRefParTypeScattOrient;
            delete gpRefParTypeScattConform;
            delete gpRefParTypeScattConformBondLength;
            delete gpRefParTypeScattConformBondAngle;
            delete gpRefParTypeScattConformDihedAngle;
            delete gpRefParTypeScattConformX;
            delete gpRefParTypeScattConformY;
            delete gpRefParTypeScattConformZ;
            delete gpRefParTypeScattOccup;
            gpRefParTypeScatt=0;
            gpRefParTypeScattTransl=0;
            gpRefParTypeScattTranslX=0;
            gpRefParTypeScattTranslY=0;
            gpRefParTypeScattTranslZ=0;
            gpRefParTypeScattOrient=0;
            gpRefParTypeScattConform=0;
            gpRefParTypeScattConformBondLength=0;
            gpRefParTypeScattConformBondAngle=0;
            gpRefParTypeScattConformDihedAngle=0;
            gpRefParTypeScattConformX=0;
            gpRefParTypeScattConformY=0;
            gpRefParTypeScattConformZ=0;
            gpRefParTypeScattOccup=0;
         }
      }
   private:
      static long mCount;
};
static NiftyStaticGlobalObjectsInitializer_Scatterer NiftyStaticGlobalObjectsInitializer_Scatterer_counter;
 
 
//######################################################################
//
//      SCATTERER
//######################################################################
 
class Scatterer:virtual public RefinableObj
{
   public:
      Scatterer();
      Scatterer(const Scatterer &old);
      virtual ~Scatterer();
      virtual Scatterer* CreateCopy() const=0;
      virtual const string& GetClassName() const;
 
      virtual int GetNbComponent() const=0;
 
      virtual const ScatteringComponentList& GetScatteringComponentList() const=0;
      virtual string GetComponentName(const int i) const=0;
 
      REAL GetX() const;
      REAL GetY() const;
      REAL GetZ() const;
 
      REAL GetOccupancy() const ;
 
      virtual void SetX(const REAL x);
      virtual void SetY(const REAL y);
      virtual void SetZ(const REAL z);
      virtual void SetOccupancy(const REAL occupancy) ;
 
      operator string()const;
      virtual void Print() const=0;
 
      virtual const string& GetColour()const;
      virtual const float* GetColourRGB()const;
 
      virtual ostream& POVRayDescription(ostream &os,
                                         const CrystalPOVRayOptions &options)const=0;
 
#ifdef OBJCRYST_GL
      virtual void GLInitDisplayList(const bool noSymmetrics=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 REAL fadeDistance=0,
                                     const bool fullMoleculeInLimits=false)const=0;
#endif  // OBJCRYST_GL
 
      const RefinableObjClock& GetClockScatterer()const;
      RefinableObjClock& GetClockScatterer();
      void SetCrystal(Crystal&);
      const Crystal& GetCrystal()const;
      Crystal& GetCrystal();
   protected:
      virtual void InitRefParList()=0;
      virtual void InitRGBColour();
      const RefinableObjClock& GetClockScattCompList()const;
      CrystVector_REAL mXYZ;
 
      REAL mOccupancy;
      string mColourName;
      float mColourRGB[3];
      RefinableObjClock mClockScatterer;
      mutable RefinableObjClock mClockScattCompList;
      Crystal *mpCryst;
 
   private:
   #ifdef __WX__CRYST__
   public:
      virtual WXCrystObjBasic* WXCreate(wxWindow*);
      friend class WXScatterer;
   #endif
};
 
extern ObjRegistry<Scatterer> gScattererRegistry;
 
 
}//namespace
 
#include "ObjCryst/ObjCryst/Crystal.h"
 
#endif //_OBJCRYST_SCATTERER_H_