QmmmCalculator.h

Go to the documentation of this file.

#ifndef SWOOSE_QMMM_QMMMCALCULATOR_H
#define SWOOSE_QMMM_QMMMCALCULATOR_H

#include <Core/Interfaces/Calculator.h>
#include <Core/Interfaces/EmbeddingCalculator.h>
#include <Utils/CalculatorBasics.h>
#include <Utils/Technical/CloneInterface.h>
#include <algorithm>

namespace Scine {

namespace MolecularMechanics {
class MolecularMechanicsCalculator;
} // namespace MolecularMechanics

namespace Qmmm {

class QmmmCalculator : public Utils::CloneInterface<QmmmCalculator, Core::EmbeddingCalculator, Core::Calculator> {
 public:
  static constexpr const char* model = "QM-SFAM";
  QmmmCalculator();
  ~QmmmCalculator() override;
  QmmmCalculator(const QmmmCalculator& rhs);
  void setUnderlyingCalculators(std::vector<std::shared_ptr<Core::Calculator>> underlyingCalculators) override;
  void addUnderlyingSettings() override;
  std::vector<std::shared_ptr<Core::Calculator>> getUnderlyingCalculators() const override;
  void setStructure(const Utils::AtomCollection& structure) override;
  std::unique_ptr<Utils::AtomCollection> getStructure() const override;
  void modifyPositions(Utils::PositionCollection newPositions) override;
  const Utils::PositionCollection& getPositions() const override;
  void setRequiredProperties(const Utils::PropertyList& requiredProperties) override;
  Utils::PropertyList getRequiredProperties() const override;
  Utils::PropertyList possibleProperties() const override;
  const Utils::Results& calculate(std::string description) override;
  std::string name() const override;
  Utils::Settings& settings() override;
  const Utils::Settings& settings() const override;
  Utils::Results& results() override;
  const Utils::Results& results() const override;
  bool supportsMethodFamily(const std::string& methodFamily) const override;
  std::shared_ptr<Core::State> getState() const final;
  void loadState(std::shared_ptr<Core::State> /*state*/) final;
  bool allowsPythonGILRelease() const override {
    const auto underlyingCalculators = getUnderlyingCalculators();
    return std::all_of(underlyingCalculators.begin(), underlyingCalculators.end(),
                       [](const auto& c) { return c->allowsPythonGILRelease(); });
  };
  std::shared_ptr<MolecularMechanics::MolecularMechanicsCalculator> getMolecularMechanicsCalculator();
  std::shared_ptr<Core::Calculator> getQuantumMechanicsCalculator();

 private:
  void setStructureImpl(const Utils::AtomCollection& structure);
  void setUnderlyingCalculatorsImpl(std::vector<std::shared_ptr<Core::Calculator>> underlyingCalculators);
  void addUnderlyingSettingsImpl();
  void optimizeLinks();
  void handleElectrostaticEmbedding();
  void removeCalculatorSpecificSettings();
  /*
   * @brief Implementation of a calculation.
   */
  const Utils::Results& calculateImpl(std::string description);
  /*
   * @brief Implementation of a calculation where the QM calculation is not performed.
   */
  const Utils::Results& ignoreQmCalculateImpl(std::string description);
  /*
   * @brief Apply settings.
   */
  void applySettings();
  /*
   * @brief Apply settings to underlying calculators (QM and MM).
   */
  void applySettingsToUnderlyingCalculators();
  /*
   * @brief Eliminates those terms from the MM calculator which shall not be calculated at the MM level,
   *        but at the QM level instead.
   * @param reducedEnergyCalculation Whether the current calculation is part of a
   *                                 reduced QM/MM energy evaluation. Default: It is not.
   */
  void prepareTermsForMmCalculator(bool reducedEnergyCalculation = false);
  /*
   * @brief Sets the current log of this calculator to the underlying QM and MM calculators.
   */
  void setLogForUnderlyingCalculators();
  // The required properties.
  Utils::PropertyList requiredProperties_;
  // The settings.
  std::unique_ptr<Utils::Settings> settings_;
  // The results container.
  Utils::Results results_;
  // The structure of the full system
  Utils::AtomCollection structure_;
  // The structure of the QM region
  Utils::AtomCollection qmRegion_;
  // Vector containing the indices of the MM atoms close to the boundary (part of a cleft bond)
  std::vector<int> mmBoundaryAtoms_;
  // Vector containing the indices of the atoms in the QM region
  std::vector<int> listOfQmAtoms_;
  // QM calculator
  std::shared_ptr<Core::Calculator> qmCalculator_;
  // Flag for the case that the QM system spans the full system.
  bool mmAtomsLeft_ = true;
  /*
   * Whether an additional MM calculation is performed to evaluate the QM/MM energy
   * without any covalent and non-covalent contributions solely within the environment
   */
  bool calculateReducedQmMmEnergy_;
  // MM calculator
  std::shared_ptr<MolecularMechanics::MolecularMechanicsCalculator> mmCalculator_;
  // Whether electrostatic embedding shall be used (otherwise just mechanical embedding)
  bool electrostaticEmbedding_;
  // Whether to not perform the QM calculation.
  bool ignoreQm_;
  // File to which the QM region is written in XYZ format
  std::string qmRegionFile_;
  // The scheme for how to redistribute the charges close to the QM-MM boundary
  std::string chargeRedistributionScheme_;
  // Name of the point charges file
  static constexpr const char* pointChargesFilename_ = "environment_pointcharges.pc";
  bool turbomoleIsQmCalculator_ = false;
  /*
   * The following boolean keeps track of whether the SCF convergence setting for the QM calculator was already set,
   * because resetting it with every calculation (e.g., as part of an optimization) will result in a repeated
   * warning with some calculators (e.g., ORCA). The reason is that some calculators reset this setting internally
   * After calling setStructure(), this boolean will be reset to false again.
   *
   * Important note: This means that if one wants to reset the setting externally, setStructure() has to be recalled
   * so that the setting is passed on to the QM calculator.
   */
  bool scfConvCriterionIsSet_ = false;
  bool optimizeLinks_ = false;
};

} // namespace Qmmm
} // namespace Scine

#endif // SWOOSE_QMMM_QMMMCALCULATOR_H