local_space.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <uni20/symmetry/qnum.hpp>
#include <uni20/symmetry/space.hpp>
 
#include <concepts>
#include <cstddef>
#include <initializer_list>
#include <ranges>
#include <span>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace uni20
{
 
class LocalSpace {
  public:
    explicit LocalSpace(Symmetry sym, std::string label = {}) : sym_(sym), label_(std::move(label))
    {
      this->verify_symmetry();
    }
 
    LocalSpace(Symmetry sym, std::initializer_list<QNum> qnums, std::string label = {})
        : LocalSpace(sym, std::move(label))
    {
      this->append_qnums(qnums);
    }
 
    template <std::ranges::input_range QNums>
      requires std::constructible_from<QNum, std::ranges::range_reference_t<QNums>>
    LocalSpace(Symmetry sym, QNums&& qnums, std::string label = {}) : LocalSpace(sym, std::move(label))
    {
      this->append_qnums(std::forward<QNums>(qnums));
    }
 
    explicit LocalSpace(QNumList const& qnums, std::string label = {}) : LocalSpace(qnums.symmetry(), std::move(label))
    {
      this->append_qnums(qnums);
    }
 
    auto symmetry() const -> Symmetry { return sym_; }
 
    auto size() const -> std::size_t { return qnums_.size(); }
 
    auto empty() const -> bool { return qnums_.empty(); }
 
    auto operator[](std::size_t index) const -> QNum const& { return qnums_[index]; }
 
    auto qnums() const -> std::span<QNum const> { return qnums_; }
 
    auto begin() const { return qnums_.begin(); }
 
    auto end() const { return qnums_.end(); }
 
    auto label() const -> std::string const& { return label_; }
 
    void set_label(std::string label) { label_ = std::move(label); }
 
    auto operator==(LocalSpace const& other) const -> bool = default;
 
  private:
    void verify_symmetry() const
    {
      if (!sym_.valid())
      {
        throw std::invalid_argument("LocalSpace requires a valid symmetry");
      }
    }
 
    template <std::ranges::input_range QNums> void append_qnums(QNums&& qnums)
    {
      for (auto&& input : qnums)
      {
        QNum q(std::forward<decltype(input)>(input));
        if (!q.valid() || q.symmetry() != sym_)
        {
          throw std::invalid_argument("LocalSpace state has the wrong symmetry");
        }
        qnums_.push_back(std::move(q));
      }
    }
 
    Symmetry sym_;
    std::vector<QNum> qnums_;
    std::string label_;
};
 
static_assert(SymmetrySpace<LocalSpace>);
 
} // namespace uni20