gf_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 "../../utility/exceptions.hpp"
 
#include <itertools/itertools.hpp>
 
#include <array>
#include <utility>
 
namespace triqs::gfs {

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

    static constexpr bool is_const = false;

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

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

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

    using regular_type = gf<M, Target, typename Layout::contiguous_t>;

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

    using complex_t = gf_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;

    /// Type of the data array view.
    using data_t = nda::basic_array_view<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_view(gf_view const &x) = default;

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

    gf_view() = default;

    gf_view(gf_const_view<M, Target> const &g) = delete;

    template <typename L> gf_view(gf<M, Target, L> const &g) = delete;

    template <typename L> gf_view(gf<M, Target, L> &g) : _mesh(g.mesh()), _data(g.data()) {}

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


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

     */
    friend void swap(gf_view &a, gf_view &b) noexcept { a.swap_impl(b); }
 
    // ---------------  Rebind --------------------
    void rebind(gf_view<M, Target> const &g) noexcept {
      this->_mesh = g._mesh;
      this->_data.rebind(g._data);
    }
 
    // ---------------  operator =  --------------------
    gf_view &operator=(gf_view const &rhs) {
      triqs_gf_view_assign_delegation(*this, rhs);
      return *this;
    }

    template <typename RHS> gf_view &operator=(RHS const &rhs) {
      triqs_gf_view_assign_delegation(*this, rhs);
      return *this;
    }
 
    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_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"
  };
 
  /*------------------------------------------------------------------------------------------------------
 *                                     View  assignment
 *-----------------------------------------------------------------------------------------------------*/
 
  // Implementation of the assignment to a gf_view: scalar rhs is assigned to every mesh point, otherwise the meshes
  // must match and the data is copied point by point (throws on a mesh mismatch).
  template <typename M, typename T, typename L, typename RHS> void triqs_gf_view_assign_delegation(gf_view<M, T, L> g, RHS const &rhs) {
    if constexpr (nda::is_scalar_v<RHS>) {
      for (auto w : g.mesh()) g[w] = rhs;
    } else {
      if (!(g.mesh() == rhs.mesh())) TRIQS_RUNTIME_ERROR << "Gf Assignment in View : incompatible mesh \n" << g.mesh() << "\n vs \n" << rhs.mesh();
      for (auto w : g.mesh()) g[w] = rhs[w];
    }
  }
} // namespace triqs::gfs
/*------------------------------------------------------------------------------------------------------
 *             Delete std::swap for views, as for arrays
 *-----------------------------------------------------------------------------------------------------*/
namespace std {
  // Deleted std::swap for Green's function views (as for nda array views): use the hidden friend swap instead.
  // NOLINTNEXTLINE(bugprone-std-namespace-modification): deleting std::swap for views is intentional, as for nda arrays
  template <typename M, typename Target> void swap(triqs::gfs::gf_view<M, Target> &a, triqs::gfs::gf_view<M, Target> &b) = delete;
} // namespace std