Commit 598bfc03 authored by gbalduzz's avatar gbalduzz
Browse files

Merge remote-tracking branch 'origin/master' into rearrange_g4

parents a60a37a4 ed9406d2

include/dca/function/domains/dmn_variadic.hpp

+32 −30
Original line number Diff line number Diff line
@@ -59,30 +59,32 @@ public: 
  // If sizeof(args) == sizeof(domains): calls index via branch domains.

  // If sizeof(args) == sizeof(leaf domains): calls index via leaf domains.

  template <typename... Args>

  int operator()(Args&&... args) const;

  std::size_t operator()(Args&&... args) const;



protected:

  // Indexing operator: accesses elements of the domain via branches.

  // index_lookup is overloaded on std::integral_constant<bool, true>::type so that if

  // sizeof...(Args) == sizeof...(domain_list) then this is called.

  template <typename... Args>

  int index_lookup(std::integral_constant<bool, true>::type, int branch_i0, Args... args) const;

  std::size_t index_lookup(std::integral_constant<bool, true>::type, int branch_i0,

                           Args... args) const;



  // Indexing operator: accesses elements of the domain via leaf domains.

  // index_lookup is overloaded on std::integral_constant<bool, true>::type so that if

  // sizeof...(Args) == sizeof...(domain_list) then this is called.

  template <typename... Args>

  int index_lookup(std::integral_constant<bool, false>::type, int leaf_i0, Args... args) const;

  std::size_t index_lookup(std::integral_constant<bool, false>::type, int leaf_i0, Args... args) const;



  // Gets the branch domain sizes for each of the domain template arguments.

  // Returns a vector of the sizes.

  template <typename Tuple, std::size_t... DomainIndex>

  std::vector<int> init_branch_domain_sizes(Tuple& t, std::index_sequence<DomainIndex...>);

  std::vector<std::size_t> init_branch_domain_sizes(Tuple& t, std::index_sequence<DomainIndex...>);



  // Gets the number of leaf domains for each of the domain template arguments.

  // Returns a vector of the counts.

  template <typename Tuple, std::size_t... DomainIndex>

  std::vector<int> init_leaf_domain_sizes(Tuple& domaintuple, std::index_sequence<DomainIndex...>);

  std::vector<std::size_t> init_leaf_domain_sizes(Tuple& domaintuple,

                                                  std::index_sequence<DomainIndex...>);



protected:

  std::tuple<domain_list...> domains;
@@ -90,14 +92,14 @@ protected: 


template <typename... domain_list>

template <typename Tuple, std::size_t... DomainIndex>

std::vector<int> dmn_variadic<domain_list...>::init_branch_domain_sizes(

std::vector<std::size_t> dmn_variadic<domain_list...>::init_branch_domain_sizes(

    Tuple& domaintuple, std::index_sequence<DomainIndex...>) {

  return {(std::get<DomainIndex>(domaintuple).get_size())...};

}



template <typename... domain_list>

template <typename Tuple, std::size_t... DomainIndex>

std::vector<int> dmn_variadic<domain_list...>::init_leaf_domain_sizes(

std::vector<std::size_t> dmn_variadic<domain_list...>::init_leaf_domain_sizes(

    Tuple& domaintuple, std::index_sequence<DomainIndex...>) {

  return {(std::get<DomainIndex>(domaintuple).get_Nb_leaf_domains())...};

}
@@ -141,12 +143,12 @@ T sum(T first, Args... args) { 
}



template <typename... Args, std::size_t... Is>

int multiply_offsets(const std::vector<int>& multipliers, std::index_sequence<Is...>,

                     Args&&... offsets) {

std::size_t multiply_offsets(const std::vector<std::size_t>& multipliers,

                             std::index_sequence<Is...>, Args&&... offsets) {

  return sum((offsets * (multipliers[Is]))...);

}



}  // detail

}  // namespace detail



template <typename... domain_list>

dmn_variadic<domain_list...>::dmn_variadic() : domain() {
@@ -169,7 +171,7 @@ void dmn_variadic<domain_list...>::reset() { 
  // std::endl

  //           << "domain sizes : ";

  // std::copy(branch_domain_sizes.begin(), branch_domain_sizes.end(),

  //           std::ostream_iterator<int>(std::cout, ","));

  //           std::ostream_iterator<std::size_t>(std::cout, ","));

  // std::cout << std::endl;



  branch_domain_steps.resize(branch_domain_sizes.size(), 1);
@@ -181,17 +183,17 @@ void dmn_variadic<domain_list...>::reset() { 


  // std::cout << "Steps ";

  // std::copy(branch_domain_steps.begin(), branch_domain_steps.end(),

  //           std::ostream_iterator<int>(std::cout, ","));

  //           std::ostream_iterator<std::size_t>(std::cout, ","));

  // std::cout << std::endl;



  // Generate the leaf domain sizes from each sub domain.

  auto leaf_stuff = init_leaf_domain_sizes(domains, indices);

  // std::cout << "Leaf stuff ";

  // std::copy(leaf_stuff.begin(), leaf_stuff.end(), std::ostream_iterator<int>(std::cout, ","));

  // std::cout << std::endl;

  // std::copy(leaf_stuff.begin(), leaf_stuff.end(), std::ostream_iterator<std::size_t>(std::cout,

  // ",")); std::cout << std::endl;



  detail::for_each_in_tuple(domains, [this](auto& d) {

    std::vector<int> temp = d.get_leaf_domain_sizes();

    std::vector<std::size_t> temp = d.get_leaf_domain_sizes();

    std::copy(std::begin(temp), std::end(temp), std::back_inserter(leaf_domain_sizes));

  });
@@ -206,7 +208,7 @@ void dmn_variadic<domain_list...>::reset() { 


  // std::cout << "leaf step size ";

  // std::copy(leaf_domain_steps.begin(), leaf_domain_steps.end(),

  //           std::ostream_iterator<int>(std::cout, ","));

  //           std::ostream_iterator<std::size_t>(std::cout, ","));

  // std::cout << std::endl;



  size = 1;
@@ -220,20 +222,20 @@ void dmn_variadic<domain_list...>::reset() { 


template <typename... domain_list>

template <typename... Args>

int dmn_variadic<domain_list...>::operator()(Args&&... args) const {

std::size_t dmn_variadic<domain_list...>::operator()(Args&&... args) const {

  static_assert(sizeof...(Args) >= sizeof...(domain_list), "not enough args");

  return index_lookup(std::integral_constant<bool, (sizeof...(Args) == sizeof...(domain_list))>(),

                      std::forward<Args>(args)...);

}



template <typename... Args, std::size_t... Is>

void check_indices(const char* /*msg*/, const std::vector<int>& sizes, std::index_sequence<Is...>,

                   Args&&... indices) {

void check_indices(const char* /*msg*/, const std::vector<std::size_t>& sizes,

                   std::index_sequence<Is...>, Args&&... indices) {

  if (std::min({(sizes[Is] - indices)...}) <= 0) {

    dca::util::ignoreReturnValues(

        (std::cerr << "size " << sizes[Is] << " index " << indices << " ")...);

    std::cerr << " : Index too big error" << std::endl;

    std::copy(sizes.begin(), sizes.end(), std::ostream_iterator<int>(std::cerr, ","));

    std::copy(sizes.begin(), sizes.end(), std::ostream_iterator<std::size_t>(std::cerr, ","));

    throw std::runtime_error("Index too big error");

  }

  if (std::min({indices...}) < 0) {
@@ -244,7 +246,7 @@ void check_indices(const char* /*msg*/, const std::vector<int>& sizes, std::inde 


template <typename... domain_list>

template <typename... Args>

int dmn_variadic<domain_list...>::index_lookup(std::integral_constant<bool, true>::type,

std::size_t dmn_variadic<domain_list...>::index_lookup(std::integral_constant<bool, true>::type,

                                                       int branch_i0, Args... branch_indices) const {

  static_assert(sizeof...(Args) + 1 == sizeof...(domain_list), "not enough args");
@@ -257,14 +259,14 @@ int dmn_variadic<domain_list...>::index_lookup(std::integral_constant<bool, true 
                std::forward<Args>(branch_indices)...);

#endif  // NDEBUG



  int N = branch_i0 +

          detail::multiply_offsets(branch_domain_steps, seq, std::forward<Args>(branch_indices)...);

  std::size_t N = branch_i0 + detail::multiply_offsets(branch_domain_steps, seq,

                                                       std::forward<Args>(branch_indices)...);

  return N;

}



template <typename... domain_list>

template <typename... Args>

int dmn_variadic<domain_list...>::index_lookup(std::integral_constant<bool, false>::type,

std::size_t dmn_variadic<domain_list...>::index_lookup(std::integral_constant<bool, false>::type,

                                                       int leaf_i0, Args... leaf_indices) const {

  // Create an index sequence starting from 1, with length sizeof...(args)-1.

  auto seq = detail::make_index_sequence_with_offset<1, sizeof...(Args)>();
@@ -274,12 +276,12 @@ int dmn_variadic<domain_list...>::index_lookup(std::integral_constant<bool, fals 
  check_indices("leaf", leaf_domain_sizes, seq2, leaf_i0, std::forward<Args>(leaf_indices)...);

#endif  // NDEBUG



  int N = leaf_i0 +

          detail::multiply_offsets(leaf_domain_steps, seq, std::forward<Args>(leaf_indices)...);

  std::size_t N = leaf_i0 + detail::multiply_offsets(leaf_domain_steps, seq,

                                                     std::forward<Args>(leaf_indices)...);

  return N;

}



}  // func

}  // dca

}  // namespace func

}  // namespace dca



#endif  // DCA_FUNCTION_DOMAINS_DMN_VARIADIC_HPP

include/dca/function/domains/domain.hpp

+16 −16
Original line number Diff line number Diff line
@@ -25,11 +25,11 @@ public: 
  void reset();



  // domain interface functions

  int get_size() const {

  std::size_t get_size() const {

    return size;

  }



  const std::vector<int>& get_branch_domain_sizes() const {

  const std::vector<std::size_t>& get_branch_domain_sizes() const {

    return branch_domain_sizes;

  }

  int get_Nb_branch_domains() const {
@@ -39,38 +39,38 @@ public: 
    return branch_domain_sizes[branch_index];

  }



  const std::vector<int>& get_leaf_domain_sizes() const {

  const std::vector<std::size_t>& get_leaf_domain_sizes() const {

    return leaf_domain_sizes;

  }

  int get_Nb_leaf_domains() const {

  std::size_t get_Nb_leaf_domains() const {

    return leaf_domain_sizes.size();

  }

  int get_subdomain_size(const int subdomain_index) const {

  std::size_t get_subdomain_size(const int subdomain_index) const {

    return leaf_domain_sizes[subdomain_index];

  }



  const std::vector<int>& get_leaf_domain_steps() const {

  const std::vector<std::size_t>& get_leaf_domain_steps() const {

    return leaf_domain_steps;

  }

  const std::vector<int>& get_branch_domain_steps() const {

  const std::vector<std::size_t>& get_branch_domain_steps() const {

    return branch_domain_steps;

  }



  // linind <--> subdomain_indices != branch_indices

  void linind_2_subind(int linind, int* subind) const;

  void subind_2_linind(const int* subind, int& linind) const;

  void linind_2_subind(std::size_t linind, int* subind) const;

  void subind_2_linind(const int* subind, std::size_t& linind) const;



protected:

  int size;

  std::size_t size;



  std::vector<int> branch_domain_sizes;

  std::vector<int> leaf_domain_sizes;

  std::vector<std::size_t> branch_domain_sizes;

  std::vector<std::size_t> leaf_domain_sizes;



  std::vector<int> branch_domain_steps;

  std::vector<int> leaf_domain_steps;

  std::vector<std::size_t> branch_domain_steps;

  std::vector<std::size_t> leaf_domain_steps;

};



}  // func

}  // dca

}  // namespace func

}  // namespace dca



#endif  // DCA_FUNCTION_DOMAINS_DOMAIN_HPP

include/dca/function/function.hpp

+4 −4
Original line number Diff line number Diff line
@@ -97,7 +97,7 @@ public: 
  int signature() const {

    return Nb_sbdms;

  }

  int size() const {

  std::size_t size() const {

    return Nb_elements;

  }

  // Returns the size of the leaf domain with the given index.
@@ -238,12 +238,12 @@ private: 


  domain dmn;  // TODO: Remove domain object?



  int Nb_elements;

  std::size_t Nb_elements;



  // The subdomains (sbdmn) represent the leaf domains, not the branch domains.

  int Nb_sbdms;

  const std::vector<int>& size_sbdm;  // TODO: Remove?

  const std::vector<int>& step_sbdm;  // TODO: Remove?

  const std::vector<std::size_t>& size_sbdm;  // TODO: Remove?

  const std::vector<std::size_t>& step_sbdm;  // TODO: Remove?



  scalartype* fnc_values;

};

include/dca/math/nfft/dnfft_1d.hpp

+1 −1
Original line number Diff line number Diff line
@@ -254,7 +254,7 @@ inline void Dnfft1D<ScalarType, WDmn, PDmn, oversampling, mode>::accumulate(cons 
                                                                            const ScalarType t_val,

                                                                            const ScalarType f_val) {

  const static PDmn p_dmn_obj;

  int linind = 0;

  std::size_t linind = 0;

  p_dmn_obj.subind_2_linind(subind, linind);

  accumulate(linind, t_val, f_val);

}

include/dca/parallel/mpi_concurrency/mpi_collective_max.hpp

+1 −1
Original line number Diff line number Diff line
@@ -29,7 +29,7 @@ public: 
  void max(Scalar& value) const {

    Scalar result;



    MPI_Allreduce(&value, &result, MPITypeMap<Scalar>::factor(), MPITypeMap<Scalar>::value(),

    MPI_Allreduce(&value, &result, 1, MPITypeMap<Scalar>::value(),

                  MPI_MAX, MPIProcessorGrouping::get());



    value = result;