harmonic.h

#ifndef HARMONIC_H
#define HARMONIC_H
 
#include "bandstructure.h"
#include "particle.h"
#include "points.h"
#include "common_kokkos.h"
 
class HarmonicHamiltonian {
 public:
  virtual int getNumBands() = 0;
 
  virtual Particle getParticle() = 0;
 
  virtual std::tuple<Eigen::VectorXd, Eigen::MatrixXcd> diagonalize(
      Point &point) = 0;
 
  virtual std::tuple<Eigen::VectorXd, Eigen::MatrixXcd>
  diagonalizeFromCoordinates(
      Eigen::Vector3d &k) = 0;
 
  virtual Eigen::Tensor<std::complex<double>, 3> diagonalizeVelocity(
      Point &point) = 0;
  virtual Eigen::Tensor<std::complex<double>, 3>
  diagonalizeVelocityFromCoordinates(
      Eigen::Vector3d &coordinates) = 0;
 
  virtual FullBandStructure populate(Points &fullPoints, const bool &withVelocities,
                                     const bool &withEigenvectors,
                                     const bool isDistributed = false) = 0;
  virtual std::tuple<DoubleView2D, StridedComplexView3D, ComplexView4D>
      kokkosBatchedDiagonalizeWithVelocities(
      const DoubleView2D &cartesianCoordinates) = 0;
  void kokkosBatchedTreatDegenerateVelocities(
      const DoubleView2D& cartesianCoordinates,
      const DoubleView2D& resultEnergies, ComplexView4D& resultVelocities,
      const double& threshold);
  virtual StridedComplexView3D kokkosBatchedBuildBlochHamiltonian(
      const DoubleView2D &cartesianCoordinates) = 0;
  virtual std::tuple<DoubleView2D, StridedComplexView3D>
  kokkosBatchedDiagonalizeFromCoordinates(
      const DoubleView2D &cartesianCoordinates, const bool withMassScaling=true) = 0;
 
  virtual int estimateBatchSize(const bool& withVelocity) {
    (void) withVelocity;
    return 1;
  };
};
 
#endif