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< SourceTermBase > > 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, const MeshLib::Mesh &bulk_mesh)
 
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)),
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 if (type == "EmbeddedAnchor")
184 {
185 // dummy value
186 component_id = 0;
187 }
188 else
189 {
190 OGS_FATAL(
191 "Specifying the component id (<component>) for a "
192 "source term for a non-scalar process variable is "
193 "mandatory.");
194 }
195 }
196
197 _source_term_configs.emplace_back(std::move(st_config), st_mesh,
198 *component_id);
199 }
200 }
201 else
202 {
203 INFO("No source terms for process variable '{:s}' found.", _name);
204 }
205
206 if (!_deactivated_subdomains.empty())
207 {
208 _is_active = getOrCreateMeshProperty<unsigned char>(
209 _mesh, _name + "_active", MeshLib::MeshItemType::Cell, 1);
210 std::fill(std::begin(*_is_active), std::end(*_is_active), 1u);
211 }
212}
#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
OGS_NO_DANGLING Parameter< ParameterDataType > & findParameter(std::string const &parameter_name, std::vector< std::unique_ptr< ParameterBase > > const &parameters, int const num_components, MeshLib::Mesh const *const mesh=nullptr)
Definition Utils.h:102
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 227 of file ProcessVariable.cpp.

236{
237 std::vector<std::unique_ptr<BoundaryCondition>> bcs;
238 bcs.reserve(_bc_configs.size());
239
240 for (auto const& config : _bc_configs)
241 {
242 auto bc = createBoundaryCondition(
243 config, dof_table, _mesh, variable_id, integration_order,
244 _shapefunction_order, parameters, process,
245 all_process_variables_for_this_process, media);
246#ifdef USE_PETSC
247 if (bc == nullptr)
248 {
249 continue;
250 }
251#endif // USE_PETSC
252 bcs.push_back(std::move(bc));
253 }
254
256 parameters, bcs);
257
258 return bcs;
259}
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 261 of file ProcessVariable.cpp.

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

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

Referenced by createBoundaryConditions().

◆ createSourceTerms()

std::vector< std::unique_ptr< SourceTermBase > > 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,
const MeshLib::Mesh & bulk_mesh )

Definition at line 357 of file ProcessVariable.cpp.

364{
365 std::vector<std::unique_ptr<SourceTermBase>> source_terms;
366
367 transform(cbegin(_source_term_configs), cend(_source_term_configs),
368 back_inserter(source_terms),
369 [&](auto const& config)
370 {
371 return createSourceTerm(
372 config, dof_table, config.mesh, variable_id,
373 integration_order, _shapefunction_order, parameters,
374 all_process_variables_for_this_process, bulk_mesh);
375 });
376
377 return source_terms;
378}
std::unique_ptr< SourceTermBase > 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, const MeshLib::Mesh &bulk_mesh)

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 221 of file ProcessVariable.cpp.

222{
223 return _mesh;
224}

References _mesh.

◆ getName()

◆ getNumberOfGlobalComponents()

◆ getShapeFunctionOrder()

◆ updateDeactivatedSubdomains()

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

Definition at line 301 of file ProcessVariable.cpp.

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

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 163 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 166 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 152 of file ProcessVariable.h.

Referenced by getActiveElementIDs(), and updateDeactivatedSubdomains().

◆ _initial_condition

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

Definition at line 161 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 132 of file ProcessVariable.h.

Referenced by ProcessVariable(), and getNumberOfGlobalComponents().

◆ _name

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

Definition at line 130 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 146 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 164 of file ProcessVariable.h.

Referenced by ProcessVariable(), and createSourceTerms().


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