Loading [MathJax]/extensions/tex2jax.js
OGS
AddProcessDataToMesh.cpp File Reference

Detailed Description

Definition in file AddProcessDataToMesh.cpp.

Include dependency graph for AddProcessDataToMesh.cpp:

Go to the source code of this file.

Namespaces

namespace  ProcessLib
 

Functions

static void addOgsVersion (MeshLib::Mesh &mesh)
 
static void addSecondaryVariableNodes (NumLib::Time const &t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, ProcessLib::SecondaryVariable const &var, std::string const &output_name, MeshLib::Mesh &mesh)
 
static void addSecondaryVariableResiduals (NumLib::Time const &t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, ProcessLib::SecondaryVariable const &var, std::string const &output_name, MeshLib::Mesh &mesh)
 
static std::vector< double > copySolutionVector (GlobalVector const &x)
 
MeshLib::PropertyVector< std::size_t > const * getBulkNodeIdMapForPetscIfNecessary (MeshLib::Mesh const &mesh, NumLib::LocalToGlobalIndexMap const &dof_table, NumLib::LocalToGlobalIndexMap const &bulk_mesh_dof_table)
 
static GlobalIndexType getIndexForComponentInSolutionVector (std::size_t const mesh_id, std::size_t const node_id, bool const is_ghost_node, int const global_component_id, GlobalVector const &x, NumLib::LocalToGlobalIndexMap const &dof_table, NumLib::LocalToGlobalIndexMap const &bulk_mesh_dof_table, MeshLib::PropertyVector< std::size_t > const *const bulk_node_id_map)
 
static bool isGhostNode (MeshLib::Mesh const &mesh, std::size_t const node_id)
 
static std::set< std::string > addPrimaryVariablesToMesh (MeshLib::Mesh &mesh, GlobalVector const &x, std::vector< std::reference_wrapper< ProcessLib::ProcessVariable > > const &process_variables, std::set< std::string > const &output_variables, NumLib::LocalToGlobalIndexMap const &dof_table, NumLib::LocalToGlobalIndexMap const &bulk_mesh_dof_table)
 
static void addSecondaryVariablesToMesh (ProcessLib::SecondaryVariableCollection const &secondary_variables, std::set< std::string > &names_of_already_output_variables, NumLib::Time const &t, std::vector< GlobalVector * > const &xs, MeshLib::Mesh &mesh, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, bool const output_residuals)
 
void ProcessLib::addProcessDataToMesh (NumLib::Time const &t, std::vector< GlobalVector * > const &xs, int const process_id, ProcessOutputData const &process_output_data, bool const output_secondary_variables, OutputDataSpecification const &process_output)
 

Function Documentation

◆ addOgsVersion()

static void addOgsVersion ( MeshLib::Mesh & mesh)
static

Copies the ogs_version string containing the release number and the git hash.

Definition at line 28 of file AddProcessDataToMesh.cpp.

29{
30 auto& ogs_version_field = *MeshLib::getOrCreateMeshProperty<char>(
33
34 ogs_version_field.assign(GitInfoLib::GitInfo::ogs_version);
35}
const std::string OGS_VERSION
Definition GitInfo.cpp:20
GITINFOLIB_EXPORT const std::string ogs_version
PropertyVector< T > * getOrCreateMeshProperty(Mesh &mesh, std::string const &property_name, MeshItemType const item_type, int const number_of_components)

References MeshLib::getOrCreateMeshProperty(), MeshLib::IntegrationPoint, GitInfoLib::GitInfo::OGS_VERSION, and GitInfoLib::GitInfo::ogs_version.

Referenced by ProcessLib::addProcessDataToMesh().

◆ addPrimaryVariablesToMesh()

static std::set< std::string > addPrimaryVariablesToMesh ( MeshLib::Mesh & mesh,
GlobalVector const & x,
std::vector< std::reference_wrapper< ProcessLib::ProcessVariable > > const & process_variables,
std::set< std::string > const & output_variables,
NumLib::LocalToGlobalIndexMap const & dof_table,
NumLib::LocalToGlobalIndexMap const & bulk_mesh_dof_table )
static

Adds data for the given process_variables to the given mesh, if they occur in output_variables.

Parameters
meshthe mesh the data is added to.
xthe global solution vector providing the data.
process_variablesthe primary variables comprising x.
output_variablesthe names of variables that can be added to the mesh.
dof_tablethe d.o.f. table related to the passed mesh and solution vector x.
bulk_mesh_dof_tablethe d.o.f. table related to the entire simulation domain and the passed solution vector x.
Note
Usually mesh and the full simulation domain are the same. But if output should be written to a sub mesh, they will differ. In that case, also the two d.o.f. tables will be different from each other.
The dof_table must correspond to the mesh, to the solution vector x and to the process_variables. I.e., if there are, e.g., two primary variables in x, there must also be two variables in the dof_table and two entries in process_variables and so on.
The dof_table must correspond to the bulk_mesh_dof_table, i.e., the former must have been derived from the latter. In particular, both must have the same number of variables and components.
Returns
The names of all variables that have been written to the mesh.

Definition at line 240 of file AddProcessDataToMesh.cpp.

248{
249 if (dof_table.getNumberOfVariables() !=
250 bulk_mesh_dof_table.getNumberOfVariables() ||
251 dof_table.getNumberOfGlobalComponents() !=
252 bulk_mesh_dof_table.getNumberOfGlobalComponents())
253 {
254 OGS_FATAL(
255 "The d.o.f. table for the passed mesh must have the same number of "
256 "variables and global components as the d.o.f. table for the full "
257 "simulation domain. But the values differ: {} != {} (variables) or "
258 "{} != {} (global components).",
259 dof_table.getNumberOfVariables(),
260 bulk_mesh_dof_table.getNumberOfVariables(),
261 dof_table.getNumberOfGlobalComponents(),
262 bulk_mesh_dof_table.getNumberOfGlobalComponents());
263 }
264
265 auto const number_of_dof_variables = dof_table.getNumberOfVariables();
266
267 if (number_of_dof_variables != static_cast<int>(process_variables.size()))
268 {
269 OGS_FATAL(
270 "The number of variables in the d.o.f. table differs from the "
271 "number of primary variables of the process {} != {}.",
272 number_of_dof_variables, process_variables.size());
273 }
274
275 auto const x_copy = copySolutionVector(x);
276 std::set<std::string> names_of_already_output_variables;
277
278 int global_component_offset_next = 0;
279
280 auto const* const bulk_node_id_map = getBulkNodeIdMapForPetscIfNecessary(
281 mesh, dof_table, bulk_mesh_dof_table);
282
283 for (int variable_id = 0; variable_id < number_of_dof_variables;
284 ++variable_id)
285 {
286 auto const& pv = process_variables[variable_id].get();
287 auto const n_components = pv.getNumberOfGlobalComponents();
288
289 // increase global component offset even if we do not add anything in
290 // this iteration
291 int global_component_offset = global_component_offset_next;
292 global_component_offset_next += n_components;
293
294 if (!output_variables.empty() &&
295 !output_variables.contains(pv.getName()))
296 {
297 continue;
298 }
299
300 names_of_already_output_variables.insert(pv.getName());
301
302 DBUG(" process variable {:s}", pv.getName());
303
304 auto& output_data = *MeshLib::getOrCreateMeshProperty<double>(
305 mesh, pv.getName(), MeshLib::MeshItemType::Node, n_components);
306
307 // mesh subsets are the same for all components
308 int const dummy_component_id = 0;
309 auto const& mesh_subset =
310 dof_table.getMeshSubset(variable_id, dummy_component_id);
311 auto const mesh_id = mesh_subset.getMeshID();
312
313 for (auto const* node : mesh_subset.getNodes())
314 {
315 auto const node_id = node->getID();
316 auto const is_ghost_node = isGhostNode(mesh, node_id);
317
318 for (int component_id = 0; component_id < n_components;
319 ++component_id)
320 {
321 auto const global_component_id =
322 global_component_offset + component_id;
323
324 auto const in_index = getIndexForComponentInSolutionVector(
325 mesh_id, node_id, is_ghost_node, global_component_id, x,
326 dof_table, bulk_mesh_dof_table, bulk_node_id_map);
327
328 // per node ordering of components
329 auto const out_index = node_id * n_components + component_id;
330
331 // request for index of linear quantities at higher order nodes
332 // results in returning NumLib::MeshComponentMap::nop
333 if (in_index == NumLib::MeshComponentMap::nop)
334 {
335 output_data[out_index] = 0;
336 continue;
337 }
338
339 output_data[out_index] = x_copy[in_index];
340 }
341 }
342 }
343
344 return names_of_already_output_variables;
345}
static std::vector< double > copySolutionVector(GlobalVector const &x)
static GlobalIndexType getIndexForComponentInSolutionVector(std::size_t const mesh_id, std::size_t const node_id, bool const is_ghost_node, int const global_component_id, GlobalVector const &x, NumLib::LocalToGlobalIndexMap const &dof_table, NumLib::LocalToGlobalIndexMap const &bulk_mesh_dof_table, MeshLib::PropertyVector< std::size_t > const *const bulk_node_id_map)
MeshLib::PropertyVector< std::size_t > const * getBulkNodeIdMapForPetscIfNecessary(MeshLib::Mesh const &mesh, NumLib::LocalToGlobalIndexMap const &dof_table, NumLib::LocalToGlobalIndexMap const &bulk_mesh_dof_table)
static bool isGhostNode(MeshLib::Mesh const &mesh, std::size_t const node_id)
#define OGS_FATAL(...)
Definition Error.h:26
void DBUG(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:30
static constexpr NUMLIB_EXPORT GlobalIndexType const nop

References copySolutionVector(), DBUG(), getBulkNodeIdMapForPetscIfNecessary(), getIndexForComponentInSolutionVector(), MeshLib::MeshSubset::getMeshID(), NumLib::LocalToGlobalIndexMap::getMeshSubset(), MeshLib::Mesh::getName(), NumLib::LocalToGlobalIndexMap::getNumberOfGlobalComponents(), NumLib::LocalToGlobalIndexMap::getNumberOfVariables(), MeshLib::getOrCreateMeshProperty(), isGhostNode(), MeshLib::Node, NumLib::MeshComponentMap::nop, and OGS_FATAL.

Referenced by ProcessLib::addProcessDataToMesh().

◆ addSecondaryVariableNodes()

static void addSecondaryVariableNodes ( NumLib::Time const & t,
std::vector< GlobalVector * > const & x,
std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables,
ProcessLib::SecondaryVariable const & var,
std::string const & output_name,
MeshLib::Mesh & mesh )
static

Definition at line 37 of file AddProcessDataToMesh.cpp.

44{
45 DBUG(" secondary variable {:s}", output_name);
46
47 auto& nodal_values_mesh = *MeshLib::getOrCreateMeshProperty<double>(
48 mesh, output_name, MeshLib::MeshItemType::Node,
49 var.fcts.num_components);
50 if (nodal_values_mesh.size() !=
51 mesh.getNumberOfNodes() * var.fcts.num_components)
52 {
54 "Nodal property `{:s}' does not have the right number of "
55 "components. Expected: {:d}, actual: {:d}",
56 output_name,
57 mesh.getNumberOfNodes() * var.fcts.num_components,
58 nodal_values_mesh.size());
59 }
60
61 std::unique_ptr<GlobalVector> result_cache;
62 auto const& nodal_values =
63 var.fcts.eval_field(t(), x, dof_tables, result_cache);
64
65#ifdef USE_PETSC
66 std::size_t const global_vector_size =
67 nodal_values.getLocalSize() + nodal_values.getGhostSize();
68#else
69 std::size_t const global_vector_size = nodal_values.size();
70#endif
71 if (nodal_values_mesh.size() != global_vector_size)
72 {
74 "Secondary variable `{:s}' did not evaluate to the right number of "
75 "components. Expected: {:d}, actual: {:d}.",
76 var.name, nodal_values_mesh.size(), global_vector_size);
77 }
78
79 // Copy result
80 nodal_values.copyValues(std::span{nodal_values_mesh});
81}
std::size_t getNumberOfNodes() const
Get the number of nodes.
Definition Mesh.h:102

References DBUG(), ProcessLib::SecondaryVariableFunctions::eval_field, ProcessLib::SecondaryVariable::fcts, MeshLib::Mesh::getNumberOfNodes(), MeshLib::getOrCreateMeshProperty(), ProcessLib::SecondaryVariable::name, MeshLib::Node, ProcessLib::SecondaryVariableFunctions::num_components, and OGS_FATAL.

Referenced by addSecondaryVariablesToMesh().

◆ addSecondaryVariableResiduals()

static void addSecondaryVariableResiduals ( NumLib::Time const & t,
std::vector< GlobalVector * > const & x,
std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_table,
ProcessLib::SecondaryVariable const & var,
std::string const & output_name,
MeshLib::Mesh & mesh )
static

Definition at line 83 of file AddProcessDataToMesh.cpp.

90{
91 if (!var.fcts.eval_residuals)
92 {
93 return;
94 }
95
96 DBUG(" secondary variable {:s} residual", output_name);
97 auto const& property_name_res = output_name + "_residual";
98
99 auto& residuals_mesh = *MeshLib::getOrCreateMeshProperty<double>(
100 mesh, property_name_res, MeshLib::MeshItemType::Cell,
101 var.fcts.num_components);
102 if (residuals_mesh.size() !=
103 mesh.getNumberOfElements() * var.fcts.num_components)
104 {
105 OGS_FATAL(
106 "Cell property `{:s}' does not have the right number of "
107 "components. Expected: {:d}, actual: {:d}",
108 property_name_res,
109 mesh.getNumberOfElements() * var.fcts.num_components,
110 residuals_mesh.size());
111 }
112
113 std::unique_ptr<GlobalVector> result_cache;
114 auto const& residuals =
115 var.fcts.eval_residuals(t(), x, dof_table, result_cache);
116#ifdef USE_PETSC
117 std::size_t const global_vector_size =
118 residuals.getLocalSize() + residuals.getGhostSize();
119#else
120 std::size_t const global_vector_size = residuals.size();
121#endif
122 if (residuals_mesh.size() != global_vector_size)
123 {
124 OGS_FATAL(
125 "The residual of secondary variable `{:s}' did not evaluate to the "
126 "right number of components. Expected: {:d}, actual: {:d}.",
127 var.name, residuals_mesh.size(), global_vector_size);
128 }
129
130 // Copy result
131 residuals.copyValues(std::span{residuals_mesh});
132}
std::size_t getNumberOfElements() const
Get the number of elements.
Definition Mesh.h:99

References MeshLib::Cell, DBUG(), ProcessLib::SecondaryVariableFunctions::eval_residuals, ProcessLib::SecondaryVariable::fcts, MeshLib::Mesh::getNumberOfElements(), MeshLib::getOrCreateMeshProperty(), ProcessLib::SecondaryVariable::name, ProcessLib::SecondaryVariableFunctions::num_components, and OGS_FATAL.

Referenced by addSecondaryVariablesToMesh().

◆ addSecondaryVariablesToMesh()

static void addSecondaryVariablesToMesh ( ProcessLib::SecondaryVariableCollection const & secondary_variables,
std::set< std::string > & names_of_already_output_variables,
NumLib::Time const & t,
std::vector< GlobalVector * > const & xs,
MeshLib::Mesh & mesh,
std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables,
bool const output_residuals )
static

Definition at line 347 of file AddProcessDataToMesh.cpp.

354{
355 for (auto const& external_variable_name : secondary_variables)
356 {
357 auto const& name = external_variable_name.first;
358 if (!names_of_already_output_variables.insert(name).second)
359 {
360 // no insertion took place, output already done
361 continue;
362 }
363
364 addSecondaryVariableNodes(t, xs, dof_tables,
365 secondary_variables.get(name), name, mesh);
366
367 if (output_residuals)
368 {
370 t, xs, dof_tables, secondary_variables.get(name), name, mesh);
371 }
372 }
373}
static void addSecondaryVariableNodes(NumLib::Time const &t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, ProcessLib::SecondaryVariable const &var, std::string const &output_name, MeshLib::Mesh &mesh)
static void addSecondaryVariableResiduals(NumLib::Time const &t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, ProcessLib::SecondaryVariable const &var, std::string const &output_name, MeshLib::Mesh &mesh)

References addSecondaryVariableNodes(), addSecondaryVariableResiduals(), and ProcessLib::SecondaryVariableCollection::get().

Referenced by ProcessLib::addProcessDataToMesh().

◆ copySolutionVector()

static std::vector< double > copySolutionVector ( GlobalVector const & x)
static

Definition at line 134 of file AddProcessDataToMesh.cpp.

135{
136 std::vector<double> x_copy;
137 x.copyValues(x_copy);
138 return x_copy;
139}

References MathLib::EigenVector::copyValues().

Referenced by addPrimaryVariablesToMesh().

◆ getBulkNodeIdMapForPetscIfNecessary()

MeshLib::PropertyVector< std::size_t > const * getBulkNodeIdMapForPetscIfNecessary ( MeshLib::Mesh const & mesh,
NumLib::LocalToGlobalIndexMap const & dof_table,
NumLib::LocalToGlobalIndexMap const & bulk_mesh_dof_table )

Definition at line 141 of file AddProcessDataToMesh.cpp.

145{
146#ifdef USE_PETSC
147
148 if (&bulk_mesh_dof_table != &dof_table)
149 {
150 auto const bulk_id_string =
152 if (!mesh.getProperties().existsPropertyVector<std::size_t>(
153 bulk_id_string))
154 {
155 OGS_FATAL(
156 "The required bulk node ids map does not exist in "
157 "the boundary mesh '{:s}' or has the wrong data "
158 "type (should be equivalent to C++ data type "
159 "std::size_t which is an unsigned integer of size "
160 "{:d} or UInt64 in vtk terminology).",
161 mesh.getName(), sizeof(std::size_t));
162 }
163 return mesh.getProperties().getPropertyVector<std::size_t>(
164 bulk_id_string);
165 }
166#endif
167
168 return nullptr;
169}
constexpr std::string_view getBulkIDString(MeshItemType mesh_item_type)
Definition Properties.h:191

References MeshLib::getBulkIDString(), MeshLib::Node, and OGS_FATAL.

Referenced by addPrimaryVariablesToMesh().

◆ getIndexForComponentInSolutionVector()

static GlobalIndexType getIndexForComponentInSolutionVector ( std::size_t const mesh_id,
std::size_t const node_id,
bool const is_ghost_node,
int const global_component_id,
GlobalVector const & x,
NumLib::LocalToGlobalIndexMap const & dof_table,
NumLib::LocalToGlobalIndexMap const & bulk_mesh_dof_table,
MeshLib::PropertyVector< std::size_t > const *const bulk_node_id_map )
static

Definition at line 171 of file AddProcessDataToMesh.cpp.

178{
179#ifdef USE_PETSC
180 if (is_ghost_node && &bulk_mesh_dof_table != &dof_table)
181 {
182 auto const bulk_node_id = (*bulk_node_id_map)[node_id];
183 std::size_t const bulk_mesh_id = 0;
184
185 MeshLib::Location const loc(bulk_mesh_id, MeshLib::MeshItemType::Node,
186 bulk_node_id);
187
188 // early return!
189 return bulk_mesh_dof_table.getLocalIndex(
190 loc, global_component_id, x.getRangeBegin(), x.getRangeEnd());
191 }
192#endif
193
194 MeshLib::Location const loc(mesh_id, MeshLib::MeshItemType::Node, node_id);
195
196 return dof_table.getLocalIndex(loc, global_component_id, x.getRangeBegin(),
197 x.getRangeEnd());
198}

References NumLib::LocalToGlobalIndexMap::getLocalIndex(), MathLib::EigenVector::getRangeBegin(), MathLib::EigenVector::getRangeEnd(), and MeshLib::Node.

Referenced by addPrimaryVariablesToMesh().

◆ isGhostNode()

static bool isGhostNode ( MeshLib::Mesh const & mesh,
std::size_t const node_id )
static

Definition at line 200 of file AddProcessDataToMesh.cpp.

202{
203#ifndef USE_PETSC
204 return false;
205#else
206 return static_cast<MeshLib::NodePartitionedMesh const&>(mesh).isGhostNode(
207 node_id);
208#endif
209}

References isGhostNode().

Referenced by addPrimaryVariablesToMesh(), and isGhostNode().