← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rheolef/trusty

« back to all changes in this revision

Viewing changes to nfem/geo_element/hack_array_seq.icc

  • Committer: Package Import Robot
  • Author(s): Pierre Saramito
  • Date: 2012-04-06 09:12:21 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20120406091221-m58me99p1nxqui49
Tags: 6.0-1
http://bugs.debian.org/667356
http://bugs.debian.org/661689
* New upstream release 6.0 (major changes):
  - massively distributed and parallel support
  - full FEM characteristic method (Lagrange-Gakerkin method) support
  - enhanced users documentation 
  - source code supports g++-4.7 (closes: #667356)
* debian/control: dependencies for MPI distributed solvers added
* debian/rules: build commands simplified
* debian/librheolef-dev.install: man1/* to man9/* added
* debian/changelog: package description rewritted (closes: #661689)

Show diffs side-by-side

added added

removed removed

Lines of Context:
nfem/geo_element/hack_array_seq.icc
 
1
///
 
2
/// This file is part of Rheolef.
 
3
///
 
4
/// Copyright (C) 2000-2009 Pierre Saramito <Pierre.Saramito@imag.fr>
 
5
///
 
6
/// Rheolef is free software; you can redistribute it and/or modify
 
7
/// it under the terms of the GNU General Public License as published by
 
8
/// the Free Software Foundation; either version 2 of the License, or
 
9
/// (at your option) any later version.
 
10
///
 
11
/// Rheolef is distributed in the hope that it will be useful,
 
12
/// but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
/// GNU General Public License for more details.
 
15
///
 
16
/// You should have received a copy of the GNU General Public License
 
17
/// along with Rheolef; if not, write to the Free Software
 
18
/// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
/// 
 
20
/// =========================================================================
 
21
# include "rheolef/hack_array.h"
 
22
namespace rheolef {
 
23
 
 
24
// ===============================================================
 
25
// allocators
 
26
// ===============================================================
 
27
template<class T, class A>
 
28
hack_array_seq_rep<T,A>::hack_array_seq_rep (const A& alloc) 
 
29
 : base (alloc),
 
30
   _ownership  (),
 
31
   _parameter  (),
 
32
   _value_size (),
 
33
   _data_size  ()
 
34
{
 
35
}
 
36
template<class T, class A>
 
37
hack_array_seq_rep<T,A>::hack_array_seq_rep (const distributor& ownership, const parameter_type& param, const A& alloc) 
 
38
 : base (alloc),
 
39
   _ownership  (ownership),
 
40
   _parameter  (param),
 
41
   _value_size (T::_size_of  (_parameter)),
 
42
   _data_size  (T::_data_size(_parameter))
 
43
{
 
44
  _init (_ownership, _parameter);
 
45
}
 
46
template<class T, class A>
 
47
hack_array_seq_rep<T,A>::hack_array_seq_rep (size_type n, const parameter_type& param, const A& alloc) 
 
48
 : base (alloc),
 
49
   _ownership  (distributor::decide, communicator(), n),
 
50
   _parameter  (param),
 
51
   _value_size (T::_size_of  (_parameter)),
 
52
   _data_size  (T::_data_size(_parameter))
 
53
{
 
54
  _init (_ownership, _parameter);
 
55
}
 
56
template<class T, class A>
 
57
void
 
58
hack_array_seq_rep<T,A>::resize (const distributor& ownership, const parameter_type& param) 
 
59
{
 
60
  _ownership  = ownership;
 
61
  _parameter  = param;
 
62
  _value_size = T::_size_of  (_parameter);
 
63
  _data_size  = T::_data_size(_parameter);
 
64
  _init (_ownership, _parameter);
 
65
}
 
66
template<class T, class A>
 
67
void
 
68
hack_array_seq_rep<T,A>::resize (size_type n, const parameter_type& param)
 
69
{
 
70
  _ownership  = distributor  (distributor::decide, communicator(), n);
 
71
  _parameter  = param;
 
72
  _value_size = T::_size_of  (_parameter);
 
73
  _data_size  = T::_data_size(_parameter);
 
74
  _init (_ownership, _parameter);
 
75
} 
 
76
template<class T, class A>
 
77
void
 
78
hack_array_seq_rep<T,A>::_init (const distributor& ownership, const parameter_type& param) 
 
79
{
 
80
  base::_ownership = distributor (ownership.dis_size()*_value_size, ownership.comm(), ownership.size()*_value_size),
 
81
  base::resize (base::_ownership, std::numeric_limits<raw_type>::max());
 
82
  size_type *p = base::begin().operator->();
 
83
  for (size_type i = 0, n = ownership.size(); i < n; i++) {
 
84
    new (p) T;
 
85
    T* q = (T*)p;
 
86
    q -> _set_parameter(param);
 
87
    p += _value_size;
 
88
  }
 
89
}
 
90
// ===============================================================
 
91
// put & get
 
92
// ===============================================================
 
93
template <class T, class A>
 
94
template <class PutFunction>
 
95
odiststream&
 
96
hack_array_seq_rep<T,A>::put_values (odiststream& ops, PutFunction put_element) const
 
97
{
 
98
  std::ostream& os = ops.os();
 
99
  for (size_type i = 0; i < size(); i++) {
 
100
    put_element (os, operator[](i));
 
101
    os << std::endl;
 
102
  }
 
103
  return ops;
 
104
}
 
105
template <class T, class A>
 
106
odiststream&
 
107
hack_array_seq_rep<T,A>::put_values (odiststream& ops) const
 
108
{
 
109
  return put_values (ops, _array_put_element_type<generic_value_type>());
 
110
}
 
111
template <class T, class A>
 
112
template <class GetFunction>
 
113
idiststream&
 
114
hack_array_seq_rep<T,A>::get_values (idiststream& ips, GetFunction get_element) {
 
115
  check_macro (load_chunk (ips.is(), begin(), end(), get_element), "read failed on input stream.");
 
116
  return ips;
 
117
}
 
118
template <class T, class A>
 
119
idiststream&
 
120
hack_array_seq_rep<T,A>::get_values (idiststream& ips) 
 
121
{
 
122
  return get_values (ips, _array_get_element_type<generic_value_type>());
 
123
}
 
124
 
 
125
} // namespace rheolef