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

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
168 if (!component_id)
169 {
170 if (_n_components == 1)
171 {
172 // default value for single component vars.
173 component_id = 0;
174 }
175 else
176 {
177 OGS_FATAL(
178 "Specifying the component id (<component>) for a "
179 "source term for a non-scalar process variable is "
180 "mandatory.");
181 }
182 }
183
184 _source_term_configs.emplace_back(std::move(st_config), st_mesh,
185 *component_id);
186 }
187 }
188 else
189 {
190 INFO("No source terms for process variable '{:s}' found.", _name);
191 }
192
193 if (!_deactivated_subdomains.empty())
194 {
195 _is_active = getOrCreateMeshProperty<unsigned char>(
196 _mesh, _name + "_active", MeshLib::MeshItemType::Cell, 1);
197 std::fill(std::begin(*_is_active), std::end(*_is_active), 1u);
198 }
199}
#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 214 of file ProcessVariable.cpp.

223{
224 std::vector<std::unique_ptr<BoundaryCondition>> bcs;
225 bcs.reserve(_bc_configs.size());
226
227 for (auto const& config : _bc_configs)
228 {
229 auto bc = createBoundaryCondition(
230 config, dof_table, _mesh, variable_id, integration_order,
231 _shapefunction_order, parameters, process,
232 all_process_variables_for_this_process, media);
233#ifdef USE_PETSC
234 if (bc == nullptr)
235 {
236 continue;
237 }
238#endif // USE_PETSC
239 bcs.push_back(std::move(bc));
240 }
241
243 parameters, bcs);
244
245 return bcs;
246}
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 &)

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

252{
253 for (auto const& deactivated_subdomain : _deactivated_subdomains)
254 {
255 auto const& deactivated_subdomain_mesh =
256 deactivated_subdomain.deactivated_subdomain_mesh;
257 auto const* parameter = &ParameterLib::findParameter<double>(
259 bool const set_outer_nodes_dirichlet_values =
260 deactivated_subdomain.boundary_value_parameter != nullptr;
261 if (set_outer_nodes_dirichlet_values)
262 {
263 parameter = deactivated_subdomain.boundary_value_parameter;
264 }
265
266 for (int component_id = 0;
267 component_id <
268 dof_table.getNumberOfVariableComponents(variable_id);
269 component_id++)
270 {
271 auto bc = std::make_unique<DeactivatedSubdomainDirichlet>(
272 *_is_active, deactivated_subdomain.time_interval, *parameter,
273 set_outer_nodes_dirichlet_values, deactivated_subdomain_mesh,
274 dof_table, variable_id, component_id);
275
276#ifdef USE_PETSC
277 // TODO: make it work under PETSc too.
278 if (bc == nullptr)
279 {
280 continue;
281 }
282#endif // USE_PETSC
283 bcs.push_back(std::move(bc));
284 }
285 }
286}
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 344 of file ProcessVariable.cpp.

351{
352 std::vector<std::unique_ptr<SourceTerm>> source_terms;
353
354 transform(cbegin(_source_term_configs), cend(_source_term_configs),
355 back_inserter(source_terms),
356 [&](auto const& config)
357 {
358 return createSourceTerm(
359 config, dof_table, config.mesh, variable_id,
360 integration_order, _shapefunction_order, parameters,
361 all_process_variables_for_this_process);
362 });
363
364 return source_terms;
365}
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.

Referenced by ProcessLib::AssemblyMixin< Process >::assembleGeneric().

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

209{
210 return _mesh;
211}

References _mesh.

◆ getName()

◆ getNumberOfGlobalComponents()

◆ getShapeFunctionOrder()

◆ updateDeactivatedSubdomains()

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

Definition at line 288 of file ProcessVariable.cpp.

289{
290 if (_deactivated_subdomains.empty())
291 {
292 return;
293 }
294
296
297 // If none of the deactivated subdomains is active at current time, then the
298 // _ids_of_active_elements remain empty.
299 if (std::none_of(
301 [&](auto const& ds) { return ds.isInTimeSupportInterval(time); }))
302 {
303 // Also mark all of the elements as active.
304 assert(_is_active != nullptr); // guaranteed by constructor
305 std::fill(std::begin(*_is_active), std::end(*_is_active), 1u);
306
307 return;
308 }
309
310 auto is_active_in_subdomain = [&](std::size_t const element_id,
311 DeactivatedSubdomain const& ds) -> bool
312 {
313 return (!ds.isInTimeSupportInterval(time)) ||
314 !ds.isDeactivated(*_mesh.getElement(element_id), time);
315 };
316
317 auto is_active_in_all_subdomains = [&](std::size_t const element_id) -> bool
318 {
319 return std::all_of(begin(_deactivated_subdomains),
321 [&](auto const& ds)
322 { return is_active_in_subdomain(element_id, ds); });
323 };
324
325 auto const number_of_elements = _mesh.getNumberOfElements();
326 for (std::size_t element_id = 0; element_id < number_of_elements;
327 element_id++)
328 {
329 if (is_active_in_all_subdomains(element_id))
330 {
331 _ids_of_active_elements.push_back(element_id);
332 }
333 }
334
335 // all elements are deactivated
336 std::fill(std::begin(*_is_active), std::end(*_is_active), 0u);
337
338 for (auto const id : _ids_of_active_elements)
339 {
340 (*_is_active)[id] = 1u;
341 }
342}
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: