Rheolef  7.2
an efficient C++ finite element environment
 
Loading...
Searching...
No Matches
disarray.h
Go to the documentation of this file.
1#ifndef _RHEO_DISARRAY_H
2#define _RHEO_DISARRAY_H
3//
4// This file is part of Rheolef.
5//
6// Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
7//
8// Rheolef is free software; you can redistribute it and/or modify
9// it under the terms of the GNU General Public License as published by
10// the Free Software Foundation; either version 2 of the License, or
11// (at your option) any later version.
12//
13// Rheolef is distributed in the hope that it will be useful,
14// but WITHOUT ANY WARRANTY; without even the implied warranty of
15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16// GNU General Public License for more details.
17//
18// You should have received a copy of the GNU General Public License
19// along with Rheolef; if not, write to the Free Software
20// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21//
22// =========================================================================
23
24namespace rheolef {
166} // namespace rheolef
167
168
169/*
170Misc notes:
171 "scatter" via "get_dis_entry".
172
173 "gather" via "dis_entry(dis_i) = value"
174 or "dis_entry(dis_i) += value". Note that += applies when T=idx_set where
175 idx_set is a wrapper class of std::set<size_t> ; the += operator represents the
176 union of a set. The operator= is used when T=double or others simple T types
177 without algebra. If there is a conflict, i.e. several processes set the dis_i
178 index, then the result of operator+= depends upon the order of the process at
179 each run and is not deterministic. Such ambiguous behavior is not detected
180 yet at run time.
181
182*/
183
184#include "rheolef/communicator.h"
185#include "rheolef/distributor.h"
186#include "rheolef/diststream.h"
187#include "rheolef/heap_allocator.h"
188#include "rheolef/msg_util.h"
189#ifdef _RHEOLEF_HAVE_MPI
190#include "rheolef/mpi_pair_datatype.h"
191#endif // _RHEOLEF_HAVE_MPI
192
193namespace rheolef {
195template <class T>
197 std::ostream& operator() (std::ostream& os, const T& x) const { return os << x; }
198};
199template <class T>
201 std::ostream& operator() (std::ostream& os, const T& x) const { return os << x << ";"; }
202};
204template <class T>
206 std::istream& operator() (std::istream& is, T& x) const { return is >> x; }
207};
208} // namespace rheolef
209// -------------------------------------------------------------
210// the sequential representation
211// -------------------------------------------------------------
212namespace rheolef {
213
214template <class T, class M, class A> class disarray_rep {};
215
216template <class T, class A>
217class disarray_rep<T,sequential,A> : public std::vector<T> { // TODO: vector<T,A> for heap_alloc
218public:
219 typedef T value_type;
221 typedef typename A::difference_type difference_type;
222 typedef std::vector<T> base; // TODO: vector<T,A> for heap_alloc
223 typedef typename base::size_type size_type;
224 typedef typename base::iterator iterator;
225 typedef typename base::const_iterator const_iterator;
226 typedef typename base::const_reference const_reference;
227 typedef typename base::reference reference;
231
232 explicit disarray_rep (const A& alloc = A());
233 disarray_rep (const distributor& ownership, const T& init_val = T(), const A& alloc = A());
234 void resize (const distributor& ownership, const T& init_val = T());
235 disarray_rep (size_type loc_size = 0, const T& init_val = T(), const A& alloc = A());
236 void resize (size_type loc_size = 0, const T& init_val = T());
238
239 A get_allocator() const { return base::get_allocator(); }
240 size_type size() const { return base::size(); }
241 iterator begin() { return base::begin(); }
242 const_iterator begin() const { return base::begin(); }
243 iterator end() { return base::end(); }
244 const_iterator end() const { return base::end(); }
245 const distributor& ownership() const { return _ownership; }
246
247 reference operator[] (size_type i) { return base::operator[] (i); }
248 const_reference operator[] (size_type i) const { return base::operator[] (i); }
249 const_reference dis_at (size_type dis_i) const { return operator[] (dis_i); }
250
251 size_type dis_size () const { return base::size(); }
252 size_type first_index () const { return 0; }
253 size_type last_index () const { return base::size(); }
254 reference dis_entry (size_type dis_i) { return operator[](dis_i); }
255 void get_dis_indexes (std::set<size_type>& ext_idx_set) const;
256 void reset_dis_indexes() const {}
257 template<class SetOp = typename details::default_set_op_traits<T>::type>
258 void dis_entry_assembly_begin (SetOp = SetOp()) {}
259 template<class SetOp = typename details::default_set_op_traits<T>::type>
260 void dis_entry_assembly_end (SetOp = SetOp()) {}
261 void repartition ( // old_numbering for *this
262 const disarray_rep<size_type,sequential,A>& partition, // old_ownership
263 disarray_rep<T,sequential,A>& new_disarray, // new_ownership (created)
264 disarray_rep<size_type,sequential,A>& old_numbering, // new_ownership
265 disarray_rep<size_type,sequential,A>& new_numbering) const // old_ownership
266 {
267 error_macro ("not yet");
268 }
269 template<class A2>
270 void reverse_permutation ( // old_ownership for *this=iold2dis_inew
271 disarray_rep<size_type,sequential,A2>& inew2dis_iold) const; // new_ownership
272
273 idiststream& get_values (idiststream& s);
274 odiststream& put_values (odiststream& s) const;
275 odiststream& put_matlab (odiststream& s) const;
276 template <class GetFunction> idiststream& get_values (idiststream& ips, GetFunction get_element);
277 template <class PutFunction> odiststream& put_values (odiststream& ops, PutFunction put_element) const;
278 void dump (std::string name) const;
279protected:
280// data:
282};
283// -------------------------------------------------------------
284// the distributed representation
285// -------------------------------------------------------------
286#ifdef _RHEOLEF_HAVE_MPI
287template <class T, class A> struct disarray_dis_reference;
288
289template <class T, class A>
290class disarray_rep<T,distributed,A> : public disarray_rep<T,sequential,A> {
291public:
292
293// typedefs:
294
296 using size_type = typename base::size_type;
297 using value_type = typename base::value_type;
299 using iterator = typename base::iterator;
301 using reference = typename base::reference;
305 using scatter_map_type = std::map <size_type, T>; // TODO: map<T,A> for heap_alloc
307
308// allocators:
309
310 disarray_rep (const distributor& ownership, const T& init_val = T(), const A& alloc = A());
311 void resize (const distributor& ownership, const T& init_val = T());
313
314 A get_allocator() const { return base::get_allocator(); }
315 size_type size() const { return base::size(); }
316 const_iterator begin() const { return base::begin(); }
317 const_iterator end() const { return base::end(); }
318 iterator begin() { return base::begin(); }
319 iterator end() { return base::end(); }
320
321 const distributor& ownership() const { return base::_ownership; }
322 const mpi::communicator& comm() const { return ownership().comm(); }
323 size_type first_index () const { return ownership().first_index(); }
324 size_type last_index () const { return ownership().last_index(); }
325 size_type dis_size () const { return ownership().dis_size(); }
326
327 dis_reference dis_entry (size_type dis_i) { return dis_reference (*this, dis_i); }
328
329 template<class SetOp = typename details::default_set_op_traits<T>::type>
330 void dis_entry_assembly_begin (SetOp my_set_op = SetOp());
331 template<class SetOp = typename details::default_set_op_traits<T>::type>
332 void dis_entry_assembly_end (SetOp my_set_op = SetOp());
333 template<class SetOp = typename details::default_set_op_traits<T>::type>
334 void dis_entry_assembly (SetOp my_set_op = SetOp())
335 { dis_entry_assembly_begin (my_set_op); dis_entry_assembly_end (my_set_op); }
336
337 template<class Set, class Map>
338 void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const;
339
340 template<class Set, class Map>
341 void get_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const {
342 ext_idx_map.clear();
343 append_dis_entry (ext_idx_set, ext_idx_map);
344 }
345
346 template<class Set>
347 void append_dis_indexes (const Set& ext_idx_set) const { append_dis_entry (ext_idx_set, _ext_x); }
348
349 template<class Set>
350 void set_dis_indexes (const Set& ext_idx_set) const { get_dis_entry (ext_idx_set, _ext_x); }
351 void get_dis_indexes (std::set<size_type>& ext_idx_set) const;
352 void reset_dis_indexes() const;
353
354 const_reference dis_at (size_type dis_i) const;
355
356 // get all external pairs (dis_i, values):
357 const scatter_map_type& get_dis_map_entries() const { return _ext_x; }
358
359 template<class A2>
360 void repartition ( // old_numbering for *this
361 const disarray_rep<size_type,distributed,A2>& partition, // old_ownership
362 disarray_rep<T,distributed,A>& new_disarray, // new_ownership (created)
363 disarray_rep<size_type,distributed,A2>& old_numbering, // new_ownership
364 disarray_rep<size_type,distributed,A2>& new_numbering) const; // old_ownership
365
366 template<class A2>
367 void permutation_apply ( // old_numbering for *this
368 const disarray_rep<size_type,distributed,A2>& new_numbering, // old_ownership
369 disarray_rep<T,distributed,A>& new_disarray) const; // new_ownership (already allocated)
370
371 template<class A2>
372 void reverse_permutation ( // old_ownership for *this=iold2dis_inew
373 disarray_rep<size_type,distributed,A2>& inew2dis_iold) const; // new_ownership
374
375 idiststream& get_values (idiststream& s);
376 odiststream& put_values (odiststream& s) const;
377 odiststream& put_matlab (odiststream& s) const;
378 template <class GetFunction> idiststream& get_values (idiststream& ips, GetFunction get_element);
379 template <class PutFunction> odiststream& put_values (odiststream& ops, PutFunction put_element) const;
380 template <class PutFunction, class A2> odiststream& permuted_put_values (odiststream& ops, const disarray_rep<size_type,distributed,A2>& perm,
381 PutFunction put_element) const;
382 void dump (std::string name) const;
383//protected:
384 template<class U, class SetOp>
385 void set_dis_entry (size_type dis_i, const U& val, const SetOp& set_op);
386#ifdef TO_CLEAN
387 template<class U, class SetOp>
388 void set_plus_dis_entry (size_type dis_i, const U& val, const SetOp& set_op);
389 template<class U, class SetOp>
390 void set_minus_dis_entry (size_type dis_i, const U& val, const SetOp& set_op);
391#endif // TO_CLEAN
392// typedefs:
396 template<class Pair>
397 struct remove_const_in_pair {
398 typedef Pair type;
399 };
400 template<class T1, class T2>
401 struct remove_const_in_pair<std::pair<T1,T2> > {
402 typedef std::pair<typename std::decay<T1>::type,
403 typename std::decay<T2>::type> type;
404 };
405 template<class U, class IsContainer> struct stash_traits {};
406 template<class U>
407 struct stash_traits<U,std::false_type> {
408 typedef U mapped_type;
409 typedef std::map <size_type, U> map_type; // TODO: map<T,A> for heap_alloc
410 };
411 template<class U>
412 struct stash_traits<U,std::true_type> {
414 typedef std::multimap <size_type, mapped_type> map_type; // TODO: map<T,A> for heap_alloc
415 };
417 typedef typename stash_traits<T,is_container>::mapped_type stash_value;
418 typedef typename stash_traits<T,is_container>::map_type stash_map_type;
419
422 struct message_type {
423 std::list<std::pair<size_type,mpi::request> > waits; // TODO: list<T,A> for heap_alloc
424 std::vector<std::pair<size_type,stash_value> > data; // TODO: vector<T,A> for heap_alloc
425 message_type() : waits(), data() {}
426 };
429 template<class Set, class Map>
430 void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map, std::true_type) const;
431 template<class Set, class Map>
432 void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map, std::false_type) const;
433
434// data:
435 stash_map_type _stash; // for assembly msgs:
436 message_type _send;
437 message_type _receive;
439 mutable scatter_map_type _ext_x; // for ext values (scatter)
440};
441// custom reference that interacts with stach
442// for ext values on others partitions
443template <class T, class A>
445{
447
450
451#ifndef TO_CLEAN // not usefull: default behavior
454
457 _x = r._x; _dis_i = r._dis_i; return *this; }
458#endif // TO_CLEAN
459
461 operator= (const T& value) {
462 trace_macro("_x.set_dis_entry (dis_i="<<_dis_i<<", value="<<value<<", op=)");
463 _x.set_dis_entry (_dis_i, value, details::generic_set_op());
464 return *this;
465 }
466 template<class U>
468 operator+= (const U& value) {
469 trace_macro("_x.set_dis_entry (dis_i="<<_dis_i<<", value="<<value<<", op+=)");
470 _x.set_dis_entry (_dis_i, value, details::generic_set_plus_op());
471 return *this;
472 }
473 template<class U>
475 operator-= (const U& value) {
476 trace_macro("_x.set_dis_entry (dis_i="<<_dis_i<<", value="<<value<<", op-=)");
477 _x.set_dis_entry (_dis_i, value, details::generic_set_minus_op());
478 return *this;
479 }
480// data:
481protected:
484};
485
486namespace details {
487template <class T, class A>
488struct is_class_reference<disarray_dis_reference<T,A>> : std::true_type {};
489} // namespace details
490
491#endif // _RHEOLEF_HAVE_MPI
492// -------------------------------------------------------------
493// the basic class with a smart pointer to representation
494// the user-level class with memory-model parameter
495// -------------------------------------------------------------
496template <class T, class M = rheo_default_memory_model, class A = std::allocator<T> >
505template <class T, class A>
506class disarray<T,sequential,A> : public smart_pointer<disarray_rep<T,sequential,A> > {
507public:
508
509// typedefs:
510
513
515 typedef typename rep::size_type size_type;
517 typedef typename rep::value_type value_type;
518 typedef typename rep::reference reference;
520 typedef typename rep::iterator iterator;
523
524// allocators:
525
526
527 disarray (size_type loc_size = 0, const T& init_val = T(), const A& alloc = A());
528 void resize (size_type loc_size = 0, const T& init_val = T());
529 disarray (const distributor& ownership, const T& init_val = T(), const A& alloc = A());
530 void resize (const distributor& ownership, const T& init_val = T());
531
532// local accessors & modifiers:
533
534 A get_allocator() const { return base::data().get_allocator(); }
535 size_type size () const { return base::data().size(); }
536 size_type dis_size () const { return base::data().dis_size(); }
537 const distributor& ownership() const { return base::data().ownership(); }
538 const communicator& comm() const { return ownership().comm(); }
539
540 reference operator[] (size_type i) { return base::data().operator[] (i); }
541 const_reference operator[] (size_type i) const { return base::data().operator[] (i); }
542 reference operator() (size_type i) { return base::data().operator[] (i); }
543 const_reference operator() (size_type i) const { return base::data().operator[] (i); }
544 const_reference dis_at (size_type dis_i) const { return operator[] (dis_i); }
545
546 iterator begin() { return base::data().begin(); }
547 const_iterator begin() const { return base::data().begin(); }
548 iterator end() { return base::data().end(); }
549 const_iterator end() const { return base::data().end(); }
550
551// global modifiers (for compatibility with distributed interface):
552
553 dis_reference dis_entry (size_type dis_i) { return base::data().dis_entry(dis_i); }
554 template<class SetOp = typename details::default_set_op_traits<T>::type>
555 void dis_entry_assembly (SetOp my_set_op = SetOp()) {}
556 template<class SetOp = typename details::default_set_op_traits<T>::type>
557 void dis_entry_assembly_begin (SetOp my_set_op = SetOp()) {}
558 template<class SetOp = typename details::default_set_op_traits<T>::type>
559 void dis_entry_assembly_end (SetOp my_set_op = SetOp()) {}
560
564
565 void get_dis_indexes (std::set<size_type>& ext_idx_set) const { base::data().get_dis_indexes (ext_idx_set); }
566 void reset_dis_indexes() const {}
567 template<class Set> void set_dis_indexes (const Set& ext_idx_set) const {}
568 template<class Set> void append_dis_indexes (const Set& ext_idx_set) const {}
569 template<class Set, class Map> void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const {}
570 template<class Set, class Map> void get_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const {}
571
572// apply a partition:
573
574 template<class RepSize>
575 void repartition ( // old_numbering for *this
576 const RepSize& partition, // old_ownership
577 disarray<T,sequential,A>& new_disarray, // new_ownership (created)
578 RepSize& old_numbering, // new_ownership
579 RepSize& new_numbering) const // old_ownership
580 { return base::data().repartition (partition, new_disarray, old_numbering, new_numbering); }
581
582 template<class RepSize>
583 void permutation_apply ( // old_numbering for *this
584 const RepSize& new_numbering, // old_ownership
585 disarray<T,sequential,A>& new_disarray) const // new_ownership (already allocated)
586 { return base::data().permutation_apply (new_numbering, new_disarray); }
587
588 void reverse_permutation ( // old_ownership for *this=iold2dis_inew
589 disarray<size_type,sequential,A>& inew2dis_iold) const // new_ownership
590 { base::data().reverse_permutation (inew2dis_iold.data()); }
591
592// i/o:
593
594 odiststream& put_values (odiststream& ops) const { return base::data().put_values(ops); }
595 idiststream& get_values (idiststream& ips) { return base::data().get_values(ips); }
596 template <class GetFunction>
597 idiststream& get_values (idiststream& ips, GetFunction get_element) { return base::data().get_values(ips, get_element); }
598 template <class PutFunction>
599 odiststream& put_values (odiststream& ops, PutFunction put_element) const { return base::data().put_values(ops, put_element); }
600 void dump (std::string name) const { return base::data().dump(name); }
601};
602template <class T, class A>
603inline
605 size_type loc_size,
606 const T& init_val,
607 const A& alloc)
608 : base(new_macro(rep(loc_size,init_val,alloc)))
609{
610}
611template <class T, class A>
612inline
614 const distributor& ownership,
615 const T& init_val,
616 const A& alloc)
617 : base(new_macro(rep(ownership,init_val,alloc)))
618{
619}
620template <class T, class A>
621inline
622void
624 size_type loc_size,
625 const T& init_val)
626{
627 base::data().resize (loc_size,init_val);
628}
629template <class T, class A>
630inline
631void
633 const distributor& ownership,
634 const T& init_val)
635{
636 base::data().resize (ownership,init_val);
637}
638#ifdef _RHEOLEF_HAVE_MPI
639// [verbatim_disarray]
640template <class T, class A>
641class disarray<T,distributed,A> : public smart_pointer<disarray_rep<T,distributed,A> > {
642public:
643
644// typedefs:
645
648
650 typedef typename rep::size_type size_type;
652 typedef typename rep::value_type value_type;
653 typedef typename rep::reference reference;
655 typedef typename rep::iterator iterator;
659
660// allocators:
661
662 disarray (const distributor& ownership = distributor(), const T& init_val = T(), const A& alloc = A());
663 void resize (const distributor& ownership = distributor(), const T& init_val = T());
664
665// local accessors & modifiers:
666
667 A get_allocator() const { return base::data().get_allocator(); }
668 size_type size () const { return base::data().size(); }
669 size_type dis_size () const { return base::data().dis_size(); }
670 const distributor& ownership() const { return base::data().ownership(); }
671 const communicator& comm() const { return base::data().comm(); }
672
673 reference operator[] (size_type i) { return base::data().operator[] (i); }
674 const_reference operator[] (size_type i) const { return base::data().operator[] (i); }
675 reference operator() (size_type i) { return base::data().operator[] (i); }
676 const_reference operator() (size_type i) const { return base::data().operator[] (i); }
677
678 iterator begin() { return base::data().begin(); }
679 const_iterator begin() const { return base::data().begin(); }
680 iterator end() { return base::data().end(); }
681 const_iterator end() const { return base::data().end(); }
682
683// global accessor:
684
685 template<class Set, class Map>
686 void append_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const { base::data().append_dis_entry (ext_idx_set, ext_idx_map); }
687
688 template<class Set, class Map>
689 void get_dis_entry (const Set& ext_idx_set, Map& ext_idx_map) const { base::data().get_dis_entry (ext_idx_set, ext_idx_map); }
690
691 template<class Set>
692 void append_dis_indexes (const Set& ext_idx_set) const { base::data().append_dis_indexes (ext_idx_set); }
693 void reset_dis_indexes() const { base::data().reset_dis_indexes(); }
694 void get_dis_indexes (std::set<size_type>& ext_idx_set) const { base::data().get_dis_indexes (ext_idx_set); }
695
696 template<class Set>
697 void set_dis_indexes (const Set& ext_idx_set) const { base::data().set_dis_indexes (ext_idx_set); }
698
699 const T& dis_at (size_type dis_i) const { return base::data().dis_at (dis_i); }
700
701 // get all external pairs (dis_i, values):
702 const scatter_map_type& get_dis_map_entries() const { return base::data().get_dis_map_entries(); }
703
704// global modifiers (for compatibility with distributed interface):
705
706 dis_reference dis_entry (size_type dis_i) { return base::data().dis_entry(dis_i); }
707
708 template<class SetOp = typename details::default_set_op_traits<T>::type>
709 void dis_entry_assembly_begin (SetOp my_set_op = SetOp()) { base::data().dis_entry_assembly_begin (my_set_op); }
710 template<class SetOp = typename details::default_set_op_traits<T>::type>
711 void dis_entry_assembly_end (SetOp my_set_op = SetOp()) { base::data().dis_entry_assembly_end (my_set_op); }
712 template<class SetOp = typename details::default_set_op_traits<T>::type>
713 void dis_entry_assembly (SetOp my_set_op = SetOp()) { base::data().dis_entry_assembly (my_set_op); }
714
715 void dis_entry_assembly_begin() { base::data().template dis_entry_assembly_begin<typename details::default_set_op_traits<T>::type>(); }
716 void dis_entry_assembly_end() { base::data().template dis_entry_assembly_end<typename details::default_set_op_traits<T>::type>(); }
717 void dis_entry_assembly() { dis_entry_assembly_begin(); dis_entry_assembly_end(); }
718
719// apply a partition:
720
721 template<class RepSize>
722 void repartition ( // old_numbering for *this
723 const RepSize& partition, // old_ownership
724 disarray<T,distributed>& new_disarray, // new_ownership (created)
725 RepSize& old_numbering, // new_ownership
726 RepSize& new_numbering) const // old_ownership
727 { return base::data().repartition (partition.data(), new_disarray.data(), old_numbering.data(), new_numbering.data()); }
728
729 template<class RepSize>
730 void permutation_apply ( // old_numbering for *this
731 const RepSize& new_numbering, // old_ownership
732 disarray<T,distributed,A>& new_disarray) const // new_ownership (already allocated)
733 { base::data().permutation_apply (new_numbering.data(), new_disarray.data()); }
734
735 void reverse_permutation ( // old_ownership for *this=iold2dis_inew
736 disarray<size_type,distributed,A>& inew2dis_iold) const // new_ownership
737 { base::data().reverse_permutation (inew2dis_iold.data()); }
738
739// i/o:
740
741 odiststream& put_values (odiststream& ops) const { return base::data().put_values(ops); }
742 idiststream& get_values (idiststream& ips) { return base::data().get_values(ips); }
743 void dump (std::string name) const { return base::data().dump(name); }
744
745 template <class GetFunction>
746 idiststream& get_values (idiststream& ips, GetFunction get_element) { return base::data().get_values(ips, get_element); }
747 template <class PutFunction>
748 odiststream& put_values (odiststream& ops, PutFunction put_element) const { return base::data().put_values(ops, put_element); }
749 template <class PutFunction, class A2> odiststream& permuted_put_values (
750 odiststream& ops, const disarray<size_type,distributed,A2>& perm, PutFunction put_element) const
751 { return base::data().permuted_put_values (ops, perm.data(), put_element); }
752};
753// [verbatim_disarray]
754template <class T, class A>
755inline
757 const distributor& ownership,
758 const T& init_val,
759 const A& alloc)
760 : base(new_macro(rep(ownership,init_val,alloc)))
761{
762}
763template <class T, class A>
764inline
765void
767 const distributor& ownership,
768 const T & init_val)
769{
770 base::data().resize (ownership,init_val);
771}
772#endif // _RHEOLEF_HAVE_MPI
773
774// -------------------------------------------------------------
775// i/o with operator<< & >>
776// -------------------------------------------------------------
777template <class T, class A>
778inline
781{
782 return x.get_values(ips);
783}
784template <class T, class A>
785inline
788{
789 return x.put_values(ops);
790}
791#ifdef _RHEOLEF_HAVE_MPI
792template <class T, class A>
793inline
794idiststream&
796{
797 return x.get_values(ips);
798}
799template <class T, class A>
800inline
803{
804 return x.put_values(ops);
805}
806#endif // _RHEOLEF_HAVE_MPI
807} // namespace rheolef
808
809// -------------------------------------------------------------
810// not inlined : longer code
811// -------------------------------------------------------------
812#include "rheolef/disarray_seq.icc"
813#include "rheolef/disarray_mpi.icc"
814#endif // _RHEO_DISARRAY_H
field::size_type size_type
Definition branch.cc:430
void get_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition disarray.h:689
void set_dis_indexes(const Set &ext_idx_set) const
Definition disarray.h:697
rep::scatter_map_type scatter_map_type
Definition disarray.h:658
const scatter_map_type & get_dis_map_entries() const
Definition disarray.h:702
odiststream & put_values(odiststream &ops) const
Definition disarray.h:741
dis_reference dis_entry(size_type dis_i)
Definition disarray.h:706
const T & dis_at(size_type dis_i) const
Definition disarray.h:699
rep::difference_type difference_type
Definition disarray.h:651
disarray_rep< T, distributed, A > rep
Definition disarray.h:646
odiststream & permuted_put_values(odiststream &ops, const disarray< size_type, distributed, A2 > &perm, PutFunction put_element) const
Definition disarray.h:749
void repartition(const RepSize &partition, disarray< T, distributed > &new_disarray, RepSize &old_numbering, RepSize &new_numbering) const
Definition disarray.h:722
void append_dis_indexes(const Set &ext_idx_set) const
Definition disarray.h:692
odiststream & put_values(odiststream &ops, PutFunction put_element) const
Definition disarray.h:748
void dis_entry_assembly_begin(SetOp my_set_op=SetOp())
Definition disarray.h:709
void permutation_apply(const RepSize &new_numbering, disarray< T, distributed, A > &new_disarray) const
Definition disarray.h:730
rep::const_reference const_reference
Definition disarray.h:656
void dis_entry_assembly_end(SetOp my_set_op=SetOp())
Definition disarray.h:711
void get_dis_indexes(std::set< size_type > &ext_idx_set) const
Definition disarray.h:694
void dis_entry_assembly(SetOp my_set_op=SetOp())
Definition disarray.h:713
void reverse_permutation(disarray< size_type, distributed, A > &inew2dis_iold) const
Definition disarray.h:735
void dump(std::string name) const
Definition disarray.h:743
void append_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition disarray.h:686
const distributor & ownership() const
Definition disarray.h:670
idiststream & get_values(idiststream &ips, GetFunction get_element)
Definition disarray.h:746
const communicator & comm() const
Definition disarray.h:671
idiststream & get_values(idiststream &ips)
Definition disarray.h:742
void reverse_permutation(disarray< size_type, sequential, A > &inew2dis_iold) const
Definition disarray.h:588
rep::const_iterator const_iterator
Definition disarray.h:522
void get_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition disarray.h:570
const_reference dis_at(size_type dis_i) const
Definition disarray.h:544
void set_dis_indexes(const Set &ext_idx_set) const
Definition disarray.h:567
disarray_rep< T, sequential, A > rep
Definition disarray.h:511
const_iterator begin() const
Definition disarray.h:547
odiststream & put_values(odiststream &ops) const
Definition disarray.h:594
dis_reference dis_entry(size_type dis_i)
Definition disarray.h:553
rep::difference_type difference_type
Definition disarray.h:516
void append_dis_indexes(const Set &ext_idx_set) const
Definition disarray.h:568
void repartition(const RepSize &partition, disarray< T, sequential, A > &new_disarray, RepSize &old_numbering, RepSize &new_numbering) const
Definition disarray.h:575
odiststream & put_values(odiststream &ops, PutFunction put_element) const
Definition disarray.h:599
void dis_entry_assembly_begin(SetOp my_set_op=SetOp())
Definition disarray.h:557
void permutation_apply(const RepSize &new_numbering, disarray< T, sequential, A > &new_disarray) const
Definition disarray.h:583
rep::const_reference const_reference
Definition disarray.h:521
void dis_entry_assembly_end(SetOp my_set_op=SetOp())
Definition disarray.h:559
void get_dis_indexes(std::set< size_type > &ext_idx_set) const
Definition disarray.h:565
void dis_entry_assembly(SetOp my_set_op=SetOp())
Definition disarray.h:555
void dump(std::string name) const
Definition disarray.h:600
void append_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition disarray.h:569
const distributor & ownership() const
Definition disarray.h:537
idiststream & get_values(idiststream &ips, GetFunction get_element)
Definition disarray.h:597
const communicator & comm() const
Definition disarray.h:538
idiststream & get_values(idiststream &ips)
Definition disarray.h:595
typename base::value_type value_type
Definition disarray.h:297
void get_dis_entry(const Set &ext_idx_set, Map &ext_idx_map) const
Definition disarray.h:341
void set_dis_indexes(const Set &ext_idx_set) const
Definition disarray.h:350
typename base::const_reference const_reference
Definition disarray.h:302
const scatter_map_type & get_dis_map_entries() const
Definition disarray.h:357
typename base::reference reference
Definition disarray.h:301
dis_reference dis_entry(size_type dis_i)
Definition disarray.h:327
stash_traits< T, is_container >::mapped_type stash_value
Definition disarray.h:417
std::map< size_type, T > scatter_map_type
Definition disarray.h:305
disarray_dis_reference< T, A > dis_reference
Definition disarray.h:306
details::is_container_of_mpi_datatype< T >::type is_container
Definition disarray.h:416
void append_dis_indexes(const Set &ext_idx_set) const
Definition disarray.h:347
const mpi::communicator & comm() const
Definition disarray.h:322
distributor::communicator_type communicator_type
Definition disarray.h:304
typename base::difference_type difference_type
Definition disarray.h:303
typename base::size_type size_type
Definition disarray.h:296
typename base::const_iterator const_iterator
Definition disarray.h:300
void dis_entry_assembly(SetOp my_set_op=SetOp())
Definition disarray.h:334
void set_dis_entry(size_type dis_i, const U &val, const SetOp &set_op)
const distributor & ownership() const
Definition disarray.h:321
stash_traits< T, is_container >::map_type stash_map_type
Definition disarray.h:418
const_reference dis_at(size_type dis_i) const
Definition disarray.h:249
distributor::communicator_type communicator_type
Definition disarray.h:229
void dis_entry_assembly_begin(SetOp=SetOp())
Definition disarray.h:258
base::const_reference const_reference
Definition disarray.h:226
void dis_entry_assembly_end(SetOp=SetOp())
Definition disarray.h:260
void repartition(const disarray_rep< size_type, sequential, A > &partition, disarray_rep< T, sequential, A > &new_disarray, disarray_rep< size_type, sequential, A > &old_numbering, disarray_rep< size_type, sequential, A > &new_numbering) const
Definition disarray.h:261
const distributor & ownership() const
Definition disarray.h:245
reference dis_entry(size_type dis_i)
Definition disarray.h:254
see the disarray page for the full documentation
Definition disarray.h:497
disarray_rep< T, sequential, A > rep
Definition disarray.h:500
rep::base::const_iterator const_iterator
Definition disarray.h:503
rep::base::iterator iterator
Definition disarray.h:502
rep::base::size_type size_type
Definition disarray.h:501
see the distributor page for the full documentation
Definition distributor.h:69
size_type last_index(size_type iproc) const
size_type dis_size() const
global and local sizes
communicator communicator_type
Definition distributor.h:79
size_type first_index(size_type iproc) const
global index range and local size owned by ip-th process
const communicator_type & comm() const
idiststream: see the diststream page for the full documentation
Definition diststream.h:336
odiststream: see the diststream page for the full documentation
Definition diststream.h:137
see the smart_pointer page for the full documentation
#define trace_macro(message)
Definition dis_macros.h:111
#define error_macro(message)
Definition dis_macros.h:49
Expr1::float_type T
Definition field_expr.h:230
verbose clean transpose logscale grid shrink ball stereo iso volume skipvtk deformation fastfieldload lattice reader_on_stdin color format format format format format format format format format format format format format format format format format format dump
This file is part of Rheolef.
std::ostream & operator<<(std::ostream &os, const catchmark &m)
Definition catchmark.h:99
std::istream & operator>>(std::istream &is, const catchmark &m)
Definition catchmark.h:88
t operator()(const t &a, const t &b)
Definition space.cc:386
STL namespace.
disarray element input helper
Definition disarray.h:205
std::istream & operator()(std::istream &is, T &x) const
Definition disarray.h:206
disarray element output helper
Definition disarray.h:196
std::ostream & operator()(std::ostream &os, const T &x) const
Definition disarray.h:197
std::ostream & operator()(std::ostream &os, const T &x) const
Definition disarray.h:201
disarray_rep< T, distributed, A > & _x
Definition disarray.h:482
disarray_dis_reference< T, A > & operator-=(const U &value)
Definition disarray.h:475
disarray_dis_reference< T, A > & operator=(const disarray_dis_reference< T, A > &r)
Definition disarray.h:456
disarray_dis_reference(disarray_rep< T, distributed, A > &x, size_type dis_i)
Definition disarray.h:448
typename disarray_rep< T, distributed, A >::size_type size_type
Definition disarray.h:446
disarray_dis_reference< T, A > & operator+=(const U &value)
Definition disarray.h:468
disarray_dis_reference(const disarray_dis_reference< T, A > &r)
Definition disarray.h:452
std::vector< std::pair< size_type, stash_value > > data
Definition disarray.h:424
std::list< std::pair< size_type, mpi::request > > waits
Definition disarray.h:423
std::pair< typename std::decay< T1 >::type, typename std::decay< T2 >::type > type
Definition disarray.h:403
remove_const_in_pair< typenameU::value_type >::type mapped_type
Definition disarray.h:413
Expr1::memory_type M