ClusterSinglesDoublesAlgorithm.hpp

Go to the documentation of this file.

#ifndef CLUSTER_SINGLES_DOUBLES_ALGORITHM_DEFINED
#define CLUSTER_SINGLES_DOUBLES_ALGORITHM_DEFINED
 
#include <algorithms/Algorithm.hpp>
#include <math/FockVector.hpp>
#include <DryTensor.hpp>
#include <util/SharedPointer.hpp>
 
#include <util/Tensor.hpp>
 
#include <string>
#include <vector>
 
namespace sisi4s {
class ClusterSinglesDoublesAlgorithm : public Algorithm {
public:
  ClusterSinglesDoublesAlgorithm(std::vector<Argument> const &argumentList);
  virtual ~ClusterSinglesDoublesAlgorithm();
  virtual void run();
 
  // TODO: dryRun
 
  virtual std::string getAbbreviation() = 0;
 
  static int constexpr DEFAULT_MAX_ITERATIONS = 16;
  static double constexpr DEFAULT_ENERGY_CONVERGENCE = 1E-6;
  static double constexpr DEFAULT_AMPLITUDES_CONVERGENCE = 1E-5;
 
  static double constexpr DEFAULT_LEVEL_SHIFT = 0.0;
 
protected:
  template <typename F>
  F run();
 
  virtual PTR(FockVector<double>)
  getResiduum(const int iteration,
              const PTR(const FockVector<double>) &amplitudes) = 0;
 
  virtual PTR(FockVector<complex>)
  getResiduum(const int iteration,
              const PTR(const FockVector<complex>) &amplitudes) = 0;
 
  template <typename F>
  F getEnergy(const PTR(const FockVector<F>) &amplitdues);
 
  template <typename F>
  void
  estimateAmplitudesFromResiduum(const PTR(FockVector<F>) &residuum,
                                 const PTR(const FockVector<F>) &amplitudes);
 
  template <typename F>
  void calculateExcitationEnergies(Tensor<F> &D, const std::string &indices);
 
  template <typename F>
  void dryAmplitudesFromResiduum(sisi4s::DryTensor<F> &R);
 
  template <typename F>
  PTR(FockVector<F>)
  createAmplitudes(std::vector<std::string> amplitudeNames,
                   std::vector<std::vector<TensorIndex>> amplitudeLens,
                   std::vector<std::string> amplitudeIndices);
 
  template <typename F>
  void storeAmplitudes(const PTR(const FockVector<F>) &amplitudes,
                       std::vector<std::string> names);
 
  Tensor<double> *
  sliceCoupledCoulombIntegrals(const PTR(const FockVector<double>) &amplitudes,
                               int a,
                               int b,
                               int integralsSliceSize);
 
  Tensor<complex> *
  sliceCoupledCoulombIntegrals(const PTR(const FockVector<complex>) &amplitudes,
                               int a,
                               int b,
                               int integralsSliceSize);
 
  Tensor<double> *sliceAmplitudesFromCoupledCoulombFactors(
      const PTR(const FockVector<double>) &amplitudes,
      int a,
      int b,
      int factorsSliceSize);
  Tensor<complex> *sliceAmplitudesFromCoupledCoulombFactors(
      const PTR(const FockVector<complex>) &amplitudes,
      int a,
      int b,
      int factorsSliceSize);
 
  template <typename F>
  void sliceIntoResiduum(Tensor<F> &Rxyij, int a0, int b0, Tensor<F> &Rabij);
 
  std::string getCapitalizedAbbreviation();
 
  std::string getDataName(const std::string &type, const std::string &data);
};
} // namespace sisi4s
 
#endif