electron_h0_wannier.h

#ifndef WANNIER_H0_H
#define WANNIER_H0_H
 
#include <cmath>
 
#include "bandstructure.h"
#include "constants.h"
#include "eigen.h"
#include "harmonic.h"
#include "points.h"
#include "common_kokkos.h"
 
class ElectronH0Wannier : public HarmonicHamiltonian {
 public:
 
  ElectronH0Wannier(
      const Eigen::Matrix3d &directUnitCell_,
      const Eigen::MatrixXd &bravaisVectors_,
      const Eigen::VectorXd &vectorsDegeneracies_,
      const Eigen::Tensor<std::complex<double>, 3> &h0R_,
      const Eigen::Tensor<std::complex<double>, 4>* rMatrix_=nullptr);
 
  ElectronH0Wannier(const ElectronH0Wannier &that);
 
  ElectronH0Wannier &operator=(const ElectronH0Wannier &that);
 
  ~ElectronH0Wannier();
 
  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 &k) override;
 
  std::tuple<std::vector<Eigen::VectorXd>, std::vector<Eigen::MatrixXcd>>
  batchedDiagonalizeFromCoordinates(std::vector<Eigen::Vector3d>& cartesianWavevectors);
 
  std::vector<Eigen::MatrixXcd> batchedBuildHamiltonians(
    std::vector<Eigen::Vector3d>& cartesianWavevectors);
 
  StridedComplexView3D kokkosBatchedBuildBlochHamiltonian(
    const DoubleView2D &cartesianCoordinates) override;
 
  std::tuple<DoubleView2D, StridedComplexView3D> kokkosBatchedDiagonalizeFromCoordinates(
      const DoubleView2D &cartesianCoordinates, const bool withMassScaling=true) override;
  std::tuple<DoubleView2D, StridedComplexView3D, ComplexView4D>
  kokkosBatchedDiagonalizeWithVelocities(
      const DoubleView2D &cartesianCoordinates) override;
 
  Eigen::Tensor<std::complex<double>, 3> diagonalizeVelocity(Point &point) override;
  Eigen::Tensor<std::complex<double>, 3> diagonalizeVelocityFromCoordinates(
      Eigen::Vector3d &coordinates) override;
 
  std::tuple<std::vector<Eigen::VectorXd>,
             std::vector<Eigen::MatrixXcd>,
             std::vector<Eigen::Tensor<std::complex<double>, 3>>>
    batchedDiagonalizeWithVelocities(
      std::vector<Eigen::Vector3d> cartesianCoordinates);
 
  FullBandStructure populate(Points &fullPoints, const bool &withVelocities,
                             const bool &withEigenvectors,
                             const bool isDistributed=false) override;
 
  std::tuple<std::vector<Eigen::VectorXd>, std::vector<Eigen::MatrixXcd>,
           std::vector<Eigen::Tensor<std::complex<double>,3>>>
                    populate(const std::vector<Eigen::Vector3d>& cartesianCoordinates,
                             const bool &withVelocities,
                             const bool &withEigenvectors);
 
  FullBandStructure cpuPopulate(Points &fullPoints, const bool &withVelocities,
                                const bool &withEigenvectors,
                                const bool isDistributed=false);
 
  std::tuple<std::vector<Eigen::VectorXd>, std::vector<Eigen::MatrixXcd>,
        std::vector<Eigen::Tensor<std::complex<double>,3>>>
                    kokkosPopulate(const std::vector<Eigen::Vector3d>& cartesianCoordinates,
                                   const bool &withVelocities,
                                   const bool &withEigenvectors, const std::vector<int>& iks);
 
  std::vector<Eigen::MatrixXcd> getBerryConnection(Point &point);
 
  void addShiftedVectors(Eigen::Tensor<double,3> degeneracyShifts_,
                         Eigen::Tensor<double,5> vectorsShifts_);
 
  int estimateBatchSize(const bool& withVelocity) override;
 
 protected:
  Particle particle;
 
  // list of lattice vectors, used for the Fourier transform from real
  // to reciprocal space
  Eigen::MatrixXd bravaisVectors;
  // count the vector degeneracies, to use symmetries
  Eigen::VectorXd vectorsDegeneracies;
  Eigen::Matrix3d directUnitCell;
  // hamiltonian matrix in real space <0m|H|nR>
  Eigen::Tensor<std::complex<double>, 3> h0R;
  // position matrix elements <0m|r|nR>
  Eigen::Tensor<std::complex<double>, 4> rMatrix;
 
  int numWannier;
  int numVectors;
 
  Eigen::Tensor<double,3> degeneracyShifts;
  Eigen::Tensor<double,5> vectorsShifts;
  bool hasShiftedVectors = false;
 
  ComplexView3D h0R_d;
  DoubleView3D degeneracyShifts_d;
  DoubleView5D vectorsShifts_d;
  DoubleView1D vectorsDegeneracies_d;
  DoubleView2D bravaisVectors_d;
 
  double getDeviceMemoryUsage();
 
};
 
#endif