GTOShell.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 "Mathematical/Functions/CartesianGTO.hpp"
#include "Mathematical/Functions/EvaluableLinearCombination.hpp"
#include "Molecule/Nucleus.hpp"
 
 
namespace GQCP {
 
 
class GTOShell {
public:
    // The type of primitive that underlies this shell.
    using Primitive = CartesianGTO;
 
    // The type of basis function that this shell can produce.
    using BasisFunction = EvaluableLinearCombination<double, Primitive>;
 
 
private:
    // If this shell is considered to be 'pure', i.e. a spherical shell is pure, a Cartesian shell is not pure.
    bool pure;
 
    // If the normalization factors of the primitives are embedded in the contraction coefficients.
    bool are_embedded_normalization_factors_of_primitives;
 
    // If the total normalization factor of the contracted GTO is already embedded in the contraction coefficients.
    bool normalized;
 
    // The angular momentum of the shell, i.e. the sum of the Cartesian exponents of this shell.
    size_t l;
 
    // The nucleus on which the shell is centered.
    Nucleus m_nucleus;
 
    // The Gaussian exponents for this shell, i.e. the exponents for the exponential. These are shared for every contraction.
    std::vector<double> gaussian_exponents;
 
    // The contraction coefficients for this shell.
    std::vector<double> contraction_coefficients;
 
 
public:
    /*
     *  MARK: Constructors
     */
 
    GTOShell(const size_t l, const Nucleus& nucleus, const std::vector<double>& gaussian_exponents, const std::vector<double>& contraction_coefficients, const bool pure = true, const bool are_embedded_normalization_factors_of_primitives = false, const bool is_normalized = false);
 
 
    /*
     *  MARK: Shell characteristics
     */
 
    size_t angularMomentum() const { return this->l; }
 
    const std::vector<double>& gaussianExponents() const { return this->gaussian_exponents; }
 
    bool isPure() const { return this->pure; }
 
    const Nucleus& nucleus() const { return this->m_nucleus; }
 
    bool operator==(const GTOShell& rhs) const;
 
 
    /*
     *  MARK: Normalization
     */
 
    bool isNormalized() const { return this->normalized; }
 
    void embedNormalizationFactor();
 
    bool areEmbeddedNormalizationFactorsOfPrimitives() const { return this->are_embedded_normalization_factors_of_primitives; }
 
    void embedNormalizationFactorsOfPrimitives();
 
    void unEmbedNormalizationFactorsOfPrimitives();
 
 
    /*
     *  MARK: Contractions
     */
 
    const std::vector<double>& contractionCoefficients() const { return this->contraction_coefficients; }
 
    size_t contractionSize() const { return this->contraction_coefficients.size(); }
 
 
    /*
     *  MARK: Basis functions
     */
 
    size_t numberOfBasisFunctions() const;
 
    std::vector<CartesianExponents> generateCartesianExponents() const;
 
    std::vector<BasisFunction> basisFunctions() const;
};
 
 
}  // namespace GQCP