1 // rbOOmit: An implementation of the Certified Reduced Basis method.
2 // Copyright (C) 2009, 2010 David J. Knezevic
3
4 // This file is part of rbOOmit.
5
6 // rbOOmit is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10
11 // rbOOmit 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 GNU
14 // Lesser General Public License for more details.
15
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
20 // rbOOmit includes
21 #include "libmesh/rb_assembly_expansion.h"
22 #include "libmesh/elem_assembly.h"
23
24 namespace libMesh
25 {
26
27 // ------------------------------------------------------------
28 // RBAssemblyExpansion implementation
29
RBAssemblyExpansion()30 RBAssemblyExpansion::RBAssemblyExpansion()
31 {
32 }
33
perform_A_interior_assembly(unsigned int q,FEMContext & context)34 void RBAssemblyExpansion::perform_A_interior_assembly(unsigned int q,
35 FEMContext & context)
36 {
37 libmesh_error_msg_if(q >= get_n_A_terms(),
38 "Error: We must have q < get_n_A_terms in perform_A_interior_assembly.");
39
40 libmesh_assert(_A_assembly_vector[q]);
41
42 return _A_assembly_vector[q]->interior_assembly( context );
43 }
44
perform_A_boundary_assembly(unsigned int q,FEMContext & context)45 void RBAssemblyExpansion::perform_A_boundary_assembly(unsigned int q,
46 FEMContext & context)
47 {
48 libmesh_error_msg_if(q >= get_n_A_terms(),
49 "Error: We must have q < get_n_A_terms in perform_A_boundary_assembly.");
50
51 libmesh_assert(_A_assembly_vector[q]);
52
53 return _A_assembly_vector[q]->boundary_assembly( context );
54 }
55
perform_F_interior_assembly(unsigned int q,FEMContext & context)56 void RBAssemblyExpansion::perform_F_interior_assembly(unsigned int q,
57 FEMContext & context)
58 {
59 libmesh_error_msg_if(q >= get_n_F_terms(),
60 "Error: We must have q < get_n_F_terms in perform_F_interior_assembly.");
61
62 libmesh_assert(_A_assembly_vector[q]);
63
64 return _F_assembly_vector[q]->interior_assembly( context );
65 }
66
perform_F_boundary_assembly(unsigned int q,FEMContext & context)67 void RBAssemblyExpansion::perform_F_boundary_assembly(unsigned int q,
68 FEMContext & context)
69 {
70 libmesh_error_msg_if(q >= get_n_F_terms(),
71 "Error: We must have q < get_n_F_terms in perform_F_interior_assembly.");
72
73 libmesh_assert(_A_assembly_vector[q]);
74
75 return _F_assembly_vector[q]->boundary_assembly( context );
76 }
77
perform_output_interior_assembly(unsigned int output_index,unsigned int q_l,FEMContext & context)78 void RBAssemblyExpansion::perform_output_interior_assembly(unsigned int output_index,
79 unsigned int q_l,
80 FEMContext & context)
81 {
82 libmesh_error_msg_if((output_index >= get_n_outputs()) || (q_l >= get_n_output_terms(output_index)),
83 "Error: We must have output_index < n_outputs and "
84 "q_l < get_n_output_terms(output_index) in perform_output_interior_assembly.");
85
86 libmesh_assert(_output_assembly_vector[output_index][q_l]);
87
88 return _output_assembly_vector[output_index][q_l]->interior_assembly(context);
89 }
90
perform_output_boundary_assembly(unsigned int output_index,unsigned int q_l,FEMContext & context)91 void RBAssemblyExpansion::perform_output_boundary_assembly(unsigned int output_index,
92 unsigned int q_l,
93 FEMContext & context)
94 {
95 libmesh_error_msg_if((output_index >= get_n_outputs()) || (q_l >= get_n_output_terms(output_index)),
96 "Error: We must have output_index < n_outputs and "
97 "q_l < get_n_output_terms(output_index) in perform_output_boundary_assembly.");
98
99 libmesh_assert(_output_assembly_vector[output_index][q_l]);
100
101 return _output_assembly_vector[output_index][q_l]->boundary_assembly(context);
102 }
103
get_n_A_terms()104 unsigned int RBAssemblyExpansion::get_n_A_terms() const
105 {
106 return cast_int<unsigned int>
107 (_A_assembly_vector.size());
108 }
109
get_n_F_terms()110 unsigned int RBAssemblyExpansion::get_n_F_terms() const
111 {
112 return cast_int<unsigned int>
113 (_F_assembly_vector.size());
114 }
115
get_n_outputs()116 unsigned int RBAssemblyExpansion::get_n_outputs() const
117 {
118 return cast_int<unsigned int>
119 (_output_assembly_vector.size());
120 }
121
get_n_output_terms(unsigned int index)122 unsigned int RBAssemblyExpansion::get_n_output_terms(unsigned int index) const
123 {
124 libmesh_error_msg_if(index >= get_n_outputs(), "Error: We must have index < n_outputs in get_Q_l.");
125
126 return cast_int<unsigned int>
127 (_output_assembly_vector[index].size());
128 }
129
attach_A_assembly(ElemAssembly * Aq_assembly)130 void RBAssemblyExpansion::attach_A_assembly(ElemAssembly * Aq_assembly)
131 {
132 _A_assembly_vector.push_back(Aq_assembly);
133 }
134
attach_multiple_A_assembly(std::vector<std::unique_ptr<ElemAssembly>> & Aq_assembly)135 void RBAssemblyExpansion::attach_multiple_A_assembly(std::vector<std::unique_ptr<ElemAssembly>> & Aq_assembly)
136 {
137 for (auto & up : Aq_assembly)
138 _A_assembly_vector.push_back(up.get());
139 }
140
attach_F_assembly(ElemAssembly * Fq_assembly)141 void RBAssemblyExpansion::attach_F_assembly(ElemAssembly * Fq_assembly)
142 {
143 _F_assembly_vector.push_back(Fq_assembly);
144 }
145
attach_multiple_F_assembly(std::vector<std::unique_ptr<ElemAssembly>> & Fq_assembly)146 void RBAssemblyExpansion::attach_multiple_F_assembly(std::vector<std::unique_ptr<ElemAssembly>> & Fq_assembly)
147 {
148 for (auto & up : Fq_assembly)
149 _F_assembly_vector.push_back(up.get());
150 }
151
attach_output_assembly(std::vector<std::unique_ptr<ElemAssembly>> & output_assembly)152 void RBAssemblyExpansion::attach_output_assembly(std::vector<std::unique_ptr<ElemAssembly>> & output_assembly)
153 {
154 std::vector<ElemAssembly *> output_assembly_ptr;
155 for (auto & up : output_assembly)
156 output_assembly_ptr.push_back(up.get());
157
158 _output_assembly_vector.push_back(output_assembly_ptr);
159 }
160
attach_output_assembly(std::vector<ElemAssembly * > output_assembly)161 void RBAssemblyExpansion::attach_output_assembly(std::vector<ElemAssembly *> output_assembly)
162 {
163 _output_assembly_vector.push_back(output_assembly);
164 }
165
attach_output_assembly(ElemAssembly * output_assembly)166 void RBAssemblyExpansion::attach_output_assembly(ElemAssembly * output_assembly)
167 {
168 std::vector<ElemAssembly *> L_vector(1); L_vector[0] = output_assembly;
169
170 attach_output_assembly(L_vector);
171 }
172
get_A_assembly(unsigned int q)173 ElemAssembly & RBAssemblyExpansion::get_A_assembly(unsigned int q)
174 {
175 libmesh_error_msg_if(q >= get_n_A_terms(),
176 "Error: We must have q < get_n_A_terms in get_A_assembly.");
177
178 return *_A_assembly_vector[q];
179 }
180
get_F_assembly(unsigned int q)181 ElemAssembly & RBAssemblyExpansion::get_F_assembly(unsigned int q)
182 {
183 libmesh_error_msg_if(q >= get_n_F_terms(),
184 "Error: We must have q < get_n_F_terms in get_F_assembly.");
185
186 return *_F_assembly_vector[q];
187 }
188
get_output_assembly(unsigned int output_index,unsigned int q_l)189 ElemAssembly & RBAssemblyExpansion::get_output_assembly(unsigned int output_index,
190 unsigned int q_l)
191 {
192 libmesh_error_msg_if((output_index >= get_n_outputs()) || (q_l >= get_n_output_terms(output_index)),
193 "Error: We must have output_index < n_outputs and "
194 "q_l < get_n_output_terms(output_index) in get_output_assembly.");
195
196 return *_output_assembly_vector[output_index][q_l];
197 }
198
199 }
200