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.

    :  
      _name(config.getConfigParameter<std::string>("name")),
      _mesh(mesh),
      _n_components(config.getConfigParameter<int>("components")),
      _shapefunction_order(config.getConfigParameter<unsigned>("order")),
      _deactivated_subdomains(
          createDeactivatedSubdomains(config, mesh, parameters, curves)),
      _initial_condition(ParameterLib::findParameter<double>(
          config.getConfigParameter<std::string>("initial_condition"),
          parameters, _n_components, &mesh)),
      _compensate_non_equilibrium_initial_residuum(
          config.getConfigParameter<bool>(
              "compensate_non_equilibrium_initial_residuum", false))
{
    DBUG("Constructing process variable {:s}", _name);
 
    if (_shapefunction_order < 1 || 2 < _shapefunction_order)
    {
        OGS_FATAL("The given shape function order {:d} is not supported",
                  _shapefunction_order);
    }
 
    // Boundary conditions
    if (auto bcs_config =
        config.getConfigSubtreeOptional("boundary_conditions"))
    {
        for (
            auto bc_config :
            bcs_config->getConfigSubtreeList("boundary_condition"))
        {
            auto const& bc_mesh = findMeshInConfig(bc_config, meshes);
            auto component_id =
                bc_config.getConfigParameterOptional<int>("component");
 
            if (!component_id && _n_components == 1)
            {
                // default value for single component vars.
                component_id = 0;
            }
 
            _bc_configs.emplace_back(std::move(bc_config), bc_mesh,
                                     component_id);
        }
    }
    else
    {
        INFO("No boundary conditions for process variable '{:s}' found.",
             _name);
    }
 
    // Source terms
    if (auto sts_config = config.getConfigSubtreeOptional("source_terms"))
    {
        for (
            auto st_config :
            sts_config->getConfigSubtreeList("source_term"))
        {
            MeshLib::Mesh const& st_mesh = findMeshInConfig(st_config, meshes);
            auto component_id =
                st_config.getConfigParameterOptional<int>("component");
            auto const type =
                st_config.peekConfigParameter<std::string>("type");
 
            if (!component_id)
            {
                if (_n_components == 1)
                {
                    // default value for single component vars.
                    component_id = 0;
                }
                else if (type == "Anchor")
                {
                    // dummy value
                    component_id = 0;
                }
                else
                {
                    OGS_FATAL(
                        "Specifying the component id (<component>) for a "
                        "source term for a non-scalar process variable is "
                        "mandatory.");
                }
            }
 
            _source_term_configs.emplace_back(std::move(st_config), st_mesh,
                                              *component_id);
        }
    }
    else
    {
        INFO("No source terms for process variable '{:s}' found.", _name);
    }
 
    if (!_deactivated_subdomains.empty())
    {
        _is_active = getOrCreateMeshProperty<unsigned char>(
            _mesh, _name + "_active", MeshLib::MeshItemType::Cell, 1);
        std::fill(std::begin(*_is_active), std::end(*_is_active), 1u);
    }
}

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

Definition at line 121 of file ProcessVariable.h.

122 {

123 return _compensate_non_equilibrium_initial_residuum;

124 }

References _compensate_non_equilibrium_initial_residuum.

◆ 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.

{
    std::vector<std::unique_ptr<BoundaryCondition>> bcs;
    bcs.reserve(_bc_configs.size());
 
    for (auto const& config : _bc_configs)
    {
        auto bc = createBoundaryCondition(
            config, dof_table, _mesh, variable_id, integration_order,
            _shapefunction_order, parameters, process,
            all_process_variables_for_this_process, media);
#ifdef USE_PETSC
        if (bc == nullptr)
        {
            continue;
        }
#endif  // USE_PETSC
        bcs.push_back(std::move(bc));
    }
 
    createBoundaryConditionsForDeactivatedSubDomains(dof_table, variable_id,
                                                     parameters, bcs);
 
    return bcs;
}

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.

{
    for (auto const& deactivated_subdomain : _deactivated_subdomains)
    {
        auto const& deactivated_subdomain_mesh =
            deactivated_subdomain.deactivated_subdomain_mesh;
        auto const* parameter = &ParameterLib::findParameter<double>(
            DeactivatedSubdomain::zero_parameter_name, parameters, 1);
        bool const set_outer_nodes_dirichlet_values =
            deactivated_subdomain.boundary_value_parameter != nullptr;
        if (set_outer_nodes_dirichlet_values)
        {
            parameter = deactivated_subdomain.boundary_value_parameter;
        }
 
        for (int component_id = 0;
             component_id <
             dof_table.getNumberOfVariableComponents(variable_id);
             component_id++)
        {
            auto bc = std::make_unique<DeactivatedSubdomainDirichlet>(
                *_is_active, deactivated_subdomain.time_interval, *parameter,
                set_outer_nodes_dirichlet_values, deactivated_subdomain_mesh,
                dof_table, variable_id, component_id);
 
#ifdef USE_PETSC
            // TODO: make it work under PETSc too.
            if (bc == nullptr)
            {
                continue;
            }
#endif  // USE_PETSC
            bcs.push_back(std::move(bc));
        }
    }
}

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< 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.

{
    std::vector<std::unique_ptr<SourceTerm>> source_terms;
 
    transform(cbegin(_source_term_configs), cend(_source_term_configs),
              back_inserter(source_terms),
              [&](auto const& config)
              {
                  return createSourceTerm(
                      config, dof_table, config.mesh, variable_id,
                      integration_order, _shapefunction_order, parameters,
                      all_process_variables_for_this_process);
              });
 
    return source_terms;
}

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 {

89 return _ids_of_active_elements;

90 }

ProcessLib::ProcessVariable::_ids_of_active_elements

std::vector< std::size_t > _ids_of_active_elements

Definition ProcessVariable.h:151

References _ids_of_active_elements.

◆ getDeactivatedSubdomains()

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

inline

Definition at line 80 of file ProcessVariable.h.

81 {

82 return _deactivated_subdomains;

83 }

References _deactivated_subdomains.

◆ getInitialCondition()

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

inline

Definition at line 114 of file ProcessVariable.h.

115 {

116 return _initial_condition;

117 }

References _initial_condition.

Referenced by ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::HydroMechanicsProcess().

◆ 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()

std::string const & ProcessLib::ProcessVariable::getName ( ) const

Definition at line 211 of file ProcessVariable.cpp.

212{

213 return _name;

214}

References _name.

Referenced by ProcessLib::ThermoRichardsFlow::checkProcessVariableComponents(), ProcessLib::ThermoRichardsMechanics::checkProcessVariableComponents(), ProcessLib::HMPhaseField::createHMPhaseFieldProcess(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::PhaseField::createPhaseFieldProcess(), ProcessLib::RichardsMechanics::createRichardsMechanicsProcess(), ProcessLib::TH2M::createTH2MProcess(), ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess(), ProcessLib::ThermoMechanicalPhaseField::createThermoMechanicalPhaseFieldProcess(), ProcessLib::ThermoMechanics::createThermoMechanicsProcess(), and ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::postTimestepConcreteProcess().

◆ getNumberOfGlobalComponents()

int ProcessLib::ProcessVariable::getNumberOfGlobalComponents ( ) const

inline

Returns the number of components of the process variable.

Definition at line 93 of file ProcessVariable.h.

93{ return _n_components; }

References _n_components.

Referenced by ProcessLib::ThermoRichardsFlow::checkProcessVariableComponents(), ProcessLib::ThermoRichardsMechanics::checkProcessVariableComponents(), ProcessLib::Process::constructMonolithicProcessDofTable(), ProcessLib::HMPhaseField::createHMPhaseFieldProcess(), ProcessLib::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::PhaseField::createPhaseFieldProcess(), ProcessLib::RichardsMechanics::createRichardsMechanicsProcess(), ProcessLib::TH2M::createTH2MProcess(), ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess(), ProcessLib::ThermoMechanicalPhaseField::createThermoMechanicalPhaseFieldProcess(), ProcessLib::ThermoMechanics::createThermoMechanicsProcess(), and ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::postTimestepConcreteProcess().

◆ getShapeFunctionOrder()

unsigned ProcessLib::ProcessVariable::getShapeFunctionOrder ( ) const

inline

Definition at line 119 of file ProcessVariable.h.

119{ return _shapefunction_order; }

References _shapefunction_order.

Referenced by ProcessLib::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::TH2M::createTH2MProcess(), ProcessLib::ThermoHydroMechanics::createThermoHydroMechanicsProcess(), and ProcessLib::ThermoRichardsMechanics::createThermoRichardsMechanicsProcessStage2().

◆ updateDeactivatedSubdomains()

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

Definition at line 296 of file ProcessVariable.cpp.

{
    if (_deactivated_subdomains.empty())
    {
        return;
    }
 
    _ids_of_active_elements.clear();
 
    // If none of the deactivated subdomains is active at current time, then the
    // _ids_of_active_elements remain empty.
    if (std::none_of(
            begin(_deactivated_subdomains), end(_deactivated_subdomains),
            [&](auto const& ds) { return ds.isInTimeSupportInterval(time); }))
    {
        // Also mark all of the elements as active.
        assert(_is_active != nullptr);  // guaranteed by constructor
        std::fill(std::begin(*_is_active), std::end(*_is_active), 1u);
 
        return;
    }
 
    auto is_active_in_subdomain = [&](std::size_t const element_id,
                                      DeactivatedSubdomain const& ds) -> bool
    {
        return (!ds.isInTimeSupportInterval(time)) ||
               !ds.isDeactivated(*_mesh.getElement(element_id), time);
    };
 
    auto is_active_in_all_subdomains = [&](std::size_t const element_id) -> bool
    {
        return std::all_of(begin(_deactivated_subdomains),
                           end(_deactivated_subdomains),
                           [&](auto const& ds)
                           { return is_active_in_subdomain(element_id, ds); });
    };
 
    auto const number_of_elements = _mesh.getNumberOfElements();
    for (std::size_t element_id = 0; element_id < number_of_elements;
         element_id++)
    {
        if (is_active_in_all_subdomains(element_id))
        {
            _ids_of_active_elements.push_back(element_id);
        }
    }
 
    // all elements are deactivated
    std::fill(std::begin(*_is_active), std::end(*_is_active), 0u);
 
    for (auto const id : _ids_of_active_elements)
    {
        (*_is_active)[id] = 1u;
    }
}

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

Definition at line 147 of file ProcessVariable.h.

Referenced by ProcessVariable(), createBoundaryConditionsForDeactivatedSubDomains(), getDeactivatedSubdomains(), and updateDeactivatedSubdomains().

◆ _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

Definition at line 152 of file ProcessVariable.h.

Referenced by ProcessVariable(), createBoundaryConditionsForDeactivatedSubDomains(), and updateDeactivatedSubdomains().

◆ _mesh

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

private

Definition at line 130 of file ProcessVariable.h.

Referenced by ProcessVariable(), createBoundaryConditions(), getMesh(), and updateDeactivatedSubdomains().

◆ _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:

ProcessLib/ProcessVariable.h
ProcessLib/ProcessVariable.cpp

Detailed Description

Public Member Functions

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ ProcessVariable() [1/2]

◆ ProcessVariable() [2/2]

◆ ~ProcessVariable()

Member Function Documentation

◆ compensateNonEquilibriumInitialResiduum()

◆ createBoundaryConditions()

◆ createBoundaryConditionsForDeactivatedSubDomains()

◆ createSourceTerms()

◆ getActiveElementIDs()

◆ getDeactivatedSubdomains()

◆ getInitialCondition()

◆ getMesh()

◆ getName()

◆ getNumberOfGlobalComponents()

◆ getShapeFunctionOrder()

◆ updateDeactivatedSubdomains()

Member Data Documentation

◆ _bc_configs

◆ _compensate_non_equilibrium_initial_residuum

◆ _deactivated_subdomains

◆ _ids_of_active_elements

◆ _initial_condition

◆ _is_active

◆ _mesh

◆ _n_components

◆ _name

◆ _shapefunction_order

◆ _source_term_configs