LibcintInterfacer.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 <functional>
 
 
extern "C" {
 
 
#include <cint.h>
 
 
/*
 *  The following functions are not inside the include header <cint.h>, so we should define them in order to be able to use them in our source code
 */
FINT cint1e_kin_cart(double* buf, const int* shls, const int* atm, int natm, const int* bas, int nbas, const double* env);   // kinetic energy
FINT cint1e_nuc_cart(double* buf, const int* shls, const int* atm, int natm, const int* bas, int nbas, const double* env);   // nuclear attraction energy
FINT cint1e_ovlp_cart(double* buf, const int* shls, const int* atm, int natm, const int* bas, int nbas, const double* env);  // overlap
FINT cint1e_r_cart(double* buf, const int* shls, const int* atm, int natm, const int* bas, int nbas, const double* env);     // dipole integrals
 
 
}  // extern "C"
 
 
namespace GQCP {
 
 
inline FINT cint2e_cart_const(double* buf, const int* shls, const int* atm, int natm, const int* bas, int nbas, const double* env, const CINTOpt* opt) {
    return cint2e_cart(buf, const_cast<int*>(shls), const_cast<int*>(atm), natm, const_cast<int*>(bas), nbas, const_cast<double*>(env), const_cast<CINTOpt*>(opt));
}
 
inline void cint2e_cart_optimizer_const(CINTOpt** opt, const int* atm, int natm, const int* bas, int nbas, const double* env) {
    cint2e_cart_optimizer(opt, const_cast<int*>(atm), natm, const_cast<int*>(bas), nbas, const_cast<double*>(env));
}
 
/*
 *  Aliases for functions that are used in Libcint
 */
 
using Libcint1eFunction = std::function<int(double*, const int*, const int*, int, const int*, int, const double*)>;
using Libcint2eFunction = std::function<int(double*, const int*, const int*, int, const int*, int, const double*, const CINTOpt*)>;
using Libcint2eOptimizerFunction = std::function<void(CINTOpt**, const int*, int, const int*, int, const double*)>;
 
 
/*
 *  Forward declarations
 */
 
namespace libcint {
 
 
class RawContainer;
 
 
}  // namespace libcint
 
 
class LibcintInterfacer {
public:
    // PUBLIC METHODS - INTERFACING
 
    libcint::RawContainer convert(const ShellSet<GTOShell>& shell_set) const;
 
    void setCommonOrigin(libcint::RawContainer& raw_container, const Vector<double, 3>& origin) const;
 
 
    //  PUBLIC METHODS - INTEGRAL FUNCTIONS
 
    Libcint1eFunction oneElectronFunction(const ElectronicDipoleOperator& op) const { return cint1e_r_cart; }
 
    Libcint1eFunction oneElectronFunction(const KineticOperator& op) const { return cint1e_kin_cart; }
 
    Libcint1eFunction oneElectronFunction(const NuclearAttractionOperator& op) const { return cint1e_nuc_cart; }
 
    Libcint1eFunction oneElectronFunction(const OverlapOperator& op) const { return cint1e_ovlp_cart; }
 
    Libcint2eFunction twoElectronFunction(const CoulombRepulsionOperator& op) const { return cint2e_cart_const; }
 
    Libcint2eOptimizerFunction twoElectronOptimizerFunction(const CoulombRepulsionOperator& op) const { return cint2e_cart_optimizer_const; }
};
 
 
namespace libcint {
 
 
static constexpr int ptr_common_orig = PTR_COMMON_ORIG;  // an offset for the origin of vector operators
static constexpr int ptr_env_start = PTR_ENV_START;      // an offset such that libcint can retrieve the correct index inside the environment, starts at 20
 
static constexpr int atm_slots = ATM_SLOTS;  // the number of 'slots' (i.e. 'members') for an atom
static constexpr int charge_of = CHARGE_OF;  // slot offset for atomic charge
static constexpr int ptr_coord = PTR_COORD;  // slot offset for a 'pointer' of the atom inside the libcint environment
 
 
static constexpr int bas_slots = BAS_SLOTS;  // the number of 'slots' (i.e. 'members') for a basis function
static constexpr int atom_of = ATOM_OF;      // slot offset for the corresponding atom in the basis function
static constexpr int ang_of = ANG_OF;        // slot offset for the angular momentum
static constexpr int nprim_of = NPRIM_OF;    // slot offset for the number of primitives inside the basis function
static constexpr int nctr_of = NCTR_OF;      // slot offset for the number of contractions
static constexpr int ptr_exp = PTR_EXP;      // slot offset for a 'pointer' to the exponents of the shell inside the libcint environment
static constexpr int ptr_coeff = PTR_COEFF;  // slot offset for a 'pointer' to the contraction coefficients inside the libcint environment
 
 
class RawContainer {
private:
    int natm;  // number of atoms
    int nbf;   // number of basis functions
    int nsh;   // the number of shells
 
    int* libcint_atm;     // information about the atoms
    int* libcint_bas;     // information about the basis functions
    double* libcint_env;  // a raw block of doubles in which libcint (probably) places intermediary calculations
 
 
public:
    /*
     *  CONSTRUCTORS
     */
 
    RawContainer(const size_t natm, const size_t nbf, const size_t nsh) :
        natm {static_cast<int>(natm)},
        nbf {static_cast<int>(nbf)},
        nsh {static_cast<int>(nsh)},
        libcint_atm {new int[this->natm * atm_slots]},
        libcint_bas {new int[this->nbf * bas_slots]},
        libcint_env {new double[10000]} {}
 
 
    /*
     *  DESTRUCTOR
     */
 
    ~RawContainer() {
        delete[] this->libcint_atm;
        delete[] this->libcint_bas;
        delete[] this->libcint_env;
    }
 
 
    /*
     *  PUBLIC METHODS
     */
 
    const int* atmData() const { return this->libcint_atm; }
 
    const int* basData() const { return this->libcint_bas; }
 
    const double* envData() const { return this->libcint_env; }
 
    int numberOfAtoms() const { return this->natm; }
 
    int numberOfBasisFunctions() const { return this->nbf; }
 
    int numberOfShells() const { return this->nsh; }
 
 
    /*
     *  FRIENDS
     */
    friend class GQCP::LibcintInterfacer;
};
 
 
}  // namespace libcint
}  // namespace GQCP