fundamental_operator_set.hpp

Go to the documentation of this file.

// Copyright (c) 2015-2018 Commissariat à l'énergie atomique et aux énergies alternatives (CEA)
// Copyright (c) 2015-2018 Centre national de la recherche scientifique (CNRS)
// Copyright (c) 2018-2022 Simons Foundation
// Copyright (c) 2015-2016 Igor Krivenko
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You may obtain a copy of the License at
//     https://www.gnu.org/licenses/gpl-3.0.txt
//
// Authors: Michel Ferrero, Igor Krivenko, Olivier Parcollet, Nils Wentzell

 
#pragma once
 
#include "../gfs/block/gf_struct.hpp"
#include "../utility/dressed_iterator.hpp"
#include "../utility/exceptions.hpp"
 
#include <h5/h5.hpp>
#include <itertools/itertools.hpp>
 
#include <algorithm>
#include <array>
#include <iterator>
#include <set>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>
 
namespace triqs::hilbert_space {


  using indices_t = std::vector<std::variant<long, std::string, double, std::array<long, 3>>>;

  using triqs::gfs::gf_struct_t;

  std::string format_indices(indices_t const &alpha, std::string_view sep = ",", std::string_view prefix = "", std::string_view suffix = "");

  class fundamental_operator_set {
    public:
    using indices_t = triqs::hilbert_space::indices_t;

    using data_t = std::vector<indices_t>;
 
    private:
    // Constructor for a vector of vector of strings (only used in h5_read_attribute).
    fundamental_operator_set(std::vector<std::vector<std::string>> const &);
 
    public:
    fundamental_operator_set() = default;

    fundamental_operator_set(std::vector<int> const &v) {
      for (int i = 0; i < v.size(); ++i)
        for (int j = 0; j < v[i]; ++j) insert(i, j);
    }

    template <typename IndexType> fundamental_operator_set(std::set<IndexType> const &A) {
      for (auto const &alpha : A) insert(alpha);
    }

    explicit fundamental_operator_set(data_t v) : idxs_(std::move(v)) {}

    fundamental_operator_set(gf_struct_t const &gf_struct) {
      for (auto const &[blname, blsize] : gf_struct)
        for (auto i : itertools::range(blsize)) insert(blname, i);
    }

    explicit operator data_t() const { return idxs_; }

    void insert_from_indices_t(indices_t const &alpha) {
      if (!has_indices(alpha)) idxs_.push_back(alpha);
    }

    template <typename... Bs> void insert(Bs const &...betas) { insert_from_indices_t(indices_t{betas...}); }

    [[nodiscard]] auto size() const { return static_cast<int>(idxs_.size()); }

    [[nodiscard]] bool has_indices(indices_t const &alpha) const { return std::ranges::find(idxs_, alpha) != idxs_.end(); }

    [[nodiscard]] auto operator[](indices_t const &alpha) const {
      auto it = std::ranges::find(idxs_, alpha);
      if (it == idxs_.end()) {
        TRIQS_RUNTIME_ERROR << "Error in fundamental_operator_set::operator[]: Operator with indices (" << format_indices(alpha)
                            << ") does not belong to this fundamental set!";
      }
      return std::distance(idxs_.begin(), it);
    }

    bool operator==(fundamental_operator_set const &fops) const { return idxs_ == fops.idxs_; }

    [[nodiscard]] data_t const &data() const { return idxs_; }
 
    private:
    // Helper class for the creation of the const iterator.
    using _enum_iterator = decltype(itertools::enumerate(std::declval<data_t>()).cbegin());
    struct _cdress {
      indices_t const &index; // NOLINT
      int linear_index;
      _cdress(_enum_iterator _it) : index(std::get<1>(*_it)), linear_index(static_cast<int>(std::get<0>(*_it))) {}
    };
 
    public:
    using const_iterator = triqs::utility::dressed_iterator<_enum_iterator, _cdress>;

    [[nodiscard]] const_iterator begin() const noexcept { return itertools::enumerate(idxs_).begin(); }

    [[nodiscard]] const_iterator cbegin() const noexcept { return itertools::enumerate(idxs_).cbegin(); }

    [[nodiscard]] auto end() const noexcept { return itertools::enumerate(idxs_).end(); }

    [[nodiscard]] auto cend() const noexcept { return itertools::enumerate(idxs_).cend(); }

    friend void h5_write_attribute(h5::object obj, std::string const &name, fundamental_operator_set const &fops);

    friend void h5_read_attribute(h5::object obj, std::string const &name, fundamental_operator_set &fops);
 
    private:
    data_t idxs_ = {};
  };

 
} // namespace triqs::hilbert_space