SpaceGroup.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
*/
/*   Spacegroup.h header for Spacegroup and AsymmetricUnit classes
*
*/
#ifndef _OBJCRYST_SPACEGROUP_H_
#define _OBJCRYST_SPACEGROUP_H_

#include "ObjCryst/CrystVector/CrystVector.h"

#include "ObjCryst/ObjCryst/General.h"
#include "ObjCryst/RefinableObj/RefinableObj.h"
#include <complex>

//#include "cctbx/sgtbx/space_group.h"
namespace cctbx{namespace sgtbx{class space_group;}}

namespace ObjCryst
{
class SpaceGroup;
//######################################################################
//  AsymmetricUnit.
//######################################################################

class AsymmetricUnit
{
   public:
      AsymmetricUnit();
      AsymmetricUnit(const SpaceGroup &spg);
      ~AsymmetricUnit();
      void SetSpaceGroup(const SpaceGroup &spg);
      bool IsInAsymmetricUnit(const REAL x, const REAL y, const REAL z)const;
      REAL Xmin() const;
      REAL Xmax() const;
      REAL Ymin() const;
      REAL Ymax() const;
      REAL Zmin() const;
      REAL Zmax() const;
   protected:
   private:
      REAL mXmin,mXmax,mYmin,mYmax,mZmin,mZmax;
};

//######################################################################
//                SpaceGroup
//######################################################################


class SpaceGroup
{
   public:
      SpaceGroup();
      SpaceGroup(const string &spgId);
      ~SpaceGroup();
      void ChangeSpaceGroup(const string &spgId);
      const string& GetName()const;
      bool IsInAsymmetricUnit(const REAL x, const REAL y, const REAL z) const;
      void ChangeToAsymmetricUnit(REAL x, REAL y, REAL z) const;//:TODO:
      const AsymmetricUnit& GetAsymUnit() const;

      int GetSpaceGroupNumber()const;

      bool IsCentrosymmetric()const;

      int GetNbTranslationVectors()const;

      struct TRx
      {
         REAL tr[3];
      };

      struct SMx
      {
         REAL mx[9];
         REAL tr[3];
      };

      const std::vector<SpaceGroup::TRx>& GetTranslationVectors()const;

      const std::vector<SpaceGroup::SMx>& GetSymmetryOperations()const;

      CrystMatrix_REAL GetAllSymmetrics(const REAL x, const REAL y, const REAL z,
                                const bool noCenter=false,const bool noTransl=false,
                                const bool noIdentical=false) const;
      void GetSymmetric(unsigned int i, REAL &x, REAL &y, REAL &z,
                        const bool noCenter=false,const bool noTransl=false,
                        const bool derivative=false) const;

      int GetNbSymmetrics(const bool noCenter=false,const bool noTransl=false)const;

      void Print()const;
      bool HasInversionCenter()const;
      bool IsInversionCenterAtOrigin()const;
      const cctbx::sgtbx::space_group& GetCCTbxSpg()const;
      const RefinableObjClock& GetClockSpaceGroup() const;
      unsigned int GetUniqueAxis()const;
      char GetExtension()const;
      CrystVector_REAL GetInversionCenter()const;
      unsigned int AreReflEquiv(const REAL h1, const REAL k1, const REAL l1,
                                const REAL h2, const REAL k2, const REAL l2)const;
      CrystMatrix_REAL GetAllEquivRefl(const REAL h, const REAL k, const REAL l,
                                       const bool excludeFriedelMate=false,
                                       const bool forceFriedelLaw=false,
                                       const REAL sf_re=0,const REAL sf_im=0) const;
      bool IsReflSystematicAbsent(const REAL h, const REAL k, const REAL l)const;
      bool IsReflCentric(const REAL h, const REAL k, const REAL l)const;
      unsigned int GetExpectedIntensityFactor(const REAL h, const REAL k, const REAL l)const;
  protected:
   private:
      void InitSpaceGroup(const string &spgId);

      string mId;

      cctbx::sgtbx::space_group *mpCCTbxSpaceGroup;

      bool mHasInversionCenter;
      bool mIsInversionCenterAtOrigin;

      AsymmetricUnit mAsymmetricUnit;

      RefinableObjClock mClock;
      unsigned int mUniqueAxisId;
      unsigned long mNbSym;
      unsigned long mNbTrans;
      unsigned long mSpgNumber;
      char mExtension;
      std::vector<SMx> mvSym;
      std::vector<TRx> mvTrans;
};

}//namespace
#endif //_OBJCRYST_SPACEGROUP_H_