SpinResolvedBase.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 "QuantumChemical/Spin.hpp"
 
#include <stdexcept>
 
#include <array>
#include <vector>
 
 
namespace GQCP {
 
 
template <typename _Of, typename _Derived>
class SpinResolvedBase {
public:
    // The type of the alpha- and beta-objects. The name 'Of' is chosen for a natural reading `SpinResolvedBase<_Of, _Derived>`.
    using Of = _Of;
 
    // The type that derives from this type, given as a template argument, enabling CRTP and compile-time polymorphism.
    using Derived = _Derived;
 
    // The type of 'this'.
    using Self = SpinResolvedBase<Of, Derived>;
 
 
private:
    // The alpha-object.
    Of m_alpha;
 
    // The beta-object.
    Of m_beta;
 
 
public:
    /*
     *  MARK: Constructors
     */
 
    SpinResolvedBase(const Of& alpha, const Of& beta) :
        m_alpha {alpha},
        m_beta {beta} {}
 
 
    SpinResolvedBase(const std::vector<Of>& both) :
        SpinResolvedBase(both[0], both[1]) {
 
        if (both.size() != 2) {
            throw std::invalid_argument("SpinResolvedBase(const std::vector<Of>&): The given vector does not have exactly two elements.");
        }
    }
 
 
    SpinResolvedBase(const std::array<Of, 2>& both) :
        SpinResolvedBase(both[0], both[1]) {}
 
 
    SpinResolvedBase(const std::initializer_list<Of>& both) :
        SpinResolvedBase(std::vector<Of>(both)) {}
 
 
    /*
     *  MARK: Named constructors
     */
 
    static Derived FromEqual(const Of& equal) {
        return Derived {equal, equal};
    }
 
 
    /*
     *  MARK: Accessing spin components
     */
 
    const Of& alpha() const { return this->m_alpha; }
 
    Of& alpha() { return this->m_alpha; }
 
    const Of& beta() const { return this->m_beta; }
 
    Of& beta() { return this->m_beta; }
 
    const Of& component(const Spin sigma) const {
 
        switch (sigma) {
        case Spin::alpha: {
            return this->alpha();
            break;
        }
 
        case Spin::beta: {
            return this->beta();
            break;
        }
        }
    }
 
    Of& component(const Spin sigma) { return const_cast<Of&>(const_cast<const Self*>(this)->component(sigma)); }
};
 
 
}  // namespace GQCP