ZeroOrderMatricesCalculator.h

Go to the documentation of this file.

#ifndef SPARROW_DFTB_ZEROORDERMATRICESCALCULATOR_H
#define SPARROW_DFTB_ZEROORDERMATRICESCALCULATOR_H

#include "DFTBCommon.h"
#include <Utils/DataStructures/MatrixWithDerivatives.h>
#include <Utils/Math/AutomaticDifferentiation/MethodsTypesHelper.h>
#include <Eigen/Core>

namespace Scine {

namespace Utils {
enum class DerivativeOrder;
class DensityMatrix;
class AtomsOrbitalsIndexes;
} // namespace Utils

namespace Sparrow {

namespace dftb {

class ZeroOrderMatricesCalculator {
 public:
  ZeroOrderMatricesCalculator(const Utils::ElementTypeCollection& elements, const Utils::PositionCollection& positions,
                              const Utils::AtomsOrbitalsIndexes& aoIndexes, const DFTBCommon::AtomicParameterContainer& atomicPar,
                              const DFTBCommon::DiatomicParameterContainer& diatomicPar,
                              const Utils::DensityMatrix& densityMatrix);
  void initializeH0S();
  void constructH0S(Utils::DerivativeOrder order);

  void initializeFockCalculator() {
  }
  void calculateFockMatrix(Utils::DerivativeOrder /*order*/) {
  }
  // For DFTB0, overlapDerivativeMultiplier is the energy-weighted density matrix.
  void addDerivatives(Utils::AutomaticDifferentiation::DerivativeContainerType<Utils::Derivative::First>& derivatives,
                      const Eigen::MatrixXd& overlapDerivativeMultiplier) const;
  void addDerivatives(Utils::AutomaticDifferentiation::DerivativeContainerType<Utils::Derivative::SecondAtomic>& derivatives,
                      const Eigen::MatrixXd& overlapDerivativeMultiplier) const;
  void addDerivatives(Utils::AutomaticDifferentiation::DerivativeContainerType<Utils::Derivative::SecondFull>& derivatives,
                      const Eigen::MatrixXd& overlapDerivativeMultiplier) const;

  // Correspond to functions from OverlapCalculator
  void calculateOverlap(Utils::DerivativeOrder highestRequiredOrder);
  const Utils::MatrixWithDerivatives& getOverlap() const;
  const Utils::MatrixWithDerivatives& getZeroOrderHamiltonian() const;
  void resetOverlap();

 private:
  template<Utils::DerivativeOrder O>
  void constructH0S();
  template<Utils::DerivativeOrder O>
  void constructPartOfH0S();
  template<Utils::Derivative O>
  void addDerivativesImpl(Utils::AutomaticDifferentiation::DerivativeContainerType<O>& derivatives,
                          const Eigen::MatrixXd& overlapDerivativeMultiplier) const;

  Utils::MatrixWithDerivatives zeroOrderHamiltonian_;
  Utils::MatrixWithDerivatives overlap_;
  const Utils::ElementTypeCollection& elements_;
  const Utils::PositionCollection& positions_;
  const Utils::AtomsOrbitalsIndexes& aoIndexes_;
  const DFTBCommon::AtomicParameterContainer& atomicPar_;
  const DFTBCommon::DiatomicParameterContainer& diatomicPar_;
  const Utils::DensityMatrix& densityMatrix_;
};

} // namespace dftb

} // namespace Sparrow
} // namespace Scine
#endif // SPARROW_DFTB_ZEROORDERMATRICESCALCULATOR_H