LibintInterfacer.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/ScalarBasis/GTOShell.hpp"
#include "Basis/ScalarBasis/ShellSet.hpp"
#include "Molecule/Molecule.hpp"
#include "Operator/FirstQuantized/CoulombRepulsionOperator.hpp"
#include "Operator/FirstQuantized/ElectronicDipoleOperator.hpp"
#include "Operator/FirstQuantized/KineticOperator.hpp"
#include "Operator/FirstQuantized/NuclearAttractionOperator.hpp"
#include "Operator/FirstQuantized/OverlapOperator.hpp"
 
#include <boost/preprocessor.hpp>  // include preprocessor before libint to fix libint-boost bug
 
#include <libint2.hpp>
 
 
namespace GQCP {
 
 
class LibintInterfacer {
public:
    using libint_target_ptr_vec = libint2::Engine::target_ptr_vec;
 
 
private:
    // PRIVATE METHODS - SINGLETON
    LibintInterfacer();
 
    ~LibintInterfacer();
 
 
    // PRIVATE STRUCTS
    typedef struct {
    } empty;  // empty_pod is a private typedef for libint2::Engine, so we copy it over
 
 
public:
    // PUBLIC METHODS - SINGLETON
 
    static LibintInterfacer& get();
 
    LibintInterfacer(LibintInterfacer const& libint_communicator) = delete;
    void operator=(LibintInterfacer const& libint_communicator) = delete;
 
 
    /*
     *  MARK: Interfacing - std to libint
     */
 
    libint2::svector<double> interface(const std::vector<double>& vector) const;
 
 
    /*
     *  MARK: Interfacing - libint to std
     */
 
    std::vector<double> interface(const libint2::svector<double>& svector) const;
 
 
    // PUBLIC METHODS - INTERFACING (GQCP TO LIBINT)
 
    libint2::Atom interface(const Nucleus& nucleus) const;
 
    std::vector<libint2::Atom> interface(const std::vector<Nucleus>& nuclei) const;
 
    libint2::Shell interface(const GTOShell& shell) const;
 
    libint2::BasisSet interface(const ShellSet<GTOShell>& shellset) const;
 
 
    // PUBLIC METHODS - INTERFACING (LIBINT TO GQCP)
    std::vector<GTOShell> interface(const libint2::Shell& libint_shell, const std::vector<Nucleus>& nuclei, bool undo_renorm = true) const;
 
    std::vector<GTOShell> interface(const libint2::BasisSet& libint_basisset, const std::vector<Nucleus>& nuclei) const;
 
 
    // PUBLIC METHODS
 
    libint2::Engine createEngine(const CoulombRepulsionOperator& op, const size_t max_nprim, const size_t max_l) const;
 
    libint2::Engine createEngine(const ElectronicDipoleOperator& op, const size_t max_nprim, const size_t max_l) const;
 
    libint2::Engine createEngine(const KineticOperator& op, const size_t max_nprim, const size_t max_l) const;
 
    libint2::Engine createEngine(const NuclearAttractionOperator& op, const size_t max_nprim, const size_t max_l) const;
 
    libint2::Engine createEngine(const OverlapOperator& op, const size_t max_nprim, const size_t max_l) const;
 
    size_t numberOfShells(const libint2::Shell& libint_shell) const;
 
    size_t numberOfShells(const libint2::BasisSet& libint_basisset) const;
 
    void undoRenorm(libint2::Shell& libint_shell) const;
};
 
 
}  // namespace GQCP