DoublySpinResolvedBase.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 <array>
#include <vector>
 
 
namespace GQCP {
 
 
template <typename _Pure, typename _Mixed, typename _Derived>
class DoublySpinResolvedBase {
public:
    // The type that represents a 'pure' combination of spin components, i.e. the alpha-alpha or beta-beta type.
    using Pure = _Pure;
 
    // The type that represents a 'mixed' combination of spin components, i.e. the alpha-beta or beta-alpha type.
    using Mixed = _Mixed;
 
    // 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 = DoublySpinResolvedBase<Pure, Mixed, Derived>;
 
 
private:
    // The alpha-alpha-object.
    Pure aa;
 
    // The alpha-beta object.
    Mixed ab;
 
    // The beta-alpha object.
    Mixed ba;
 
    // The beta-beta object.
    Pure bb;
 
 
public:
    /*
     *  MARK: Constructors
     */
 
    DoublySpinResolvedBase(const Pure& aa, const Mixed& ab, const Mixed& ba, const Pure& bb) :
        aa {aa},
        ab {ab},
        ba {ba},
        bb {bb} {}
 
 
    /*
     *  MARK: Accessing spin components
     */
 
    const Pure& alphaAlpha() const { return this->aa; }
 
    Pure& alphaAlpha() { return this->aa; }
 
    const Mixed& alphaBeta() const { return this->ab; }
 
    Mixed& alphaBeta() { return this->ab; }
 
    const Mixed& betaAlpha() const { return this->ba; }
 
    Mixed& betaAlpha() { return this->ba; }
 
    const Pure& betaBeta() const { return this->bb; }
 
    Pure& betaBeta() { return this->bb; }
 
    const Pure& pureComponent(const Spin& sigma) const {
 
        if (sigma == Spin::alpha) {
            return this->aa;
        } else {
            return this->bb;
        }
    }
 
    Pure& pureComponent(const Spin& sigma) {
 
        if (sigma == Spin::alpha) {
            return this->aa;
        } else {
            return this->bb;
        }
    }
};
 
 
}  // namespace GQCP