CISLinearResponseTimeDependentCalculator.h

Go to the documentation of this file.

#ifndef SPARROW_CISLINEARRESPONSETIMEDEPENDENTCALCULATOR_H
#define SPARROW_CISLINEARRESPONSETIMEDEPENDENTCALCULATOR_H

#include "CISSigmaVectorEvaluator.h"
#include <Core/Interfaces/CalculatorWithReference.h>
#include <Sparrow/Implementations/TimeDependent/LinearResponseCalculator.h>
#include <Utils/CalculatorBasics.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;
namespace LcaoUtils {
class ElectronicOccupation;
}
enum class SpinTransition;
} // namespace Utils
namespace Sparrow {

class NDDOMethodWrapper;

class CISLinearResponseTimeDependentCalculator final : public LinearResponseCalculator {
 public:
  constexpr static const char* model = "CIS-NDDO";
  CISLinearResponseTimeDependentCalculator();
  ~CISLinearResponseTimeDependentCalculator() final = default;

  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 setExcitedStatesParam(Utils::Reference restrictedness, Utils::SpinTransition spinBlock);
  void prepareIntegralScreening();
  void checkMemoryRequirement(int excitationsDim, int numberOfEnergyLevels);
  template<Utils::Reference restrictedness>
  void generateTransitionDipoleMoments(Utils::ElectronicTransitionResult& excitedStatesResults, const CISData& cisData,
                                       Utils::SpinTransition spinBlock) const;

  std::shared_ptr<NDDOMethodWrapper> nddoMethod_;
  std::unique_ptr<Utils::Settings> settings_;
  std::unique_ptr<CISData> cisData_;
  std::shared_ptr<GuessSpecifier> guess_;
  std::vector<std::multimap<double, int, std::greater<double>>> integralsThresholds_;
  std::vector<int> orderMap_;
  ExcitedStatesParam excitedStatesParam_{1., 1., 1.};
  Utils::Results results_;
};
} // namespace Sparrow
} // namespace Scine

#endif // SPARROW_CISLINEARRESPONSETIMEDEPENDENTCALCULATOR_H