Basis.h

#ifndef PRDC_BASIS_H
#define PRDC_BASIS_H
/*
* PSCF - Polymer Self-Consistent Field
*
* Copyright 2015 - 2025, 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
#include <util/signal/Signal.h>           // member
 
// Forward declarations
namespace Util {
   template <typename T> class Signal;
   template <> class Signal<void>;
}
namespace Pscf {
  namespace Prdc {
     template <int D> class UnitCell;
     template <int D> class SpaceGroup;
  }
}
 
namespace Pscf {
namespace Prdc {
 
   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;

         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;

         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();
 
      // Initialization

      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);

      Signal<void>& signal();
 
      // Data Output

      void outputWaves(std::ostream& out, bool outputAll = false) const;

      void outputStars(std::ostream& out, bool outputAll = false) 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;

      bool isInitialized() const;

      bool isValid() const;
 
   private:

      DArray<Wave> waves_;

      GArray<Star> stars_;

      DArray<int> waveIds_;

      DArray<int> starIds_;

      int nWave_;

      int nBasisWave_;

      int nStar_;

      int nBasis_;

      Signal<>* signalPtr_;

      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