TDDFTBCalculator.h

Go to the documentation of this file.

#ifndef SPARROW_TDDFTBCALCULATOR_H
#define SPARROW_TDDFTBCALCULATOR_H

#include <Core/Interfaces/CalculatorWithReference.h>
#include <Sparrow/Implementations/TimeDependent/LinearResponseCalculator.h>
#include <Utils/CalculatorBasics.h>
#include <Utils/Math/IterativeDiagonalizer/SigmaVectorEvaluator.h>
#include <Utils/Math/IterativeDiagonalizer/SpinAdaptedEigenContainer.h>
#include <Utils/UniversalSettings/SettingsNames.h>
#include <Eigen/Core>
#include <Eigen/Sparse>
#include <chrono>
#include <memory>
#include <numeric>
namespace Scine {
namespace Core {
class Calculator;
} // namespace Core
namespace Utils {
class Settings;
class Results;
class Excitation;
class DipoleMatrix;
namespace LcaoUtils {
class ElectronicOccupation;
}
enum class SpinTransition;
} // namespace Utils
namespace Sparrow {

class DFTBMethodWrapper;
class TDDFTBData;
template<Utils::Reference restrictedness>
class OrderedInput;
template<Utils::Reference restrictedness>
class TDDFTBEigenvalueSolver;

class TDDFTBCalculator final : public LinearResponseCalculator {
 public:
  constexpr static const char* model = "TD-DFTB";
  TDDFTBCalculator();
  ~TDDFTBCalculator() final;

  Core::Calculator& getReferenceCalculator() final;
  const Core::Calculator& getReferenceCalculator() const final;
  void setReferenceCalculator(std::shared_ptr<Core::Calculator> method) final;
  void referenceCalculation() final;

  Utils::Results& results() final;
  const Utils::Results& results() const final;

  Utils::Settings& settings() final;
  const Utils::Settings& settings() const final;
  std::string name() const final;

  void applySettings() final;

  template<Utils::Reference restrictedness>
  Utils::ElectronicTransitionResult solve(Utils::SpinAdaptedContainer<restrictedness, Eigen::VectorXd> energyDifferenceVector,
                                          int numberOfEnergyLevels = 0, int initialSubspaceDimension = 0,
                                          Utils::SpinTransition spinBlock = Utils::SpinTransition::Singlet);

  const Utils::Results& calculate() final;

  void setGuess(std::shared_ptr<GuessSpecifier> guessVectorMatrix) final;
  auto getGuess() const -> std::shared_ptr<GuessSpecifier> final;

 private:
  void checkMemoryRequirement(int excitationsDim, int numberOfEnergyLevels);
  template<Utils::Reference restrictedness>
  void generateTransitionDipoleMoments(Utils::ElectronicTransitionResult& excitedStatesResults,
                                       const std::vector<Utils::Excitation>& excitations) const;
  auto isDFTB0(std::shared_ptr<DFTBMethodWrapper> method) const -> bool;

  template<Utils::Reference restrictedness>
  void evalImpl(Utils::SpinAdaptedElectronicTransitionResult& transitionResult,
                const Eigen::MatrixXd& transitionCharges, std::shared_ptr<Utils::DipoleMatrix> dipoleMatrix);
  template<Utils::Reference restrictedness>
  void solveEigenvalueProblem(Utils::SpinAdaptedElectronicTransitionResult& transitionResult,
                              const std::unique_ptr<TDDFTBEigenvalueSolver<restrictedness>>& solver, int numberOfRoots,
                              int initialSubspaceDimension);
  std::shared_ptr<DFTBMethodWrapper> dftbMethod_;
  std::shared_ptr<GuessSpecifier> guess_;
  std::unique_ptr<Utils::Settings> settings_;
  std::unique_ptr<TDDFTBData> tddftbData_;
  std::vector<int> orderMap_;
  std::vector<Utils::Excitation> excitations_;
  Utils::Results results_;
};
} // namespace Sparrow
} // namespace Scine

#endif // SPARROW_TDDFTBCALCULATOR_H