OGS
ProcessLib::ProcessVariable Class Reference

Detailed Description

A named process variable. Its properties includes the mesh, and the initial and boundary conditions as well as the source terms.

Definition at line 61 of file ProcessVariable.h.

#include <ProcessVariable.h>

Collaboration diagram for ProcessLib::ProcessVariable:
[legend]

Public Member Functions

 ProcessVariable (BaseLib::ConfigTree const &config, MeshLib::Mesh &mesh, std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
 
 ProcessVariable (ProcessVariable &&)
 
std::string const & getName () const
 
MeshLib::Mesh const & getMesh () const
 Returns a mesh on which the process variable is defined.
 
std::vector< DeactivatedSubdomain > const & getDeactivatedSubdomains () const
 
void updateDeactivatedSubdomains (double const time)
 
std::vector< std::size_t > const & getActiveElementIDs () const
 
int getNumberOfGlobalComponents () const
 Returns the number of components of the process variable.
 
std::vector< std::unique_ptr< BoundaryCondition > > createBoundaryConditions (const NumLib::LocalToGlobalIndexMap &dof_table, const int variable_id, unsigned const integration_order, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, Process const &process, std::vector< std::reference_wrapper< ProcessVariable > > const &all_process_variables_for_this_process, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
 
std::vector< std::unique_ptr< SourceTerm > > createSourceTerms (const NumLib::LocalToGlobalIndexMap &dof_table, const int variable_id, unsigned const integration_order, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::vector< std::reference_wrapper< ProcessVariable > > const &all_process_variables_for_this_process)
 
ParameterLib::Parameter< double > const & getInitialCondition () const
 
unsigned getShapeFunctionOrder () const
 
bool compensateNonEquilibriumInitialResiduum () const
 
 ~ProcessVariable ()
 

Private Member Functions

void createBoundaryConditionsForDeactivatedSubDomains (const NumLib::LocalToGlobalIndexMap &dof_table, const int variable_id, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::vector< std::unique_ptr< BoundaryCondition > > &bcs)
 

Private Attributes

std::string const _name
 
MeshLib::Mesh_mesh
 
const int _n_components
 
unsigned _shapefunction_order
 
std::vector< DeactivatedSubdomain_deactivated_subdomains
 
std::vector< std::size_t > _ids_of_active_elements
 
MeshLib::PropertyVector< unsigned char > * _is_active = nullptr
 
ParameterLib::Parameter< double > const & _initial_condition
 
std::vector< BoundaryConditionConfig_bc_configs
 
std::vector< SourceTermConfig_source_term_configs
 
const bool _compensate_non_equilibrium_initial_residuum
 

Constructor & Destructor Documentation

◆ ProcessVariable() [1/2]

ProcessLib::ProcessVariable::ProcessVariable ( BaseLib::ConfigTree const & config,
MeshLib::Mesh & mesh,
std::vector< std::unique_ptr< MeshLib::Mesh > > const & meshes,
std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const & parameters,
std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const & curves )
Input File Parameter
prj__process_variables__process_variable__boundary_conditions
Input File Parameter
prj__process_variables__process_variable__boundary_conditions__boundary_condition
Input File Parameter
prj__process_variables__process_variable__boundary_conditions__boundary_condition__component
Input File Parameter
prj__process_variables__process_variable__source_terms
Input File Parameter
prj__process_variables__process_variable__source_terms__source_term
Input File Parameter
prj__process_variables__process_variable__source_terms__source_term__component
Input File Parameter
prj__process_variables__process_variable__source_terms__source_term__type

Definition at line 90 of file ProcessVariable.cpp.

97 :
98 _name(config.getConfigParameter<std::string>("name")),
99 _mesh(mesh),
101 _n_components(config.getConfigParameter<int>("components")),
103 _shapefunction_order(config.getConfigParameter<unsigned>("order")),
105 createDeactivatedSubdomains(config, mesh, parameters, curves)),
106 _initial_condition(ParameterLib::findParameter<double>(
108 config.getConfigParameter<std::string>("initial_condition"),
109 parameters, _n_components, &mesh)),
112 config.getConfigParameter<bool>(
113 "compensate_non_equilibrium_initial_residuum", false))
114{
115 DBUG("Constructing process variable {:s}", _name);
116
118 {
119 OGS_FATAL("The given shape function order {:d} is not supported",
121 }
122
123 // Boundary conditions
124 if (auto bcs_config =
126 config.getConfigSubtreeOptional("boundary_conditions"))
127 {
128 for (
129 auto bc_config :
131 bcs_config->getConfigSubtreeList("boundary_condition"))
132 {
133 auto const& bc_mesh = findMeshInConfig(bc_config, meshes);
134 auto component_id =
136 bc_config.getConfigParameterOptional<int>("component");
137
138 if (!component_id && _n_components == 1)
139 {
140 // default value for single component vars.
141 component_id = 0;
142 }
143
144 _bc_configs.emplace_back(std::move(bc_config), bc_mesh,
145 component_id);
146 }
147 }
148 else
149 {
150 INFO("No boundary conditions for process variable '{:s}' found.",
151 _name);
152 }
153
154 // Source terms
156 if (auto sts_config = config.getConfigSubtreeOptional("source_terms"))
157 {
158 for (
159 auto st_config :
161 sts_config->getConfigSubtreeList("source_term"))
162 {
163 MeshLib::Mesh const& st_mesh = findMeshInConfig(st_config, meshes);
164 auto component_id =
166 st_config.getConfigParameterOptional<int>("component");
167 auto const type =
169 st_config.peekConfigParameter<std::string>("type");
170
171 if (!component_id)
172 {
173 if (_n_components == 1)
174 {
175 // default value for single component vars.
176 component_id = 0;
177 }
178 else if (type == "Anchor")
179 {
180 // dummy value
181 component_id = 0;
182 }
183 else
184 {
185 OGS_FATAL(
186 "Specifying the component id (<component>) for a "
187 "source term for a non-scalar process variable is "
188 "mandatory.");
189 }
190 }
191
192 _source_term_configs.emplace_back(std::move(st_config), st_mesh,
193 *component_id);
194 }
195 }
196 else
197 {
198 INFO("No source terms for process variable '{:s}' found.", _name);
199 }
200
201 if (!_deactivated_subdomains.empty())
202 {
203 _is_active = getOrCreateMeshProperty<unsigned char>(
204 _mesh, _name + "_active", MeshLib::MeshItemType::Cell, 1);
205 std::fill(std::begin(*_is_active), std::end(*_is_active), 1u);
206 }
207}
#define OGS_FATAL(...)
Definition Error.h:26
void INFO(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:35
void DBUG(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:30
ParameterLib::Parameter< double > const & _initial_condition
std::vector< BoundaryConditionConfig > _bc_configs
std::vector< DeactivatedSubdomain > _deactivated_subdomains
const bool _compensate_non_equilibrium_initial_residuum
MeshLib::PropertyVector< unsigned char > * _is_active
std::vector< SourceTermConfig > _source_term_configs
std::vector< DeactivatedSubdomain > createDeactivatedSubdomains(BaseLib::ConfigTree const &config, MeshLib::Mesh const &mesh, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
MeshLib::Mesh const & findMeshInConfig(BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes)

References _bc_configs, _deactivated_subdomains, _is_active, _mesh, _n_components, _name, _shapefunction_order, _source_term_configs, MeshLib::Cell, DBUG(), BaseLib::ConfigTree::getConfigSubtreeOptional(), INFO(), and OGS_FATAL.

◆ ProcessVariable() [2/2]

ProcessLib::ProcessVariable::ProcessVariable ( ProcessVariable && )
default

◆ ~ProcessVariable()

ProcessLib::ProcessVariable::~ProcessVariable ( )
default

Member Function Documentation

◆ compensateNonEquilibriumInitialResiduum()

bool ProcessLib::ProcessVariable::compensateNonEquilibriumInitialResiduum ( ) const
inline

◆ createBoundaryConditions()

std::vector< std::unique_ptr< BoundaryCondition > > ProcessLib::ProcessVariable::createBoundaryConditions ( const NumLib::LocalToGlobalIndexMap & dof_table,
const int variable_id,
unsigned const integration_order,
std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const & parameters,
Process const & process,
std::vector< std::reference_wrapper< ProcessVariable > > const & all_process_variables_for_this_process,
std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const & media )

Definition at line 222 of file ProcessVariable.cpp.

231{
232 std::vector<std::unique_ptr<BoundaryCondition>> bcs;
233 bcs.reserve(_bc_configs.size());
234
235 for (auto const& config : _bc_configs)
236 {
237 auto bc = createBoundaryCondition(
238 config, dof_table, _mesh, variable_id, integration_order,
239 _shapefunction_order, parameters, process,
240 all_process_variables_for_this_process, media);
241#ifdef USE_PETSC
242 if (bc == nullptr)
243 {
244 continue;
245 }
246#endif // USE_PETSC
247 bcs.push_back(std::move(bc));
248 }
249
251 parameters, bcs);
252
253 return bcs;
254}
void createBoundaryConditionsForDeactivatedSubDomains(const NumLib::LocalToGlobalIndexMap &dof_table, const int variable_id, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::vector< std::unique_ptr< BoundaryCondition > > &bcs)
std::unique_ptr< BoundaryCondition > createBoundaryCondition(const BoundaryConditionConfig &config, const NumLib::LocalToGlobalIndexMap &dof_table, const MeshLib::Mesh &bulk_mesh, const int variable_id, const unsigned integration_order, const unsigned shapefunction_order, const std::vector< std::unique_ptr< ParameterLib::ParameterBase > > &parameters, const Process &process, std::vector< std::reference_wrapper< ProcessVariable > > const &all_process_variables_for_this_process, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)

References _bc_configs, _mesh, _shapefunction_order, ProcessLib::createBoundaryCondition(), and createBoundaryConditionsForDeactivatedSubDomains().

Referenced by ProcessLib::BoundaryConditionCollection::addBCsForProcessVariables().

◆ createBoundaryConditionsForDeactivatedSubDomains()

void ProcessLib::ProcessVariable::createBoundaryConditionsForDeactivatedSubDomains ( const NumLib::LocalToGlobalIndexMap & dof_table,
const int variable_id,
std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const & parameters,
std::vector< std::unique_ptr< BoundaryCondition > > & bcs )
private

Definition at line 256 of file ProcessVariable.cpp.

260{
261 for (auto const& deactivated_subdomain : _deactivated_subdomains)
262 {
263 auto const& deactivated_subdomain_mesh =
264 deactivated_subdomain.deactivated_subdomain_mesh;
265 auto const* parameter = &ParameterLib::findParameter<double>(
267 bool const set_outer_nodes_dirichlet_values =
268 deactivated_subdomain.boundary_value_parameter != nullptr;
269 if (set_outer_nodes_dirichlet_values)
270 {
271 parameter = deactivated_subdomain.boundary_value_parameter;
272 }
273
274 for (int component_id = 0;
275 component_id <
276 dof_table.getNumberOfVariableComponents(variable_id);
277 component_id++)
278 {
279 auto bc = std::make_unique<DeactivatedSubdomainDirichlet>(
280 *_is_active, deactivated_subdomain.time_interval, *parameter,
281 set_outer_nodes_dirichlet_values, deactivated_subdomain_mesh,
282 dof_table, variable_id, component_id);
283
284#ifdef USE_PETSC
285 // TODO: make it work under PETSc too.
286 if (bc == nullptr)
287 {
288 continue;
289 }
290#endif // USE_PETSC
291 bcs.push_back(std::move(bc));
292 }
293 }
294}
int getNumberOfVariableComponents(int variable_id) const
static PROCESSLIB_EXPORT const std::string zero_parameter_name

References _deactivated_subdomains, _is_active, NumLib::LocalToGlobalIndexMap::getNumberOfVariableComponents(), and ProcessLib::DeactivatedSubdomain::zero_parameter_name.

Referenced by createBoundaryConditions().

◆ createSourceTerms()

std::vector< std::unique_ptr< SourceTerm > > ProcessLib::ProcessVariable::createSourceTerms ( const NumLib::LocalToGlobalIndexMap & dof_table,
const int variable_id,
unsigned const integration_order,
std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const & parameters,
std::vector< std::reference_wrapper< ProcessVariable > > const & all_process_variables_for_this_process )

Definition at line 352 of file ProcessVariable.cpp.

359{
360 std::vector<std::unique_ptr<SourceTerm>> source_terms;
361
362 transform(cbegin(_source_term_configs), cend(_source_term_configs),
363 back_inserter(source_terms),
364 [&](auto const& config)
365 {
366 return createSourceTerm(
367 config, dof_table, config.mesh, variable_id,
368 integration_order, _shapefunction_order, parameters,
369 all_process_variables_for_this_process);
370 });
371
372 return source_terms;
373}
std::unique_ptr< SourceTerm > createSourceTerm(const SourceTermConfig &config, const NumLib::LocalToGlobalIndexMap &dof_table_bulk, const MeshLib::Mesh &source_term_mesh, const int variable_id, const unsigned integration_order, const unsigned shapefunction_order, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, std::vector< std::reference_wrapper< ProcessVariable > > const &all_process_variables_for_this_process)

References _shapefunction_order, _source_term_configs, and ProcessLib::createSourceTerm().

Referenced by ProcessLib::SourceTermCollection::addSourceTermsForProcessVariables().

◆ getActiveElementIDs()

std::vector< std::size_t > const & ProcessLib::ProcessVariable::getActiveElementIDs ( ) const
inline

Definition at line 87 of file ProcessVariable.h.

88 {
90 }
std::vector< std::size_t > _ids_of_active_elements

References _ids_of_active_elements.

◆ getDeactivatedSubdomains()

std::vector< DeactivatedSubdomain > const & ProcessLib::ProcessVariable::getDeactivatedSubdomains ( ) const
inline

Definition at line 80 of file ProcessVariable.h.

81 {
83 }

References _deactivated_subdomains.

◆ getInitialCondition()

ParameterLib::Parameter< double > const & ProcessLib::ProcessVariable::getInitialCondition ( ) const
inline

◆ getMesh()

MeshLib::Mesh const & ProcessLib::ProcessVariable::getMesh ( ) const

Returns a mesh on which the process variable is defined.

Definition at line 216 of file ProcessVariable.cpp.

217{
218 return _mesh;
219}

References _mesh.

◆ getName()

◆ getNumberOfGlobalComponents()

◆ getShapeFunctionOrder()

◆ updateDeactivatedSubdomains()

void ProcessLib::ProcessVariable::updateDeactivatedSubdomains ( double const time)

Definition at line 296 of file ProcessVariable.cpp.

297{
298 if (_deactivated_subdomains.empty())
299 {
300 return;
301 }
302
304
305 // If none of the deactivated subdomains is active at current time, then the
306 // _ids_of_active_elements remain empty.
307 if (std::none_of(
309 [&](auto const& ds) { return ds.isInTimeSupportInterval(time); }))
310 {
311 // Also mark all of the elements as active.
312 assert(_is_active != nullptr); // guaranteed by constructor
313 std::fill(std::begin(*_is_active), std::end(*_is_active), 1u);
314
315 return;
316 }
317
318 auto is_active_in_subdomain = [&](std::size_t const element_id,
319 DeactivatedSubdomain const& ds) -> bool
320 {
321 return (!ds.isInTimeSupportInterval(time)) ||
322 !ds.isDeactivated(*_mesh.getElement(element_id), time);
323 };
324
325 auto is_active_in_all_subdomains = [&](std::size_t const element_id) -> bool
326 {
327 return std::all_of(begin(_deactivated_subdomains),
329 [&](auto const& ds)
330 { return is_active_in_subdomain(element_id, ds); });
331 };
332
333 auto const number_of_elements = _mesh.getNumberOfElements();
334 for (std::size_t element_id = 0; element_id < number_of_elements;
335 element_id++)
336 {
337 if (is_active_in_all_subdomains(element_id))
338 {
339 _ids_of_active_elements.push_back(element_id);
340 }
341 }
342
343 // all elements are deactivated
344 std::fill(std::begin(*_is_active), std::end(*_is_active), 0u);
345
346 for (auto const id : _ids_of_active_elements)
347 {
348 (*_is_active)[id] = 1u;
349 }
350}
const Element * getElement(std::size_t idx) const
Get the element with the given index.
Definition Mesh.h:94
std::size_t getNumberOfElements() const
Get the number of elements.
Definition Mesh.h:97

References _deactivated_subdomains, _ids_of_active_elements, _is_active, _mesh, MeshLib::Mesh::getElement(), and MeshLib::Mesh::getNumberOfElements().

Member Data Documentation

◆ _bc_configs

std::vector<BoundaryConditionConfig> ProcessLib::ProcessVariable::_bc_configs
private

Definition at line 162 of file ProcessVariable.h.

Referenced by ProcessVariable(), and createBoundaryConditions().

◆ _compensate_non_equilibrium_initial_residuum

const bool ProcessLib::ProcessVariable::_compensate_non_equilibrium_initial_residuum
private

Definition at line 165 of file ProcessVariable.h.

Referenced by compensateNonEquilibriumInitialResiduum().

◆ _deactivated_subdomains

std::vector<DeactivatedSubdomain> ProcessLib::ProcessVariable::_deactivated_subdomains
private

◆ _ids_of_active_elements

std::vector<std::size_t> ProcessLib::ProcessVariable::_ids_of_active_elements
mutableprivate

IDs of the active elements. It is initialized only if there are deactivated subdomains.

Definition at line 151 of file ProcessVariable.h.

Referenced by getActiveElementIDs(), and updateDeactivatedSubdomains().

◆ _initial_condition

ParameterLib::Parameter<double> const& ProcessLib::ProcessVariable::_initial_condition
private

Definition at line 160 of file ProcessVariable.h.

Referenced by getInitialCondition().

◆ _is_active

MeshLib::PropertyVector<unsigned char>* ProcessLib::ProcessVariable::_is_active = nullptr
private

◆ _mesh

MeshLib::Mesh& ProcessLib::ProcessVariable::_mesh
private

◆ _n_components

const int ProcessLib::ProcessVariable::_n_components
private

Definition at line 131 of file ProcessVariable.h.

Referenced by ProcessVariable(), and getNumberOfGlobalComponents().

◆ _name

std::string const ProcessLib::ProcessVariable::_name
private

Definition at line 129 of file ProcessVariable.h.

Referenced by ProcessVariable(), and getName().

◆ _shapefunction_order

unsigned ProcessLib::ProcessVariable::_shapefunction_order
private

The polynomial order of the process variable's shape functions.

Requires an appropriate mesh.

The order of the shape functions can not be higher than the maximum available order for the underlying geometric elements. For example the second order shape functions for a hexahedron are only possible if the geometric element is at least a 20-node hexahedron element (MeshLib::TemplateElement<MeshLib::HexRule20>), whereas linear shape functions are also available on the 8-node hexahedron (MeshLib::TemplateElement<MeshLib::HexRule8>).

See also
MeshLib::CellRule MeshLib::FaceRule MeshLib::EdgeRule.

Definition at line 145 of file ProcessVariable.h.

Referenced by ProcessVariable(), createBoundaryConditions(), createSourceTerms(), and getShapeFunctionOrder().

◆ _source_term_configs

std::vector<SourceTermConfig> ProcessLib::ProcessVariable::_source_term_configs
private

Definition at line 163 of file ProcessVariable.h.

Referenced by ProcessVariable(), and createSourceTerms().


The documentation for this class was generated from the following files: