electron_h0_fourier.h

#ifndef H0FOURIER_H
#define H0FOURIER_H
 
#include <string>
 
#include "bandstructure.h"
#include "harmonic.h"
#include "points.h"
#include "context.h"
#include "common_kokkos.h"
 
class ElectronH0Fourier : public HarmonicHamiltonian {
 public:
 
  ElectronH0Fourier(Crystal &crystal_, const Points& coarsePoints_,
                    const FullBandStructure& coarseBandStructure_, double cutoff);
 
  Particle getParticle() override;
 
  int getNumBands() override;
 
  std::tuple<Eigen::VectorXd, Eigen::MatrixXcd> diagonalize(Point &point) override;
 
  std::tuple<Eigen::VectorXd, Eigen::MatrixXcd> diagonalizeFromCoordinates(
      Eigen::Vector3d &wavevector) override;
 
  Eigen::Tensor<std::complex<double>, 3> diagonalizeVelocity(Point &point) override;
  Eigen::Tensor<std::complex<double>, 3> diagonalizeVelocityFromCoordinates(
      Eigen::Vector3d &coordinates) override;
 
  FullBandStructure populate(Points &fullPoints, const bool &withVelocities,
                             const bool &withEigenvectors,
                             const bool isDistributed=false) override;
 
  void trimBands(Context &context, const double &minEn, const double &maxEn);
  virtual StridedComplexView3D kokkosBatchedBuildBlochHamiltonian(
      const DoubleView2D &cartesianCoordinates) override;
  virtual std::tuple<DoubleView2D, StridedComplexView3D, ComplexView4D>
  kokkosBatchedDiagonalizeWithVelocities(
      const DoubleView2D &cartesianCoordinates) override;
  std::tuple<DoubleView2D, StridedComplexView3D>
  kokkosBatchedDiagonalizeFromCoordinates(
      const DoubleView2D &cartesianCoordinates, const bool withMassScaling=true) override;
 protected:
  Crystal &crystal;
  FullBandStructure coarseBandStructure;
  Points coarsePoints;
  Particle particle;
 
  Eigen::MatrixXcd expansionCoefficients;
 
  int numBands;
  double cutoff;
  int numDataPoints;
  int numPositionVectors = 0;
  double minDistance = 10.;
  Eigen::VectorXd positionDegeneracies;
  Eigen::MatrixXd positionVectors;
  Eigen::Vector3d refWavevector;
 
  void setPositionVectors();
  Eigen::VectorXcd getLagrangeMultipliers(Eigen::VectorXd energies);
  Eigen::VectorXcd getCoefficients(Eigen::VectorXd energies);
  std::complex<double> getStarFunction(Eigen::Vector3d &wavevector, int &iR);
  Eigen::Vector3cd getDerivativeStarFunction(Eigen::Vector3d &wavevector,
                                             int &iR);
  double getRoughnessFunction(const Eigen::Vector3d &position) const;
  const double coefficient1 = 0.75;  // 3/4
  const double coefficient2 = 0.75;
  double getEnergyFromCoordinates(Eigen::Vector3d &wavevector, int &bandIndex);
  Eigen::Vector3d getGroupVelocityFromCoordinates(Eigen::Vector3d &wavevector,
                                             int &bandIndex);
};
 
#endif