gf_const_view.hpp

Go to the documentation of this file.

// Copyright (c) 2019-2023 Simons Foundation
//
// 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, Olivier Parcollet, Nils Wentzell

 
#pragma once
 
#include "./gf.hpp"
#include "../../utility/concept_tools.hpp"
 
#include <itertools/itertools.hpp>
 
#include <array>
#include <utility>
 
namespace triqs::gfs {

  template <Mesh M, typename Target, typename Layout> class gf_const_view : is_view_tag, TRIQS_CONCEPT_TAG_NAME(GreenFunction) {
 
    using this_t = gf_const_view<M, Target, Layout>; // used in common code
 
    public:
    static constexpr bool is_view = true;

    static constexpr bool is_const = true;

    using mutable_view_type = gf_view<M, Target, Layout>;

    using const_view_type = gf_const_view<M, Target, Layout>;


    using view_type = gf_const_view<M, Target, Layout>;

    using regular_type = gf<M, Target>; // FIXME : find the Layout

    using real_t = gf_const_view<M, typename Target::real_t, Layout>;

    using complex_t = gf_const_view<M, typename Target::complex_t, Layout>;

    using target_t = Target;

    using mesh_t = M;

    using mesh_point_t = typename mesh_t::mesh_point_t;

    using mesh_index_t = typename mesh_t::index_t;

    using scalar_t = typename Target::scalar_t;

    static constexpr int arity = n_variables<M>;

    static constexpr int target_rank = Target::rank;

    static constexpr int data_rank = arity + Target::rank;

    using data_t = nda::basic_array_view<const scalar_t, data_rank, Layout>;

    using target_shape_t = std::array<long, Target::rank>;

    struct target_and_shape_t {
      target_shape_t _shape;

      using target_t = Target;

      target_shape_t const &shape() const { return _shape; }
    };
 
    // ------------- Accessors -----------------------------

    mesh_t const &mesh() const { return _mesh; }

    data_t &data() & { return _data; }

    data_t const &data() const & { return _data; }

    data_t data() && { return std::move(_data); }

    auto const &data_shape() const { return _data.shape(); }

    target_and_shape_t target() const { return target_and_shape_t{stdutil::front_mpop<arity>(_data.shape())}; } // drop arity dims

    std::array<long, Target::rank> target_shape() const { return target().shape(); } // drop arity dims

    auto target_indices() const { return itertools::product_range(target().shape()); }
 
    private:
    mesh_t _mesh;
    data_t _data;
 
    // -------------------------------- impl. details common to all classes -----------------------------------------------
 
    public:
    gf_const_view(gf_const_view const &x) = default;

    gf_const_view(gf_const_view &&) = default;
 
    private:
    void swap_impl(gf_const_view &b) noexcept {
      using std::swap;
      swap(this->_mesh, b._mesh);
      swap(this->_data, b._data);
    }
 
    public:
    // ---------------  Constructors --------------------

    /// Construct an empty view, not bound to any data.
    gf_const_view() = default;


    gf_const_view(gf_view<M, Target> const &g) : _mesh(g.mesh()), _data(g.data()) {}

    gf_const_view(gf<M, Target> const &g) : _mesh(g.mesh()), _data(g.data()) {}

    gf_const_view(gf<M, Target> &g) : _mesh(g.mesh()), _data(g.data()) {} // from a gf &

     */
    // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved): a view binds to the data of `g`, not moving it
    gf_const_view(gf<M, Target> &&g) noexcept : _mesh(std::move(g.mesh())), _data(std::move(g.data())) {} // from a gf &&


    gf_const_view(mesh_t m, data_t dat) : _mesh(std::move(m)), _data(dat) {}
 
    // ---------------  swap --------------------

     * @brief Swap two const views.
     * @param a First view.
     * @param b Second view.
     */
    friend void swap(gf_const_view &a, gf_const_view &b) noexcept { a.swap_impl(b); }
 
    // ---------------  Rebind --------------------


    void rebind(gf_const_view<M, Target> const &g) noexcept {
      this->_mesh = g._mesh;
      this->_data.rebind(g._data);
    }

    void rebind(gf_view<M, Target> const &X) noexcept { rebind(gf_const_view{X}); }
 
    // ---------------  No = since it is const ... --------------------

    gf_const_view &operator=(gf_const_view const &) = delete; // a const view can not be assigned to
 
    public:
    // ------------- apply_on_data -----------------------------

    template <typename Fdata> auto apply_on_data(Fdata &&fd) {
      auto d2    = std::forward<Fdata>(fd)(_data);
      using t2   = target_from_array<decltype(d2), arity>;
      using gv_t = gf_const_view<M, t2>;
      return gv_t{mesh(), d2};
    }

    template <typename Fdata> auto apply_on_data(Fdata &&fd) const {
      auto d2    = std::forward<Fdata>(fd)(_data);
      using t2   = target_from_array<decltype(d2), arity>;
      using gv_t = gf_const_view<M, t2>;
      return gv_t{mesh(), d2};
    }
 
    // Common code for gf, gf_view, gf_const_view
#include "./_gf_view_common.hpp"
  };
 
} // namespace triqs::gfs