Stokhos Package Browser (Single Doxygen Collection)  Version of the Day
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Stokhos_ProductContainerImp.hpp
Go to the documentation of this file.
1 // @HEADER
2 // *****************************************************************************
3 // Stokhos Package
4 //
5 // Copyright 2009 NTESS and the Stokhos contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9 
10 template <typename coeff_type>
11 Stokhos::ProductContainer<coeff_type>::
12 ProductContainer() :
13  map_(),
14  coeff_()
15 {
16 }
17 
18 template <typename coeff_type>
19 Stokhos::ProductContainer<coeff_type>::
20 ProductContainer(const Teuchos::RCP<const Epetra_BlockMap>& theMap) :
21  map_(theMap),
22  coeff_(map_->NumMyElements())
23 {
24 }
25 
26 template <typename coeff_type>
27 Stokhos::ProductContainer<coeff_type>::
28 ProductContainer(const Teuchos::RCP<const Epetra_BlockMap>& theMap,
29  const typename traits_type::cloner_type& cloner) :
30  map_(theMap),
31  coeff_(map_->NumMyElements())
32 {
33  ordinal_type sz = map_->NumMyElements();
34  for (ordinal_type i=0; i<sz; i++)
35  coeff_[i] = cloner.clone(i);
36 }
37 
38 template <typename coeff_type>
39 Stokhos::ProductContainer<coeff_type>::
40 ProductContainer(const Stokhos::ProductContainer<coeff_type>& v) :
41  map_(v.map_),
42  coeff_(v.coeff_)
43 {
44 }
45 
46 template <typename coeff_type>
47 Stokhos::ProductContainer<coeff_type>::
48 ~ProductContainer()
49 {
50 }
51 
52 template <typename coeff_type>
53 Stokhos::ProductContainer<coeff_type>&
54 Stokhos::ProductContainer<coeff_type>::
55 operator=(const Stokhos::ProductContainer<coeff_type>& v)
56 {
57  if (this != &v) {
58  map_ = v.map_;
59  coeff_ = v.coeff_;
60  }
61  return *this;
62 }
63 
64 template <typename coeff_type>
65 void
66 Stokhos::ProductContainer<coeff_type>::
67 reset(const Teuchos::RCP<const Epetra_BlockMap>& theMap)
68 {
69  map_ = theMap;
70  ordinal_type sz = map_->NumMyElements();
71  coeff_.resize(sz);
72 }
73 
74 template <typename coeff_type>
75 void
76 Stokhos::ProductContainer<coeff_type>::
77 reset(const Teuchos::RCP<const Epetra_BlockMap>& theMap,
78  const typename traits_type::cloner_type& cloner)
79 {
80  map_ = theMap;
81  ordinal_type sz = map_->NumMyElements();
82  coeff_.resize(sz);
83  for (ordinal_type i=0; i<sz; i++)
84  coeff_[i] = cloner.clone(i);
85 }
86 
87 template <typename coeff_type>
88 void
89 Stokhos::ProductContainer<coeff_type>::
90 resize(const Teuchos::RCP<const Epetra_BlockMap>& theMap)
91 {
92  map_ = theMap;
93  coeff_.resize(map_->NumMyElements());
94 }
95 
96 template <typename coeff_type>
97 void
98 Stokhos::ProductContainer<coeff_type>::
99 reserve(ordinal_type sz)
100 {
101  coeff_.reserve(sz);
102 }
103 
104 template <typename coeff_type>
105 typename Stokhos::ProductContainer<coeff_type>::ordinal_type
106 Stokhos::ProductContainer<coeff_type>::
107 size() const
108 {
109  return coeff_.size();
110 }
111 
112 template <typename coeff_type>
113 Teuchos::RCP<const Epetra_BlockMap>
114 Stokhos::ProductContainer<coeff_type>::
115 map() const
116 {
117  return map_;
118 }
119 
120 template <typename coeff_type>
121 const Teuchos::Array<Teuchos::RCP<coeff_type> >&
122 Stokhos::ProductContainer<coeff_type>::
123 getCoefficients() const
124 {
125  return coeff_;
126 }
127 
128 template <typename coeff_type>
129 Teuchos::Array<Teuchos::RCP<coeff_type> >&
130 Stokhos::ProductContainer<coeff_type>::
131 getCoefficients()
132 {
133  return coeff_;
134 }
135 
136 template <typename coeff_type>
137 Teuchos::RCP<coeff_type>
138 Stokhos::ProductContainer<coeff_type>::
139 getCoeffPtr(ordinal_type i)
140 {
141  return coeff_[i];
142 }
143 
144 template <typename coeff_type>
145 Teuchos::RCP<const coeff_type>
146 Stokhos::ProductContainer<coeff_type>::
147 getCoeffPtr(ordinal_type i) const
148 {
149  return coeff_[i];
150 }
151 
152 template <typename coeff_type>
153 void
154 Stokhos::ProductContainer<coeff_type>::
155 setCoeffPtr(ordinal_type i, const Teuchos::RCP<coeff_type>& c)
156 {
157  coeff_[i] = c;
158 }
159 
160 template <typename coeff_type>
161 coeff_type&
162 Stokhos::ProductContainer<coeff_type>::
163 operator[](ordinal_type i)
164 {
165  return *(coeff_[i]);
166 }
167 
168 template <typename coeff_type>
169 const coeff_type&
170 Stokhos::ProductContainer<coeff_type>::
171 operator[](ordinal_type i) const
172 {
173  return *(coeff_[i]);
174 }
175 
176 template <typename coeff_type>
177 bool
178 Stokhos::ProductContainer<coeff_type>::
179 myGID(int i) const
180 {
181  return map_->MyGID(i);
182 }
183 
184 template <typename coeff_type>
185 void
186 Stokhos::ProductContainer<coeff_type>::
187 init(const value_type& val)
188 {
189  ordinal_type sz = coeff_.size();
190  for (ordinal_type i=0; i<sz; i++)
191  traits_type::init(*(coeff_[i]), val);
192 }
193 
194 template <typename coeff_type>
195 std::ostream&
196 Stokhos::ProductContainer<coeff_type>::
197 print(std::ostream& os) const
198 {
199  Teuchos::Array<ordinal_type> trm;
200  ordinal_type sz = coeff_.size();
201  os << "Stokhos::ProductContainer of global size " << map_->NumGlobalElements()
202  << ", local size " << sz << ":" << std::endl;
203  for (ordinal_type i=0; i<sz; i++) {
204  os << "Term " << map_->GID(i) << ":" << std::endl;
205  traits_type::print(os, *(coeff_[i]));
206  }
207 
208  return os;
209 }
Stokhos::ProductContainer::map
Teuchos::RCP< const Epetra_BlockMap > map() const
Return container map.
Definition: Stokhos_ProductContainerImp.hpp:115
Stokhos::ProductContainer::setCoeffPtr
void setCoeffPtr(ordinal_type i, const Teuchos::RCP< coeff_type > &c)
Set coefficient i to c.
Definition: Stokhos_ProductContainerImp.hpp:155
Stokhos::ProductContainer::myGID
bool myGID(int i) const
Return whether global index i resides on this processor.
Definition: Stokhos_ProductContainerImp.hpp:179
Stokhos::ProductContainer::operator=
ProductContainer & operator=(const ProductContainer &)
Assignment.
Definition: Stokhos_ProductContainerImp.hpp:55
Stokhos::ProductContainer::init
void init(const value_type &val)
Initialize coefficients.
Definition: Stokhos_ProductContainerImp.hpp:187
Stokhos::ProductContainer::operator[]
coeff_type & operator[](ordinal_type i)
Array access.
Definition: Stokhos_ProductContainerImp.hpp:163
Epetra_BlockMap::NumMyElements
int NumMyElements() const
Stokhos::ProductContainer::map_
Teuchos::RCP< const Epetra_BlockMap > map_
Container map.
Definition: Stokhos_ProductContainer.hpp:144
Stokhos::ProductContainer::getCoefficients
const Teuchos::Array< Teuchos::RCP< coeff_type > > & getCoefficients() const
Return array of coefficients.
Definition: Stokhos_ProductContainerImp.hpp:123
Stokhos::ProductContainer::reset
void reset(const Teuchos::RCP< const Epetra_BlockMap > &map)
Resize to new map map.
Definition: Stokhos_ProductContainerImp.hpp:67
Stokhos::ProductContainer::coeff_
Teuchos::Array< Teuchos::RCP< coeff_type > > coeff_
Array of polynomial coefficients.
Definition: Stokhos_ProductContainer.hpp:147
Stokhos::ProductContainer::getCoeffPtr
Teuchos::RCP< coeff_type > getCoeffPtr(ordinal_type i)
Return ref-count pointer to coefficient i.
Definition: Stokhos_ProductContainerImp.hpp:139
Stokhos::ProductContainer
A product (in the mathematical sense) container class whose coefficients are vectors, operators, or in general any type that would have an expensive copy constructor.
Definition: Stokhos_ProductContainer.hpp:29
Stokhos::ProductContainer::ordinal_type
traits_type::ordinal_type ordinal_type
Typename of ordinals.
Definition: Stokhos_ProductContainer.hpp:39
val
expr val()
Teuchos::Array::size
size_type size() const
Stokhos::ProductContainer::print
std::ostream & print(std::ostream &os) const
Print polynomial.
Definition: Stokhos_ProductContainerImp.hpp:197
Stokhos::ProductContainer::value_type
traits_type::value_type value_type
Typename of values.
Definition: Stokhos_ProductContainer.hpp:36
Stokhos::ProductContainer::reserve
void reserve(ordinal_type sz)
Reserve space for a size sz container.
Definition: Stokhos_ProductContainerImp.hpp:99
Stokhos::ProductContainer::size
ordinal_type size() const
Return size.
Definition: Stokhos_ProductContainerImp.hpp:107
Stokhos::ProductContainer::resize
void resize(const Teuchos::RCP< const Epetra_BlockMap > &map)
Resize to map map.
Definition: Stokhos_ProductContainerImp.hpp:90
Generated on Fri Nov 22 2024 09:18:13 for Stokhos Package Browser (Single Doxygen Collection) by   doxygen 1.8.5