OrbitalSpace.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/SpinorBasis/OccupationType.hpp"
#include "Mathematical/Representation/ImplicitMatrixSlice.hpp"
#include "Mathematical/Representation/ImplicitRankFourTensorSlice.hpp"
 
#include <cstdlib>
#include <map>
#include <string>
#include <vector>
 
 
namespace GQCP {
 
 
class OrbitalSpace {
private:
    std::vector<size_t> occupied_indices;  // the indices of the orbitals that are considered occupied by the electrons
    std::vector<size_t> active_indices;    // the indices of the orbitals that are considered 'active', i.e. those spinor indices that are occupied in some set of configurations but not in others
    std::vector<size_t> virtual_indices;   // the indices of the orbitals that are considered virtual (i.e. unoccupied) by the electrons
 
    std::vector<size_t> all_indices;
 
 
public:
    // CONSTRUCTORS
 
    OrbitalSpace(const std::vector<size_t>& occupied_indices, const std::vector<size_t>& active_indices, const std::vector<size_t>& virtual_indices);
 
    OrbitalSpace(const std::vector<size_t>& occupied_indices, const std::vector<size_t>& virtual_indices);
 
 
    // NAMED CONSTRUCTORS
 
    static OrbitalSpace Implicit(const std::map<OccupationType, size_t>& occupation_type_numbers);
 
 
    // PUBLIC METHODS
 
    template <typename Scalar>
    ImplicitMatrixSlice<Scalar> createRepresentableObjectFor(const OccupationType row_type, const OccupationType column_type, const MatrixX<Scalar>& M) const {
 
        // Prepare the necessary members for ImplicitMatrixSlice.
        const auto row_indices = this->indices(row_type);
        const auto column_indices = this->indices(column_type);
 
        return ImplicitMatrixSlice<Scalar>::FromIndices(row_indices, column_indices, M);
    }
 
 
    template <typename Scalar>
    ImplicitRankFourTensorSlice<Scalar> createRepresentableObjectFor(const OccupationType axis1_type, const OccupationType axis2_type, const OccupationType axis3_type, const OccupationType axis4_type, const Tensor<Scalar, 4>& T) const {
 
        // Prepare the necessary members for ImplicitRankFourTensor.
        const auto axis1_indices = this->indices(axis1_type);
        const auto axis2_indices = this->indices(axis2_type);
        const auto axis3_indices = this->indices(axis3_type);
        const auto axis4_indices = this->indices(axis4_type);
 
        return ImplicitRankFourTensorSlice<Scalar>::FromIndices(axis1_indices, axis2_indices, axis3_indices, axis4_indices, T);
    }
 
 
    std::string description() const;
 
    const std::vector<size_t>& indices() const { return this->all_indices; }
 
    const std::vector<size_t>& indices(const OccupationType type) const;
 
    template <typename Scalar>
    ImplicitMatrixSlice<Scalar> initializeRepresentableObjectFor(const OccupationType row_type, const OccupationType column_type) const {
 
        // Prepare the necessary members for the other method.
        const auto rows = this->numberOfOrbitals(row_type);
        const auto columns = this->numberOfOrbitals(column_type);
 
        const MatrixX<Scalar> M = MatrixX<Scalar>::Zero(rows, columns);
 
        return this->createRepresentableObjectFor<Scalar>(row_type, column_type, M);
    }
 
 
    template <typename Scalar>
    ImplicitRankFourTensorSlice<Scalar> initializeRepresentableObjectFor(const OccupationType axis1_type, const OccupationType axis2_type, const OccupationType axis3_type, const OccupationType axis4_type) const {
 
        // Prepare the necessary members for the other method.
        const auto axis1_dimension = static_cast<long>(this->numberOfOrbitals(axis1_type));  // need static_cast for Tensor
        const auto axis2_dimension = static_cast<long>(this->numberOfOrbitals(axis2_type));
        const auto axis3_dimension = static_cast<long>(this->numberOfOrbitals(axis3_type));
        const auto axis4_dimension = static_cast<long>(this->numberOfOrbitals(axis4_type));
 
        Tensor<Scalar, 4> T {axis1_dimension, axis2_dimension, axis3_dimension, axis4_dimension};
        T.setZero();
 
        return this->createRepresentableObjectFor(axis1_type, axis2_type, axis3_type, axis4_type, T);
    }
 
 
    bool isIndex(const OccupationType type, const size_t p) const;
 
    size_t numberOfExcitations(const OccupationType from, const OccupationType to) const;
 
    size_t numberOfOrbitals() const { return this->indices().size(); }
 
    size_t numberOfOrbitals(const OccupationType type) const { return this->indices(type).size(); }
};
 
 
}  // namespace GQCP