Basis.h

#ifndef PRDC_BASIS_H
#define PRDC_BASIS_H
/*
* PSCF - Polymer Self-Consistent Field Theory
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <pscf/math/IntVec.h>             // inline waveId
#include <pscf/mesh/Mesh.h>               // inline waveId
#include <util/containers/DArray.h>       // member
#include <util/containers/GArray.h>       // member
 
namespace Pscf { 
namespace Prdc { 
 
   template <int D> class UnitCell;
   template <int D> class SpaceGroup;
 
   using namespace Util;
 
   template <int D>
   class Basis 
   {
 
   public:
 
      class Wave 
      {
 
      public:
 
         std::complex<double> coeff;
 
         IntVec<D> indicesDft;
 
         IntVec<D> indicesBz;
 
         int starId;
 
         int inverseId;
 
         bool implicit;
 
         /*
         * Default constructor.   
         */
         Wave()
          : coeff(0.0),
            indicesDft(0),
            indicesBz(0),
            starId(0),
            inverseId(-1),
            implicit(false),
            sqNorm(0.0)
         {}
 
      private:
 
         double sqNorm;
 
         friend class Basis<D>;
 
      };
 
      class Star 
      {
 
      public:
 
         int size; 
 
         int beginId; 
 
         int endId;  
 
         int invertFlag; 
 
         IntVec<D> waveBz;
 
         int starId;
 
         int basisId;
 
         bool cancel;
 
         /*
         * Default constructor.   
         */
         Star()
          : size(0),
            beginId(0),
            endId(0),
            invertFlag(0),
            waveBz(0),
            starId(0),
            basisId(0),
            cancel(false)
         {}
 
      };
 
      // Public member functions of Basis<D>
 
      Basis();
 
      ~Basis();
 
      void makeBasis(Mesh<D> const & mesh, 
                     UnitCell<D> const & unitCell, 
                     SpaceGroup<D> const & group);
 
      void makeBasis(Mesh<D> const & mesh, 
                     UnitCell<D> const & unitCell, 
                     std::string groupName);
 
      void outputWaves(std::ostream& out, bool outputAll = false) const;
 
      void outputStars(std::ostream& out, bool outputAll = false) const;
 
      bool isValid() const;
 
      bool isInitialized() const;
 
      // Accessors
 
      int nWave() const;
 
      int nBasisWave() const;
 
      int nStar() const;
 
      int nBasis() const;
 
      Wave const & wave(int id) const;
 
      Star const & star(int id) const;
 
      Star const & basisFunction(int id) const;
 
      int waveId(IntVec<D> vector) const;
 
   private:
 
      DArray<Wave> waves_;
 
      GArray<Star> stars_;
 
      DArray<int> waveIds_;
 
      DArray<int> starIds_;
 
      int nWave_;
 
      int nBasisWave_;
 
      int nStar_;
 
      int nBasis_;
 
      UnitCell<D> const * unitCellPtr_;
 
      Mesh<D> const * meshPtr_;
 
      bool isInitialized_;
 
      void makeWaves();
 
      void makeStars(const SpaceGroup<D>& group);
 
      Mesh<D> const & mesh() const 
      { return *meshPtr_; }
 
      UnitCell<D> const & unitCell() const 
      { return *unitCellPtr_; }
 
   };
 
   // Inline functions
 
   template <int D>
   inline int Basis<D>::nWave() const
   {  return nWave_; }
 
   template <int D>
   inline int Basis<D>::nBasisWave() const
   {  return nBasisWave_; }
 
   template <int D>
   inline int Basis<D>::nStar() const
   {  return nStar_; }
 
   template <int D>
   inline 
   typename Basis<D>::Wave const & Basis<D>::wave(int id) const
   {  return waves_[id]; }
 
   template <int D>
   inline 
   typename Basis<D>::Star const & Basis<D>::star(int id) const
   {  return stars_[id]; }
 
   template <int D>
   inline 
   typename Basis<D>::Star const & Basis<D>::basisFunction(int id) const
   {  return stars_[starIds_[id]]; }
 
   template <int D>
   int Basis<D>::waveId(IntVec<D> vector) const
   {
      meshPtr_->shift(vector);
      int rank = mesh().rank(vector);
      return waveIds_[rank];
   }
 
   template <int D>
   inline bool Basis<D>::isInitialized() const
   {  return isInitialized_; }
 
   #ifndef PRDC_BASIS_TPP
   extern template class Basis<1>;
   extern template class Basis<2>;
   extern template class Basis<3>;
   #endif
 
} // namespace Prdc
} // namespace Pscf
#endif