irregular_space.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <uni20/symmetry/block_sector.hpp>
#include <uni20/symmetry/space.hpp>
 
#include <algorithm>
#include <concepts>
#include <cstddef>
#include <initializer_list>
#include <numeric>
#include <ranges>
#include <span>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace uni20
{
 
class IrregularSpace {
  public:
    explicit IrregularSpace(Symmetry sym, std::string label = {}) : sym_(sym), label_(std::move(label))
    {
      this->verify_symmetry();
    }
 
    IrregularSpace(Symmetry sym, std::initializer_list<BlockSector> sectors, std::string label = {})
        : IrregularSpace(sym, std::move(label))
    {
      this->append_sectors(sectors);
    }
 
    template <std::ranges::input_range Sectors>
      requires std::constructible_from<BlockSector, std::ranges::range_reference_t<Sectors>>
    IrregularSpace(Symmetry sym, Sectors&& sectors, std::string label = {}) : IrregularSpace(sym, std::move(label))
    {
      this->append_sectors(std::forward<Sectors>(sectors));
    }
 
    auto symmetry() const -> Symmetry { return sym_; }
 
    auto size() const -> std::size_t { return sectors_.size(); }
 
    auto empty() const -> bool { return sectors_.empty(); }
 
    auto total_dim() const -> std::size_t
    {
      return std::accumulate(sectors_.begin(), sectors_.end(), std::size_t{0},
                             [](std::size_t total, BlockSector const& sector) { return total + sector.dim; });
    }
 
    auto contains(QNum q) const -> bool
    {
      this->verify_symmetry(q);
      return std::ranges::find(sectors_, q, &BlockSector::q) != sectors_.end();
    }
 
    auto operator[](std::size_t index) const -> BlockSector const& { return sectors_[index]; }
 
    auto sectors() const -> std::span<BlockSector const> { return sectors_; }
 
    auto begin() const { return sectors_.begin(); }
 
    auto end() const { return sectors_.end(); }
 
    auto label() const -> std::string const& { return label_; }
 
    void set_label(std::string label) { label_ = std::move(label); }
 
    auto operator==(IrregularSpace const& other) const -> bool = default;
 
  private:
    void verify_symmetry() const
    {
      if (!sym_.valid())
      {
        throw std::invalid_argument("IrregularSpace requires a valid symmetry");
      }
    }
 
    void verify_symmetry(QNum const& q) const
    {
      if (!q.valid() || q.symmetry() != sym_)
      {
        throw std::invalid_argument("IrregularSpace block has the wrong symmetry");
      }
    }
 
    template <std::ranges::input_range Sectors> void append_sectors(Sectors&& sectors)
    {
      for (auto&& input : sectors)
      {
        BlockSector sector(std::forward<decltype(input)>(input));
        this->verify_symmetry(sector.q);
        if (sector.dim == 0)
        {
          throw std::invalid_argument("IrregularSpace blocks must have positive dimension");
        }
        sectors_.push_back(std::move(sector));
      }
    }
 
    Symmetry sym_;
    std::vector<BlockSector> sectors_;
    std::string label_;
};
 
static_assert(SymmetrySpace<IrregularSpace>);
 
} // namespace uni20