active_bandstructure.h

#ifndef ACT_BAND_STRUCTURE_H
#define ACT_BAND_STRUCTURE_H
 
#include "bandstructure.h"
#include "constants.h"
#include "harmonic.h"
#include "particle.h"
#include "points.h"
#include "statistics_sweep.h"
#include "window.h"
 
class ActiveBandStructure : public BaseBandStructure {
public:
  ActiveBandStructure(Particle &particle_, Points &points_);
 
 
  ActiveBandStructure(const Points &points_,
                      HarmonicHamiltonian *h0, const bool &withEigenvectors,
                      const bool &withVelocities);
 
  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;
 
  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;
 
  const double &getEnergy(StateIndex &is) override;
 
  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 setEnergies(Point &point, std::vector<double> &energies_);
 
  void setEigenvectors(Point &point, Eigen::MatrixXcd &eigenvectors_) override;
 
  void setVelocities(Point &point,
                     Eigen::Tensor<std::complex<double>, 3> &velocities_) override;
 
  static std::tuple<ActiveBandStructure, StatisticsSweep>
  builder(Context &context, HarmonicHamiltonian &h0, Points &points,
          const bool &withEigenvectors = true,
          const bool &withVelocities = true, const bool &forceBuildAPP = false);
 
  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;
 
  Points points;
 
  // note: we don't store a matrix: we are storing an object (Nk,Nb),
  // with a variable number of bands Nb per point
  std::vector<double> energies;
  std::vector<std::complex<double>> velocities, eigenvectors;
 
  bool hasEigenvectors = false;
  bool hasVelocities = false;
  int numStates = 0;
  int numIrrStates;
  int numIrrPoints;
  int numPoints;
 
  Eigen::VectorXi numBands;
  int numFullBands = 0;
  int windowMethod = 0;
 
  // index management
  // these are two auxiliary vectors to store indices
  Eigen::MatrixXi auxBloch2Comb;
  Eigen::VectorXi cumulativeKbOffset;
  Eigen::MatrixXi bteAuxBloch2Comb;
  Eigen::VectorXi bteCumulativeKbOffset;
  Eigen::VectorXi cumulativeKbbOffset;
  // this is the functionality to build the indices
  void buildIndices(); // to be called after building the band structure
  // and these are the tools to convert indices
  void buildSymmetries();
  // symmetrizes the band energies, velocities, and eigenvectors
  //void symmetrize(Context &context, const bool& withVelocities);
 
  // utilities to convert Bloch indices into internal indices
  size_t velBloch2Comb(const int &ik, const int &ib1, const int &ib2,
                     const int &i);
  size_t eigBloch2Comb(const int &ik, const int &ibFull, const int &ibRed);
  size_t bloch2Comb(const int &k, const int &b);
  std::tuple<int, int> comb2Bloch(const int &is);
 
  size_t bteBloch2Comb(const int &k, const int &b);
  std::tuple<int, int> bteComb2Bloch(const int &is);
 
  void buildOnTheFly(Window &window, Points points_, HarmonicHamiltonian &h0,
                     const bool &withEigenvectors = true,
                     const bool &withVelocities = true);
 
  StatisticsSweep buildAsPostprocessing(Context &context, Points points_,
                                        HarmonicHamiltonian &h0,
                                        const bool &withEigenvector = true,
                                        const bool &withVelocities = true);
 
  /*void enforceBandNumSymmetry(Context& context, const int& numFullBands,
        const std::vector<int>& myFilteredPoints,
        Eigen::MatrixXi& filteredBands,
        const std::vector<int>& displacements,
        HarmonicHamiltonian& h0, const bool &withVelocities);
        */
};
 
#endif