UnitCellBase.h

#ifndef PRDC_UNIT_CELL_BASE_H
#define PRDC_UNIT_CELL_BASE_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/RealVec.h>         // member
#include <pscf/math/IntVec.h>          // interface, with default parameters
#include <util/containers/FArray.h>    // member
#include <util/containers/FMatrix.h>   // member
#include <util/containers/FSArray.h>   // interface
 
// Forward declarations
namespace Util {
   template <typename T> class Signal;
   template <> class Signal<void>;
}
 
namespace Pscf {
namespace Prdc {
 
   using namespace Util;

   template <int D>
   class UnitCellBase
   {
   public:
 
      // Protected constructor and destructor (see below)


      void setParameters(FSArray<double, 6> const & parameters);

      int nParameter() const;

      FSArray<double, 6> parameters() const;

      double parameter(int i) const;

      bool isInitialized() const;

 
      const RealVec<D>& rBasis(int i) const;

      const RealVec<D>& kBasis(int i) const;

      double drBasis(int k, int i, int j) const;

      double dkBasis(int k, int i, int j) const;

      double drrBasis(int k, int i, int j) const;

      double dkkBasis(int k, int i, int j) const;


      virtual double ksq(IntVec<D> const & k) const;

      virtual double dksq(IntVec<D> const & vec, int n) const;


      void setSignal(Signal<void>& signal);

      bool hasSignal() const;

      Signal<void>& signal();

 
   protected:
 
      // Protected member functions

      UnitCellBase();

      virtual ~UnitCellBase() = default;

      void setLattice();
 
      // Protected member variables

      FArray<RealVec<D>, D> rBasis_;

      FArray<RealVec<D>, D> kBasis_;

      FArray<FMatrix<double, D, D>, 6> drBasis_;

      FArray<FMatrix<double, D, D>, 6> dkBasis_;

      FArray<FMatrix<double, D, D>, 6> drrBasis_;

      FArray<FMatrix<double, D, D>, 6> dkkBasis_;

      FArray<double, 6> parameters_;

      int nParameter_;

      bool isInitialized_;
 
   private:

      Signal<void>* signalPtr_;

      void initializeToZero();

      virtual void setBasis() = 0;

      void computeDerivatives();

      UnitCellBase(UnitCellBase<D> const & other);

      UnitCellBase<D>& operator = (UnitCellBase<D> const & other);
 
   };
 
   // Inline member functions
 
   /*
   * Get the number of Parameters in the unit cell.
   */
   template <int D>
   inline
   int UnitCellBase<D>::nParameter() const
   {  return nParameter_;  }
 
   /*
   * Get a single parameter of the unit cell.
   */
   template <int D>
   inline
   double UnitCellBase<D>::parameter(int i) const
   {  return parameters_[i]; }
 
   /*
   * Get Bravais basis vector i.
   */
   template <int D>
   inline
   const RealVec<D>& UnitCellBase<D>::rBasis(int i) const
   {  return rBasis_[i];  }
 
   /*
   * Get reciprocal basis vector i.
   */
   template <int D>
   inline
   const RealVec<D>& UnitCellBase<D>::kBasis(int i) const
   {  return kBasis_[i];  }
 
   /*
   * Get component j of derivative of r basis vector i w/respect to param k.
   */
   template <int D>
   inline
   double UnitCellBase<D>::drBasis(int k, int i, int j) const
   {  return drBasis_[k](i,j);  }
 
   /*
   * Get component j of derivative of r basis vector i w/respect to param k.
   */
   template <int D>
   inline
   double UnitCellBase<D>::dkBasis(int k, int i, int j) const
   {  return dkBasis_[k](i, j);  }
 
   /*
   * Get the derivative of ki*kj with respect to parameter k.
   */
   template <int D>
   inline
   double UnitCellBase<D>::dkkBasis(int k, int i, int j) const
   {  return dkkBasis_[k](i, j);  }
 
   /*
   * Get the derivative of ri*rj with respect to parameter k.
   */
   template <int D>
   inline
   double UnitCellBase<D>::drrBasis(int k, int i, int j) const
   {  return drrBasis_[k](i, j);  }
 
   /*
   * Is this unit cell initialized?
   */
   template <int D>
   inline
   bool UnitCellBase<D>::isInitialized() const
   {  return isInitialized_; }
 
   // Explicit instantiation declaration
   extern template class UnitCellBase<1>;
   extern template class UnitCellBase<2>;
   extern template class UnitCellBase<3>;
 
}
}
#endif