elph_qe_to_phoebe_app.h

#ifndef EL_PH_BLOCH_TO_WAN_APP_H
#define EL_PH_BLOCH_TO_WAN_APP_H
 
#include "app.h"
#include "electron_h0_wannier.h"
#include "phonon_h0.h"
 
class ElPhQeToPhoebeApp : public App {
public:
  void run(Context &context) override;
 
  void checkRequirements(Context &context) override;
 
  // these are public because need testing
  static std::tuple<Eigen::Vector3i, Eigen::Vector3i, Eigen::MatrixXd,
                    Eigen::MatrixXd, Eigen::MatrixXd, int, int, int, int>
  readQEPhoebeHeader(Crystal &crystal, const std::string &phoebePrefixQE);
 
  void postProcessingWannier(
      Context &context, Crystal &crystal, PhononH0 &phononH0, Points &kPoints,
      Points &qPoints, int numQEBands, int numModes, int numIrrQPoints,
      int numElectrons, int numSpin, const Eigen::MatrixXd &energies,
      const Eigen::MatrixXd &kGridFull, const Eigen::Vector3i &kMesh,
      const Eigen::Vector3i &qMesh, bool runTests = false);
 
protected:
  Eigen::Tensor<std::complex<double>, 5> static blochToWannier(
      const Eigen::MatrixXd &elBravaisVectors,
      const Eigen::MatrixXd &phBravaisVectors,
      Eigen::Tensor<std::complex<double>, 5> &gFull,
      const Eigen::Tensor<std::complex<double>, 3> &uMatrices,
      const Eigen::Tensor<std::complex<double>, 3> &phEigenvectors,
      Points &kPoints, Points &qPoints, Crystal &crystal, PhononH0 &phononH0);
 
  Eigen::Tensor<std::complex<double>, 5> BlochToWannierEfficient(
      Context &context, const Eigen::MatrixXd &energies,
      const Eigen::MatrixXd &kGridFull, const int &numIrrQPoints,
      const int &numQEBands, const Eigen::MatrixXd &elBravaisVectors,
      const Eigen::MatrixXd &phBravaisVectors,
      const Eigen::Tensor<std::complex<double>, 3> &uMatrices, Points &kPoints,
      Points &qPoints, Crystal &crystal, PhononH0 &phononH0);
 
  static Eigen::Tensor<std::complex<double>, 3>
  setupRotationMatrices(const std::string &wannierPrefix, Points &fullPoints);
 
  std::tuple<Eigen::Tensor<std::complex<double>, 5>,
             Eigen::Tensor<std::complex<double>, 3>, Eigen::MatrixXd>
  readGFromQEFile(Context &context, const int &numModes, const int &numBands,
                  const int &numWannier, Points &kPoints, Points &qPoints,
                  const Eigen::MatrixXd &kGridFull, const int &numIrrQPoints,
                  const int &numQEBands, const Eigen::MatrixXd &energies);
 
  std::tuple<Eigen::Tensor<std::complex<double>, 5>,
             Eigen::Tensor<std::complex<double>, 3>, Eigen::MatrixXd,
             Eigen::MatrixXd>
  readChunkGFromQE(const int &iqIrr, Context &context, Points &kPoints,
                   const int &numModes, const int &numQEBands,
                   const Eigen::VectorXi &ikMap);
 
  static int computeOffset(const Eigen::MatrixXd &energies,
                           const std::string &wannierPrefix);
 
  // valid choices of interpolation, either "wannier" or "epa"
  std::vector<std::string> choices;
 
  void epaPostProcessing(Context &context, Eigen::MatrixXd &elEnergies,
                         Points &kPoints, Points &qPoints,
                         const int &numElectrons, const int &numSpin,
                         const int &numModes, const int &numIrrQPoints,
                         const int &numQEBands,
                         const Eigen::MatrixXd &kGridFull);
 
  static void testElectronicTransform(
      Points &kPoints, const std::string &wannierPrefix,
      const Eigen::MatrixXd &elBravaisVectors,
      const Eigen::Tensor<std::complex<double>, 3> &uMatrices,
      const Eigen::VectorXd &elDegeneracies, ElectronH0Wannier &electronH0);
 
  static void testPhononTransform(
      Crystal &crystal, PhononH0 &phononH0, Points &qPoints,
      const Eigen::Tensor<std::complex<double>, 3> &phEigenvectors,
      const Eigen::MatrixXd &phBravaisVectors,
      const Eigen::VectorXd &phDegeneracies, const Eigen::MatrixXd &phEnergies);
 
  static void testBackTransform(Context &context, PhononH0 &phononH0,
                                Points &kPoints, Points &qPoints,
                                ElectronH0Wannier &electronH0, Crystal &crystal,
                                Eigen::Tensor<std::complex<double>, 5> &gFull);
 
  static void writeWannierCoupling(
      Context &context, Eigen::Tensor<std::complex<double>, 5> &gWannier,
      const int &numFilledWannier, const int &numSpin, const int &numModes,
      const int &numWannier, const Eigen::VectorXd &phDegeneracies,
      const Eigen::VectorXd &elDegeneracies,
      const Eigen::MatrixXd &phBravaisVectors,
      const Eigen::MatrixXd &elBravaisVectors, const Eigen::Vector3i &qMesh,
      const Eigen::Vector3i &kMesh);
};
 
#endif