context.h

#ifndef CONTEXT_H
#define CONTEXT_H
 
#include <limits>  // NaN
#include <string>
#include <vector>
 
#include "eigen.h"
 
class Context {
 private:
  std::string phFC2FileName;
  std::string phFC3FileName;
  std::string phonopyDispFileName;
  std::string phonopyBORNFileName;
 
  std::string electronH0Name;
  std::string wannier90Prefix;
  std::string jdftxScfOutFile;
  std::string quantumEspressoPrefix;
  std::string elPhInterpolation;
 
  std::string appName;
  std::string sumRuleFC2;
  int smearingMethod = -1;
  double smearingWidth = std::numeric_limits<double>::quiet_NaN();
  double elSmearingWidth = std::numeric_limits<double>::quiet_NaN();
  double phSmearingWidth = std::numeric_limits<double>::quiet_NaN();
  //double dragSmearingWidth = std::numeric_limits<double>::quiet_NaN();
  double adaptiveSmearingPrefactor = std::numeric_limits<double>::quiet_NaN();
  Eigen::VectorXd temperatures;
  std::vector<std::string> solverBTE;
  double convergenceThresholdBTE = 1e-2;
  int maxIterationsBTE = 50;
 
  bool scatteringMatrixInMemory = true;
  bool useSymmetries = false;
  bool symmetrizeBandStructure = false;
 
  std::string windowType = "nothing";
  Eigen::Vector2d windowEnergyLimit = Eigen::Vector2d::Zero();
  double windowPopulationLimit = std::numeric_limits<double>::quiet_NaN();
 
  Eigen::VectorXd dopings;
  Eigen::VectorXd chemicalPotentials;
  double electronFourierCutoff = std::numeric_limits<double>::quiet_NaN();
 
  Eigen::Vector3i qMesh = Eigen::Vector3i::Zero();
  Eigen::Vector3i kMesh = Eigen::Vector3i::Zero();
 
  double fermiLevel = std::numeric_limits<double>::quiet_NaN();
  double numOccupiedStates = std::numeric_limits<double>::quiet_NaN();
  bool hasSpinOrbit = false;
  double spinDegeneracyFactor = 2.; 
 
  int dimensionality = 3;
  double thickness = 1.; // material thickness or cross area for lower dimensions
 
  double dosMinEnergy = std::numeric_limits<double>::quiet_NaN();
  double dosMaxEnergy = std::numeric_limits<double>::quiet_NaN();
  double dosDeltaEnergy = std::numeric_limits<double>::quiet_NaN();
 
  Eigen::MatrixXd inputAtomicPositions;
  Eigen::VectorXi inputAtomicSpecies;
  std::vector<std::string> inputSpeciesNames;
 
  Eigen::Tensor<double, 3> pathExtrema;
  std::vector<std::string> pathLabels;
  double deltaPath = 0.05;
 
  bool outputEigendisplacements = false; // used by bands app if phonon eigdisps are dumped
  bool outputUNTimes = false; // triggers scattering matrix to output times for U and N processes
 
  double constantRelaxationTime = std::numeric_limits<double>::quiet_NaN();
  bool withIsotopeScattering = true;  // add isotopes in phonon scattering matrix
 
  // for custom masses and custom isotope scattering
  Eigen::VectorXd customIsotopeCouplings;
  Eigen::VectorXd customMasses;
 
  // the C coefficient as in the ee self energy for a Fermi liquid
  // will be internally stored in 1/Ry
  double eeFermiLiquidCoefficient = 0; 
 
  // add RTA boundary scattering in scattering matrix
  double boundaryLength = std::numeric_limits<double>::quiet_NaN();
 
  std::string elphFileName;
  double minChemicalPotential = std::numeric_limits<double>::quiet_NaN();
  double maxChemicalPotential = std::numeric_limits<double>::quiet_NaN();
  double deltaChemicalPotential = std::numeric_limits<double>::quiet_NaN();
  double minTemperature = std::numeric_limits<double>::quiet_NaN();
  double maxTemperature = std::numeric_limits<double>::quiet_NaN();
  double deltaTemperature = std::numeric_limits<double>::quiet_NaN();
  double eFermiRange = std::numeric_limits<double>::quiet_NaN();
 
  std::string epaFileName;
  double epaEnergyRange = std::numeric_limits<double>::quiet_NaN();
  double epaEnergyStep = std::numeric_limits<double>::quiet_NaN();
  double epaMinEnergy = std::numeric_limits<double>::quiet_NaN();
  double epaMaxEnergy = std::numeric_limits<double>::quiet_NaN();
  int epaNumBins;
  double epaSmearingEnergy = std::numeric_limits<double>::quiet_NaN();
  double epaDeltaEnergy = std::numeric_limits<double>::quiet_NaN();
 
  // plot of el-ph coupling
  std::string g2PlotStyle = "allToAll";
  std::string g2MeshStyle = "pointsMesh";
  Eigen::Vector3d g2PlotFixedPoint = {0,0,0};
  std::pair<int,int> g2PlotEl1Bands = std::make_pair(0,-1);
  std::pair<int,int> g2PlotEl2Bands = std::make_pair(0,-1);
  std::pair<int,int> g2PlotPhBands = std::make_pair(0,-1);
 
  // utilities for parsing
 
  static std::vector<std::string> &split(const std::string &s, char delimiter,
                                  std::vector<std::string> &elements);
  static std::vector<std::string> split(const std::string &s, char delimiter);
 
  // variable used for the polarization
  Eigen::VectorXi numCoreElectrons;
 
  bool distributedElPhCoupling = true; // MPI parallelize the el-ph coupling
  // currently only support parallelization of the qe2Phoebe app
 
  // if true, enforce the symmetrization of the scattering matrix
  bool symmetrizeMatrix = false;
  // if true, and symmetrize matrix = false,
  // only compute the upper triangle of the matrix
  bool useUpperTriangle = false;
 
  // number of eigenvalues to use the in the relaxons solver
  int numRelaxonsEigenvalues = 0;
  // toggle the check for negative relaxons eigenvalues in few eigenvalues case
  bool checkNegativeRelaxons = true;
  // toggle the enforcement of the matrix being positive semidefinite
  bool enforcePositiveSemiDefinite = false;
 
  // for coupled transport
  bool useDragTerms = true;
  bool enforceDetailedBalance = false;
 
  int hdf5ElphFileFormat = 1;
  std::string wsVecFileName;
 
public:
 
  // Setter and getter for all the variables above ----------------
 
  // Methods for the apps of plotting the electron-phonon coupling
  std::string getG2PlotStyle();
  void setG2PlotStyle(const std::string &x);
 
  std::string getG2MeshStyle();
  void setG2MeshStyle(const std::string &x);
 
  Eigen::Vector3d getG2PlotFixedPoint();
  void setG2PlotFixedPoint(const Eigen::Vector3d &x);
 
  std::pair<int,int> getG2PlotEl1Bands();
  void setG2PlotEl1Bands(const std::pair<int,int> &x);
 
  std::pair<int,int> getG2PlotEl2Bands();
  void setG2PlotEl2Bands(const std::pair<int,int> &x);
 
  std::pair<int,int> getG2PlotPhBands();
  void setG2PlotPhBands(const std::pair<int,int> &x);
 
  std::string getPhFC2FileName();
  void setPhFC2FileName(const std::string &x);
 
  std::string getPhFC3FileName();
  void setPhFC3FileName(const std::string &x);
 
  std::string getPhonopyDispFileName();
  void setPhonopyDispFileName(const std::string &x);
 
  std::string getPhonopyBORNFileName();
 
  std::string getElphFileName();
  void setElphFileName(const std::string &x);
 
  std::string getWannier90Prefix();
  void setWannier90Prefix(const std::string &x);
 
  std::string getQuantumEspressoPrefix();
  void setQuantumEspressoPrefix(const std::string &x);
 
  std::string getJDFTxScfOutFile();
  void setJDFTxScfOutFile(const std::string &x);
 
  std::string getElPhInterpolation();
 
  double getEpaSmearingEnergy() const;
  double getEpaDeltaEnergy() const;
  double getEpaMinEnergy() const;
  double getEpaMaxEnergy() const;
  int getEpaNumBins() const;
 
  std::string getElectronH0Name();
  void setElectronH0Name(const std::string &x);
 
  double getElectronFourierCutoff() const;
 
  std::string getAppName();
 
  std::string getSumRuleFC2();
  void setSumRuleFC2(const std::string &x);
 
  Eigen::Vector3i getQMesh();
 
  Eigen::Vector3i getKMesh();
 
  Eigen::Vector3i getKMeshPhEl();
  void setKMeshPhEl(Eigen::Vector3i newKMeshPhEl);
 
  std::string getWindowType();
  void setWindowType(const std::string &x);
 
  Eigen::Vector2d getWindowEnergyLimit();
  void setWindowEnergyLimit(const Eigen::Vector2d &x);
 
  double getWindowPopulationLimit() const;
  void setWindowPopulationLimit(const double &x);
 
  Eigen::VectorXd getChemicalPotentials();
 
  Eigen::VectorXd getDopings();
  void setDopings(const Eigen::VectorXd &x);
 
  Eigen::VectorXd getTemperatures();
  void setTemperatures(const Eigen::VectorXd &x);
 
  std::vector<std::string> getSolverBTE();
 
  double getConvergenceThresholdBTE() const;
 
  int getMaxIterationsBTE() const;
 
  int getDimensionality() const;
 
  double getThickness() const;
 
  double getDosMinEnergy() const;
 
  double getDosMaxEnergy() const;
 
  double getDosDeltaEnergy() const;
 
  // Wannier90 output doesn't contain the crystal information.
  // the user must then supplement it in the input
  // at least, if there's no phonon run
  // we may change the behavior in the future, parsing another file
  Eigen::MatrixXd getInputAtomicPositions();
 
  Eigen::VectorXi getInputAtomicSpecies();
 
  std::vector<std::string> getInputSpeciesNames();
 
  void setInputAtomicPositions(const Eigen::MatrixXd &x);
  void setInputAtomicSpecies(const Eigen::VectorXi &x);
  void setInputSpeciesNames(const std::vector<std::string> &x);
 
  Eigen::Tensor<double, 3> getPathExtrema();
  std::vector<std::string> getPathLabels();
 
  double getDeltaPath() const;
 
  bool getOutputEigendisplacements() const;
  bool getOutputUNTimes() const;
 
  double getFermiLevel() const;
  void setFermiLevel(const double &x);
 
  double getNumOccupiedStates() const;
  void setNumOccupiedStates(const double &x);
 
  bool getHasSpinOrbit() const;
  void setHasSpinOrbit(const bool &x);
 
  double getSpinDegeneracyFactor() const;
  void setSpinDegeneracyFactor(const double &x);
 
  int getSmearingMethod() const;
 
  double getSmearingWidth() const;
  void setSmearingWidth(const double &x);
 
  double getElSmearingWidth() const;
  void setElSmearingWidth(const double &x);
 
  double getPhSmearingWidth() const;
  void setPhSmearingWidth(const double &x);
 
  //double getDragSmearingWidth() const;
  //void setDragSmearingWidth(const double &x);
 
  double getAdaptiveSmearingPrefactor() const;
  void setAdaptiveSmearingPrefactor(const double &x);
 
  double getConstantRelaxationTime() const;
 
  bool getScatteringMatrixInMemory() const;
  void setScatteringMatrixInMemory(const bool &x);
 
  bool getUseSymmetries() const;
  void setUseSymmetries(const bool &x);
  bool getSymmetrizeBandStructure() const;
  void setSymmetrizeBandStructure(const bool &x);
 
  bool getWithIsotopeScattering() const;
 
  Eigen::VectorXd getMasses();
  Eigen::VectorXd getIsotopeCouplings();
 
  double getEeFermiLiquidCoefficient() const; 
  double getBoundaryLength() const;
 
  // EPA:
  std::string getEpaFileName();
  double getMinChemicalPotential() const;
  double getMaxChemicalPotential() const;
  double getDeltaChemicalPotential() const;
  double getMinTemperature() const;
  double getMaxTemperature() const;
  double getDeltaTemperature() const;
  double getEpaEnergyRange() const;
  double getEpaEnergyStep() const;
  double getEFermiRange() const;
 
  void setupFromInput(const std::string &fileName);
 
  void printInputSummary(const std::string &fileName);
 
  void inputSanityCheck();
 
  Eigen::VectorXi getCoreElectrons();
  void setCoreElectrons(const Eigen::VectorXi &x);
 
  bool getDistributedElPhCoupling() const;
  void setDistributedElPhCoupling(const bool &x);
 
  int getHdf5ElPhFileFormat() const;
  void setHdf5ElPhFileFormat(const int &x);
 
  std::string getWsVecFileName() const;
  void setWsVecFileName(const std::string& x);
 
  bool getUseDragTerms() const;
  void setUseDragTerms(const bool &x);
  bool getEnforceDetailedBalance() const;
  void setEnforceDetailedBalance(const bool &x);
 
  // relaxons variables
 
  bool getSymmetrizeMatrix() const;
  void setSymmetrizeMatrix(const bool &x);
 
  bool getUseUpperTriangle() const;
  void setUseUpperTriangle(const bool &x);
 
  int getNumRelaxonsEigenvalues() const;
  void setNumRelaxonsEigenvalues(const int &x);
 
  bool getCheckNegativeRelaxons() const;
  bool setCheckNegativeRelaxons() const;
 
  bool getEnforcePositiveSemiDefinite() const;
  void setEnforcePositiveSemiDefinite(const bool &x);
 
};
 
#endif