TDHFbasis.hpp

#pragma once
#include "CorePolarisation.hpp"
#include "TDHF.hpp"
#include <vector>
class DiracSpinor;
namespace DiracOperator {
class TensorOperator;
}
 
namespace ExternalField {
 
 
class TDHFbasis final : public TDHF {
public:
  TDHFbasis(const DiracOperator::TensorOperator *const h,
            const HF::HartreeFock *const hf,
            const std::vector<DiracSpinor> &basis);
 
private:
  const std::vector<DiracSpinor> m_basis; // store copy?
 
public:
  virtual void solve_core(const double omega, int max_its = 100,
                          const bool print = true) override final;
 
  virtual Method method() const override final { return Method::basis; }
 
  DiracSpinor form_dPsi(const DiracSpinor &Fv, const double omega,
                        dPsiType XorY, const int kappa_beta,
                        const std::vector<DiracSpinor> &spectrum,
                        StateType st = StateType::ket,
                        bool incl_dV = true) const;
 
  std::vector<DiracSpinor> form_dPsis(const DiracSpinor &Fv, const double omega,
                                      dPsiType XorY,
                                      const std::vector<DiracSpinor> &spectrum,
                                      StateType st = StateType::ket,
                                      bool incl_dV = true) const;
 
public:
  TDHFbasis &operator=(const TDHFbasis &) = delete;
  TDHFbasis(const TDHFbasis &) = default;
  ~TDHFbasis() = default;
};
 
} // namespace ExternalField