doc/pexamples/aa.cc

Go to the documentation of this file.

template <class T, class M>
struct csr_concat {
 typedef typename csr<T,M>::size_type   size_type;
 typedef csr_concat_line<T,M>           line_type;
 typedef csr_concat_value<T,M>          value_type;
 csr_concat () : _l() {}
 csr_concat (const std::initializer_list<line_type>& il) : _l() {
#ifdef _RHEOLEF_HAVE_STD_INITIALIZER_ITERATOR
    typedef typename std::initializer_list<line_type>::const_iterator const_iterator;
#else // _RHEOLEF_HAVE_STD_INITIALIZER_ITERATOR
    typedef const line_type* const_iterator;
#endif // _RHEOLEF_HAVE_STD_INITIALIZER_ITERATOR
    for(const_iterator iter = il.begin(); iter != il.end(); ++iter) {
        _l.push_back(*iter);
    }
 }
 friend std::ostream& operator<< (std::ostream& o, const csr_concat<T,M>& x) {
    std::cout << "{";
    for(typename std::list<line_type>::const_iterator iter = x._l.begin(); iter != x._l.end(); ++iter) {
        std::cout << *iter << " ";
    }
    return std::cout << "}";
 }
 void     build_csr_pass1 (distributor& row_ownership, distributor& col_ownership) const;
 csr<T,M> build_csr_pass2 (asr<T,M>& a) const;
 csr<T,M> build_csr () const;

protected:
 std::list<line_type> _l;
};
template <class T, class M>
csr<T,M>
csr_concat<T,M>::build_csr() const
{
  distributor col_ownership;
  bool has_col = false;
  size_type nrow = 0;
  size_type dis_nrow = 0;
  std::list<std::pair<size_type,size_type> > nrow_list;
  for(typename std::list<line_type>::const_iterator iter = _l.begin(); iter != _l.end(); ++iter) {
    const line_type& line = *iter;
    distributor row_line_ownership;
    distributor col_line_ownership;
    line.build_csr_pass1 (row_line_ownership, col_line_ownership);
    if (!has_col) {
      has_col = true;
      col_ownership = col_line_ownership;
    } else {
      check_macro (col_line_ownership == col_ownership,
        "matrix initializer list: matrix col argument [0:" <<col_line_ownership.dis_size() << "["
        << " has incomptible size: expect [0:" <<col_ownership.dis_size() << "[");
    }
    nrow_list.push_back (std::make_pair(row_line_ownership.size(), row_line_ownership.dis_size()));
    nrow     += row_line_ownership.size();
    dis_nrow += row_line_ownership.dis_size();
  }
  communicator comm = col_ownership.comm();
  distributor row_ownership (dis_nrow, comm, nrow);
  asr<T,M> a (row_ownership, col_ownership);
  size_type block_i = 0;
  size_type block_dis_i = 0;
  typename std::list<std::pair<size_type,size_type> >::const_iterator iter_nrow = nrow_list.begin();
  for(typename std::list<line_type>::const_iterator iter = _l.begin(); iter != _l.end(); ++iter, ++iter_nrow) {
    const line_type& line = *iter;
    line.build_csr_pass2 (a, block_i, block_dis_i);
    block_i     += (*iter_nrow).first;
    block_dis_i += (*iter_nrow).second;
  }
  a.dis_entry_assembly();
  return csr<T,M>(a);
}
#define RHEOLEF_csr_cstor(M)                                            \
template <class T>                                                      \
inline                                                                  \
csr<T,M>::csr (const std::initializer_list<csr_concat_line<T,M> >& init_list) \
{                                                                       \
  csr_concat<T,M> cc (init_list);                                       \
  csr<T,M>::operator= (cc.build_csr());                                 \
}
RHEOLEF_csr_cstor(sequential)
#ifdef _RHEOLEF_HAVE_MPI
RHEOLEF_csr_cstor(distributed)
#endif // _RHEOLEF_HAVE_MPI
#undef RHEOLEF_csr_cstor

} // namespace rheolef
#endif // _RHEOLEF_CSR_CONCAT_H