bandstructure.h

#ifndef BAND_STRUCTURE_H
#define BAND_STRUCTURE_H
 
#include "exceptions.h"
#include "particle.h"
#include "points.h"
#include "utilities.h"
#include "Matrix.h"
#include <utility>
 
class BaseBandStructure {
 public:
 
  virtual ~BaseBandStructure() = default;
 
  virtual Particle getParticle() = 0;
 
  virtual Points getPoints() = 0;
 
  virtual Point getPoint(const int &pointIndex) = 0;
 
  virtual int getNumPoints(const bool &useFullGrid = false) = 0;
 
  virtual int getNumBands() = 0;
  virtual int getFullNumBands() = 0;
 
  virtual int getNumBands(WavevectorIndex &ik) = 0;
 
  virtual int hasWindow() = 0;
  virtual bool getIsDistributed() = 0;
 
  // needed in the BTE
  virtual size_t getIndex(const WavevectorIndex &ik, const BandIndex &ib) = 0;
 
  virtual std::tuple<WavevectorIndex, BandIndex> getIndex(const int &is) = 0;
  virtual std::tuple<WavevectorIndex, BandIndex> getIndex(StateIndex &is) = 0;
 
  virtual int getNumStates() = 0;
 
  virtual std::vector<size_t> parallelStateIterator();
 
  virtual const double &getEnergy(StateIndex &is) = 0;
  virtual Eigen::VectorXd getEnergies(WavevectorIndex &ik) = 0;
 
  virtual double getMaxEnergy() = 0;
 
  virtual Eigen::Vector3d getGroupVelocity(StateIndex &is) = 0;
  virtual Eigen::MatrixXd getGroupVelocities(WavevectorIndex &ik) = 0;
  virtual Eigen::Tensor<std::complex<double>, 3> getVelocities(
      WavevectorIndex &ik) = 0;
 
  virtual Eigen::MatrixXcd getEigenvectors(WavevectorIndex &ik) = 0;
  virtual Eigen::Tensor<std::complex<double>, 3> getPhEigenvectors(
      WavevectorIndex &ik) = 0;
 
  virtual Eigen::Vector3d getWavevector(StateIndex &is) = 0;
  virtual Eigen::Vector3d getWavevector(WavevectorIndex &ik) = 0;
 
  virtual void setEnergies(Point &point, Eigen::VectorXd &energies_) = 0;
 
  virtual void setEigenvectors(Point &point,
                               Eigen::MatrixXcd &eigenvectors_) = 0;
 
  virtual void setVelocities(
      Point &point, Eigen::Tensor<std::complex<double>, 3> &velocities_) = 0;
 
  virtual std::vector<Eigen::Matrix3d> getRotationsStar(WavevectorIndex &ikIndex) = 0;
 
  virtual std::vector<Eigen::Matrix3d> getRotationsStar(StateIndex &isIndex) = 0;
 
  virtual std::tuple<int, Eigen::Matrix3d> getRotationToIrreducible(
      const Eigen::Vector3d &x,
      const int &basis = Points::crystalCoordinates) = 0;
 
  virtual BteIndex stateToBte(StateIndex &isIndex) = 0;
 
  virtual StateIndex bteToState(BteIndex &iBteIndex) = 0;
 
  virtual std::vector<int> irrStateIterator() = 0;
 
  virtual std::vector<int> parallelIrrStateIterator() = 0;
 
  virtual std::vector<int> irrPointsIterator() = 0;
 
  virtual std::vector<int> parallelIrrPointsIterator() = 0;
 
  virtual int getNumIrrStates() = 0;
 
  virtual int getPointIndex(const Eigen::Vector3d &crystalCoordinates,
                             const bool &suppressError=false) = 0;
 
  virtual std::vector<int> getReducibleStarFromIrreducible(const int &ik) = 0;
 
  void outputComponentsToJSON(const std::string &outFileName = "bandstructure.json"); 
 
  void printBandStructureStateInfo(const int& fullNumBands);
 
};
 
class ActiveBandStructure;
// forward declaration of friend class
// we could remove this by making ActiveBS a subclass of FullBS
 
class FullBandStructure : public BaseBandStructure {
 public:
  FullBandStructure(int numBands_, Particle &particle_, bool withVelocities,
                    bool withEigenvectors, Points &points_,
                    bool isDistributed_ = false);
 
  FullBandStructure();
 
  /* Note, these explicit constructors are needed because we want to make deep copies
  when these objects are created and assigned as FBS fbs = h0.populate() */
 
  FullBandStructure(const FullBandStructure &that);
 
  FullBandStructure &operator=(const FullBandStructure &that);
 
  void symmetrize();
 
  Particle getParticle() override;
 
  Points getPoints() override;
 
  Point getPoint(const int &pointIndex) override;
 
  int getNumPoints(const bool &useFullGrid = false) override;
 
  int getNumBands() override;
  int getFullNumBands() override;
 
  int getNumBands(WavevectorIndex &ik) override;
 
  int hasWindow() override;
 
  bool getIsDistributed() override;
 
  bool getHasEigenvectors();
 
  size_t getIndex(const WavevectorIndex &ik, const BandIndex &ib) override;
 
  std::tuple<WavevectorIndex, BandIndex> getIndex(const int &is) override;
 
  std::tuple<WavevectorIndex, BandIndex> getIndex(StateIndex &is) override;
 
  int getNumStates() override;
 
  std::vector<int> getLocalWavevectorIndices();
 
  std::vector<std::tuple<WavevectorIndex, BandIndex>> getLocalEnergyStateIndices();
 
  //std::vector<size_t> getLocalStateIndices();
 
  std::vector<int> getLocalBandIndices() const;
 
  const double &getEnergy(StateIndex &is) override;
 
  const double &getEnergy(WavevectorIndex &ik, BandIndex &ib);
 
  Eigen::VectorXd getEnergies(WavevectorIndex &ik) override;
 
  double getMaxEnergy() override;
 
  Eigen::Vector3d getGroupVelocity(StateIndex &is) override;
 
  Eigen::MatrixXd getGroupVelocities(WavevectorIndex &ik) override;
 
  Eigen::Tensor<std::complex<double>, 3> getVelocities(WavevectorIndex &ik) override;
 
  Eigen::MatrixXcd getEigenvectors(WavevectorIndex &ik) override;
 
  Eigen::Tensor<std::complex<double>, 3> getPhEigenvectors(WavevectorIndex &ik) override;
 
  Eigen::Vector3d getWavevector(StateIndex &is) override;
 
  Eigen::Vector3d getWavevector(WavevectorIndex &ik) override;
 
  void setEnergies(Point &point, Eigen::VectorXd &energies_) override;
 
  void setEigenvectors(Point &point, Eigen::MatrixXcd &eigenvectors_) override;
 
  void setVelocities(Point &point,
                     Eigen::Tensor<std::complex<double>, 3> &velocities_) override;
 
  void setEnergies(Eigen::Vector3d &point, Eigen::VectorXd &energies_);
 
  Eigen::VectorXd getBandEnergies(int &bandIndex);
 
  std::vector<Eigen::Matrix3d> getRotationsStar(WavevectorIndex &ikIndex) override;
 
  std::vector<Eigen::Matrix3d> getRotationsStar(StateIndex &isIndex) override;
 
  std::tuple<int, Eigen::Matrix3d> getRotationToIrreducible(
      const Eigen::Vector3d &x,
      const int &basis = Points::crystalCoordinates) override;
 
  BteIndex stateToBte(StateIndex &isIndex) override;
 
  StateIndex bteToState(BteIndex &iBteIndex) override;
 
  std::vector<int> irrStateIterator() override;
 
  std::vector<int> parallelIrrStateIterator() override;
 
  std::vector<int> irrPointsIterator() override;
 
  std::vector<int> parallelIrrPointsIterator() override;
 
  int getNumIrrStates() override;
 
  int getPointIndex(const Eigen::Vector3d &crystalCoordinates,
                    const bool &suppressError=false) override;
 
  std::vector<int> getReducibleStarFromIrreducible(const int &ik) override;
 
protected:
  // stores the quasiparticle kind
  Particle particle;
 
  // link to the underlying mesh of points
  Points &points;  // these may be FullPoints or PathPoints
 
  // if the bands are distributed or not
  bool isDistributed = false;
 
  bool hasEigenvectors = false;
  bool hasVelocities = false;
 
  // matrices storing the raw data
  Matrix<double> energies;       // size(bands,points)
  Matrix<std::complex<double>> velocities;    // size(3*bands^2,points)
  Matrix<std::complex<double>> eigenvectors;  // size(bands^2,points)
 
  // auxiliary variables
  int numBands = 0;
  int numAtoms = 0;
  size_t numPoints = 0;
  int numLocalPoints = 0;
 
  // method to find the index of the point, from its crystal coordinates
  //int getIndex(Eigen::Vector3d &pointCoordinates);
 
  // ActiveBandStructure, which restricts the FullBandStructure to a subset
  // of wavevectors, needs low-level access to the raw data (for now)
  friend class ActiveBandStructure;
};
 
#endif