IntegralEngine.hpp

Go to the documentation of this file.

// This file is part of GQCG-GQCP.
//
// Copyright (C) 2017-2020  the GQCG developers
//
// GQCG-GQCP is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GQCG-GQCP is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GQCG-GQCP.  If not, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
 
#include "Basis/Integrals/Interfaces/LibcintOneElectronIntegralEngine.hpp"
#include "Basis/Integrals/Interfaces/LibcintTwoElectronIntegralEngine.hpp"
#include "Basis/Integrals/Interfaces/LibintOneElectronIntegralEngine.hpp"
#include "Basis/Integrals/Interfaces/LibintTwoElectronIntegralEngine.hpp"
#include "Basis/Integrals/OneElectronIntegralEngine.hpp"
#include "Basis/Integrals/Primitive/PrimitiveAngularMomentumIntegralEngine.hpp"
#include "Basis/Integrals/Primitive/PrimitiveCanonicalKineticEnergyIntegralEngine.hpp"
#include "Basis/Integrals/Primitive/PrimitiveCoulombRepulsionIntegralEngine.hpp"
#include "Basis/Integrals/Primitive/PrimitiveElectronicDipoleIntegralEngine.hpp"
#include "Basis/Integrals/Primitive/PrimitiveElectronicQuadrupoleIntegralEngine.hpp"
#include "Basis/Integrals/Primitive/PrimitiveLinearMomentumIntegralEngine.hpp"
#include "Basis/Integrals/Primitive/PrimitiveNuclearAttractionIntegralEngine.hpp"
#include "Basis/Integrals/Primitive/PrimitiveOverlapIntegralEngine.hpp"
#include "Basis/Integrals/TwoElectronIntegralEngine.hpp"
#include "Utilities/aliases.hpp"
 
 
namespace GQCP {
 
 
class IntegralEngine {
public:
    /*
     *  MARK: GQCP ("In-house") integral engines
     * 
     *  These integral engines can only calculate integrals over Cartesian d-shells, not over spherical d-shells.
     */
 
    template <typename Shell>
    static auto InHouse(const OverlapOperator& op) -> OneElectronIntegralEngine<PrimitiveOverlapIntegralEngine<Shell>> {
 
        return OneElectronIntegralEngine<PrimitiveOverlapIntegralEngine<Shell>>(PrimitiveOverlapIntegralEngine<Shell>());
    }
 
 
    template <typename Shell>
    static auto InHouse(const ElectronicDipoleOperator& op) -> OneElectronIntegralEngine<PrimitiveElectronicDipoleIntegralEngine<Shell>> {
 
        return OneElectronIntegralEngine<PrimitiveElectronicDipoleIntegralEngine<Shell>>(PrimitiveElectronicDipoleIntegralEngine<Shell>(op));
    }
 
 
    template <typename Shell>
    static auto InHouse(const LinearMomentumOperator& op) -> OneElectronIntegralEngine<PrimitiveLinearMomentumIntegralEngine<Shell>> {
 
        return OneElectronIntegralEngine<PrimitiveLinearMomentumIntegralEngine<Shell>>(PrimitiveLinearMomentumIntegralEngine<Shell>());
    }
 
 
    template <typename Shell>
    static auto InHouse(const KineticOperator& op) -> OneElectronIntegralEngine<PrimitiveCanonicalKineticEnergyIntegralEngine<Shell>> {
 
        return OneElectronIntegralEngine<PrimitiveCanonicalKineticEnergyIntegralEngine<Shell>>(PrimitiveCanonicalKineticEnergyIntegralEngine<Shell>());
    }
 
 
    template <typename Shell>
    static auto InHouse(const AngularMomentumOperator& op) -> OneElectronIntegralEngine<PrimitiveAngularMomentumIntegralEngine<Shell>> {
 
        return OneElectronIntegralEngine<PrimitiveAngularMomentumIntegralEngine<Shell>>(PrimitiveAngularMomentumIntegralEngine<Shell>(op));
    }
 
 
    template <typename Shell>
    static auto InHouse(const ElectronicQuadrupoleOperator& op) -> OneElectronIntegralEngine<PrimitiveElectronicQuadrupoleIntegralEngine<Shell>> {
 
        return OneElectronIntegralEngine<PrimitiveElectronicQuadrupoleIntegralEngine<Shell>>(PrimitiveElectronicQuadrupoleIntegralEngine<Shell>(op));
    }
 
 
    template <typename Shell>
    static auto InHouse(const NuclearAttractionOperator& op) -> OneElectronIntegralEngine<PrimitiveNuclearAttractionIntegralEngine<Shell>> {
 
        return OneElectronIntegralEngine<PrimitiveNuclearAttractionIntegralEngine<Shell>>(PrimitiveNuclearAttractionIntegralEngine<Shell>(op));
    };
 
 
    template <typename Shell>
    static auto InHouse(const CoulombRepulsionOperator& op) -> TwoElectronIntegralEngine<PrimitiveCoulombRepulsionIntegralEngine<Shell>> {
 
        return TwoElectronIntegralEngine<PrimitiveCoulombRepulsionIntegralEngine<Shell>>(PrimitiveCoulombRepulsionIntegralEngine<Shell>());
    }
 
 
    /*
     *  LIBINT
     */
 
    static auto Libint(const CoulombRepulsionOperator& op, const size_t max_nprim, const size_t max_l) -> LibintTwoElectronIntegralEngine<CoulombRepulsionOperator::NumberOfComponents>;
 
    static auto Libint(const ElectronicDipoleOperator& op, const size_t max_nprim, const size_t max_l) -> LibintOneElectronIntegralEngine<ElectronicDipoleOperator::NumberOfComponents>;
 
    static auto Libint(const NuclearAttractionOperator& op, const size_t max_nprim, const size_t max_l) -> LibintOneElectronIntegralEngine<NuclearAttractionOperator::NumberOfComponents>;
 
    static auto Libint(const KineticOperator& op, const size_t max_nprim, const size_t max_l) -> LibintOneElectronIntegralEngine<KineticOperator::NumberOfComponents>;
 
    static auto Libint(const OverlapOperator& op, const size_t max_nprim, const size_t max_l) -> LibintOneElectronIntegralEngine<OverlapOperator::NumberOfComponents>;
 
 
    /*
     *  LIBCINT
     */
 
    static auto Libcint(const CoulombRepulsionOperator& op, const ShellSet<GTOShell>& shell_set) -> LibcintTwoElectronIntegralEngine<GTOShell, CoulombRepulsionOperator::NumberOfComponents, double>;
 
    static auto Libcint(const ElectronicDipoleOperator& op, const ShellSet<GTOShell>& shell_set) -> LibcintOneElectronIntegralEngine<GTOShell, ElectronicDipoleOperator::NumberOfComponents, double>;
 
    static auto Libcint(const NuclearAttractionOperator& op, const ShellSet<GTOShell>& shell_set) -> LibcintOneElectronIntegralEngine<GTOShell, NuclearAttractionOperator::NumberOfComponents, double>;
 
    static auto Libcint(const KineticOperator& op, const ShellSet<GTOShell>& shell_set) -> LibcintOneElectronIntegralEngine<GTOShell, KineticOperator::NumberOfComponents, double>;
 
    static auto Libcint(const OverlapOperator& op, const ShellSet<GTOShell>& shell_set) -> LibcintOneElectronIntegralEngine<GTOShell, OverlapOperator::NumberOfComponents, double>;
};
 
 
}  // namespace GQCP