grid_generator.hpp

Go to the documentation of this file.

// Copyright (c) 2013-2018 Commissariat à l'énergie atomique et aux énergies alternatives (CEA)
// Copyright (c) 2013-2018 Centre national de la recherche scientifique (CNRS)
// Copyright (c) 2018-2022 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 <itertools/itertools.hpp>
#include <nda/nda.hpp>
 
#include <iterator>
 
namespace triqs::lattice {


  using v_t = nda::vector<double>;

  class grid_generator : public itertools::iterator_facade<grid_generator, v_t const, std::forward_iterator_tag> {
    friend struct itertools::iterator_facade<grid_generator, v_t const, std::forward_iterator_tag>;
    int dim{3}, nkpts{0}, nx{0}, ny{0}, nz{0}, N_X{0}, N_Y{0}, N_Z{0}, index_{0};
    double step_x{0.0}, step_y{0.0}, step_z{0.0};
    bool at_end{false};
    v_t pt;
    void init() {
      N_X    = nkpts;
      N_Y    = (dim > 1 ? nkpts : 1);
      N_Z    = (dim > 2 ? nkpts : 1);
      step_x = 1.0 / double(N_X);
      step_y = 1.0 / double(N_Y);
      step_z = 1.0 / double(N_Z);
      pt(0)  = step_x / 2;
      pt(1)  = step_y / 2;
      pt(2)  = step_z / 2;
    }
 
    void increment() {
      if (nx < N_X - 1) {
        ++nx;
        pt(0) += step_x;
        ++index_;
        return;
      }
      pt(0) = step_x / 2;
      nx    = 0;
      if (ny < N_Y - 1) {
        ++ny;
        pt(1) += step_y;
        ++index_;
        return;
      }
      pt(1) = step_y / 2;
      ny    = 0;
      if (nz < N_Z - 1) {
        ++nz;
        pt(2) += step_z;
        ++index_;
        return;
      }
      at_end = true;
    }
 
    value_type dereference() const { return pt; }
 
    public:
    grid_generator(int dim, int nkpts) : dim(dim), nkpts(nkpts), pt(3) { init(); }

    grid_generator() : pt(3) { init(); }

    bool operator==(grid_generator const &other) const { return ((other.dim == dim) && (other.index_ == index_) && (other.nkpts == nkpts)); }

    int size() const { return (N_X * N_Y * N_Z); }

    int index() const { return index_; }

    operator bool() const { return !(at_end); }
  };

 
} // namespace triqs::lattice