GenericMethodWrapper.h

Go to the documentation of this file.

#ifndef SPARROW_GENERICMETHODWRAPPER_H
#define SPARROW_GENERICMETHODWRAPPER_H

/* External Includes */

#include <Core/Interfaces/Calculator.h>
#include <Core/Interfaces/WavefunctionOutputGenerator.h>
#include <Utils/CalculatorBasics.h>
#include <Utils/DataStructures/AtomicGtos.h>
#include <Utils/Settings.h>
#include <Utils/Technical/CloneInterface.h>
#include <string>
#include <unordered_map>

namespace Scine {
namespace Utils {
class LcaoMethod;
class DensityMatrix;
class DipoleMatrix;
class AdditiveElectronicContribution;
enum class Derivative;
} // namespace Utils
namespace Sparrow {

class DipoleMatrixCalculator;
class DipoleMomentCalculator;

class GenericMethodWrapper : public Utils::CloneInterface<Utils::Abstract<GenericMethodWrapper>, Core::Calculator>,
                             public Core::WavefunctionOutputGenerator {
 public:
  GenericMethodWrapper();
  ~GenericMethodWrapper() override;
  GenericMethodWrapper(const GenericMethodWrapper& rhs);
  void setStructure(const Utils::AtomCollection& structure) final;
  std::unique_ptr<Utils::AtomCollection> getStructure() const final;
  void modifyPositions(Utils::PositionCollection newPositions) final;
  const Utils::PositionCollection& getPositions() const final;
  void setRequiredProperties(const Utils::PropertyList& requiredProperties) final;
  Utils::PropertyList getRequiredProperties() const final;
  Utils::PropertyList possibleProperties() const override;
  const Utils::Results& calculate(std::string description) final;
  virtual Utils::DensityMatrix getDensityMatrixGuess() const = 0;
  Utils::Settings& settings() final;
  const Utils::Settings& settings() const final;
  Utils::Results& results() final;
  const Utils::Results& results() const final;

  virtual void addElectronicContribution(std::shared_ptr<Utils::AdditiveElectronicContribution> contribution) = 0;
  bool supportsMethodFamily(const std::string& methodFamily) const final;

  virtual Utils::LcaoMethod& getLcaoMethod() = 0;
  virtual const Utils::LcaoMethod& getLcaoMethod() const = 0;
  std::string getStoNGExpansionPath() const;
  std::unordered_map<int, Utils::AtomicGtos> getAtomicGtosMap() const;
  void generateWavefunctionInformation(const std::string& filename) final;
  void generateWavefunctionInformation(std::ostream& out) final;

  void loadState(std::shared_ptr<Core::State> state) override;
  std::shared_ptr<Core::State> getState() const final;

 protected:
  std::unique_ptr<Utils::Settings> settings_;
  Utils::Results results_;
  virtual void initialize() = 0;
  Utils::Derivative highestDerivativeRequired() const;
  virtual void assembleResults(const std::string& description);

  virtual bool successfulCalculation() const = 0;
  virtual bool canCalculateAnalyticalHessian() const;

  void checkBasicSettings();

  virtual void applySettings();
  virtual bool getZPVEInclusion() const = 0;

  virtual void calculateImpl(Utils::Derivative requiredDerivative) = 0;

  std::unique_ptr<DipoleMomentCalculator> dipoleCalculator_;
  std::unique_ptr<DipoleMatrixCalculator> dipoleMatrixCalculator_;
  Utils::PropertyList requiredProperties_;
};

} /* namespace Sparrow */
} /* namespace Scine */

#endif /* SPARROW_GENERICMETHODWRAPPER_H */