Debian Codegraph @

include/deal.II/multigrid/mg_transfer_component.templates.h

raw
1 // ------------------------------------------------------------------------
2 //
3 // SPDX-License-Identifier: LGPL-2.1-or-later
4 // Copyright (C) 2007 - 2023 by the deal.II authors
5 //
6 // This file is part of the deal.II library.
7 //
8 // Part of the source code is dual licensed under Apache-2.0 WITH
9 // LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10 // governing the source code and code contributions can be found in
11 // LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12 //
13 // ------------------------------------------------------------------------
14
15
16 #ifndef dealii_mg_transfer_component_templates_h
17 #define dealii_mg_transfer_component_templates_h
18
19 #include <deal.II/base/config.h>
20
21 #include <deal.II/dofs/dof_accessor.h>
22
23 #include <deal.II/fe/fe.h>
24
25 #include <deal.II/grid/tria_iterator.h>
26
27 #include <deal.II/lac/affine_constraints.h>
28 #include <deal.II/lac/sparse_matrix.h>
29
30 #include <deal.II/multigrid/mg_base.h>
31 #include <deal.II/multigrid/mg_tools.h>
32 #include <deal.II/multigrid/mg_transfer_component.h>
33
34 #include <deal.II/numerics/data_out.h>
35
36 #include <algorithm>
37 #include <fstream>
38 #include <sstream>
39
40 DEAL_II_NAMESPACE_OPEN
41
42 /* --------------------- MGTransferSelect -------------- */
43
44
45
46 template <typename number>
47 template <int dim, typename number2, int spacedim>
48 void
49 MGTransferSelect<number>::copy_to_mg(
50 const DoFHandler<dim, spacedim> &mg_dof_handler,
51 MGLevelObject<Vector<number>> &dst,
52 const BlockVector<number2> &src) const
53 {
54 do_copy_to_mg(mg_dof_handler,
55 dst,
56 src.block(target_component[selected_component]));
57 }
58
59
60
61 template <typename number>
62 template <int dim, typename number2, int spacedim>
63 void
64 MGTransferSelect<number>::copy_to_mg(
65 const DoFHandler<dim, spacedim> &mg_dof_handler,
66 MGLevelObject<Vector<number>> &dst,
67 const Vector<number2> &src) const
68 {
69 do_copy_to_mg(mg_dof_handler, dst, src);
70 }
71
72
73
74 template <typename number>
75 template <int dim, typename number2, int spacedim>
76 void
77 MGTransferSelect<number>::copy_from_mg(
78 const DoFHandler<dim, spacedim> &mg_dof_handler,
79 BlockVector<number2> &dst,
80 const MGLevelObject<Vector<number>> &src) const
81 {
82 dst = 0;
83 do_copy_from_mg(mg_dof_handler,
84 dst.block(target_component[selected_component]),
85 src);
86 if (constraints != nullptr)
87 constraints->condense(dst);
88 }
89
90
91
92 template <typename number>
93 template <int dim, typename number2, int spacedim>
94 void
95 MGTransferSelect<number>::copy_from_mg(
96 const DoFHandler<dim, spacedim> &mg_dof_handler,
97 Vector<number2> &dst,
98 const MGLevelObject<Vector<number>> &src) const
99 {
100 dst = 0;
101 do_copy_from_mg(mg_dof_handler, dst, src);
102 if (constraints != nullptr)
103 {
104 // If we were given constraints
105 // apply them to the dst that goes
106 // back now to the linear solver.
107 // Since constraints are globally
108 // defined create a global vector here
109 // and copy dst to the right component,
110 // apply the constraints then and copy
111 // the block back to dst.
112 const unsigned int n_blocks =
113 *std::max_element(target_component.begin(), target_component.end()) + 1;
114 const std::vector<types::global_dof_index> dofs_per_block =
115 DoFTools::count_dofs_per_fe_block(mg_dof_handler, target_component);
116 BlockVector<number> tmp;
117 tmp.reinit(n_blocks);
118 for (unsigned int b = 0; b < n_blocks; ++b)
119 tmp.block(b).reinit(dofs_per_block[b]);
120 tmp.collect_sizes();
121 tmp.block(target_component[selected_component]) = dst;
122 constraints->condense(tmp);
123 dst = tmp.block(target_component[selected_component]);
124 }
125 }
126
127
128
129 template <typename number>
130 template <int dim, typename number2, int spacedim>
131 void
132 MGTransferSelect<number>::copy_from_mg_add(
133 const DoFHandler<dim, spacedim> &mg_dof_handler,
134 BlockVector<number2> &dst,
135 const MGLevelObject<Vector<number>> &src) const
136 {
137 do_copy_from_mg_add(mg_dof_handler, dst, src);
138 }
139
140
141
142 template <typename number>
143 template <int dim, typename number2, int spacedim>
144 void
145 MGTransferSelect<number>::copy_from_mg_add(
146 const DoFHandler<dim, spacedim> &mg_dof_handler,
147 Vector<number2> &dst,
148 const MGLevelObject<Vector<number>> &src) const
149 {
150 do_copy_from_mg_add(mg_dof_handler, dst, src);
151 }
152
153
154
155 template <typename number>
156 template <int dim, class OutVector, int spacedim>
157 void
158 MGTransferSelect<number>::do_copy_from_mg(
159 const DoFHandler<dim, spacedim> &mg_dof_handler,
160 OutVector &dst,
161 const MGLevelObject<Vector<number>> &src) const
162 {
163 typename DoFHandler<dim, spacedim>::active_cell_iterator level_cell =
164 mg_dof_handler.begin_active();
165 const typename DoFHandler<dim, spacedim>::active_cell_iterator endc =
166 mg_dof_handler.end();
167
168 // traverse all cells and copy the
169 // data appropriately to the output
170 // vector
171
172 // Note that the level is increasing monotonically
173 dst = 0;
174 for (; level_cell != endc; ++level_cell)
175 {
176 const unsigned int level = level_cell->level();
177 using IT = std::vector<
178 std::pair<types::global_dof_index, unsigned int>>::const_iterator;
179 for (IT i = copy_to_and_from_indices[level].begin();
180 i != copy_to_and_from_indices[level].end();
181 ++i)
182 dst(i->first) = src[level](i->second);
183 }
184 }
185
186
187 template <typename number>
188 template <int dim, class OutVector, int spacedim>
189 void
190 MGTransferSelect<number>::do_copy_from_mg_add(
191 const DoFHandler<dim, spacedim> &mg_dof_handler,
192 OutVector &dst,
193 const MGLevelObject<Vector<number>> &src) const
194 {
195 typename DoFHandler<dim, spacedim>::active_cell_iterator level_cell =
196 mg_dof_handler.begin_active();
197 const typename DoFHandler<dim, spacedim>::active_cell_iterator endc =
198 mg_dof_handler.end();
199
200 // traverse all cells and copy the
201 // data appropriately to the output
202 // vector
203
204 // Note that the level is increasing monotonically
205 dst = 0;
206 for (; level_cell != endc; ++level_cell)
207 {
208 const unsigned int level = level_cell->level();
209 using IT = std::vector<
210 std::pair<types::global_dof_index, unsigned int>>::const_iterator;
211 for (IT i = copy_to_and_from_indices[level].begin();
212 i != copy_to_and_from_indices[level].end();
213 ++i)
214 dst(i->first) += src[level](i->second);
215 }
216 }
217
218
219 template <typename number>
220 std::size_t
221 MGTransferSelect<number>::memory_consumption() const
222 {
223 return sizeof(int) + MGTransferComponentBase::memory_consumption();
224 }
225
226
227
228 DEAL_II_NAMESPACE_CLOSE
229
230 #endif