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 54 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 105 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_meshes = 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_meshes, component_id,
                _compensate_non_equilibrium_initial_residuum);
        }
    }
    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"))
        {
            auto st_meshes = 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 if (type == "EmbeddedAnchor")
                {
                    // 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_meshes.front(), *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, _compensate_non_equilibrium_initial_residuum, _deactivated_subdomains, _initial_condition, _is_active, _mesh, _n_components, _name, _shapefunction_order, _source_term_configs, MeshLib::Cell, ProcessLib::createDeactivatedSubdomains(), DBUG(), BaseLib::ConfigTree::getConfigSubtreeOptional(), INFO(), and OGS_FATAL.

Referenced by ProcessVariable().

◆ ProcessVariable() [2/2]

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

default

References ProcessVariable().

◆ ~ProcessVariable()

ProcessLib::ProcessVariable::~ProcessVariable ( )

default

Member Function Documentation

◆ compensateNonEquilibriumInitialResiduum()

bool ProcessLib::ProcessVariable::compensateNonEquilibriumInitialResiduum ( ) const

inline

Definition at line 115 of file ProcessVariable.h.

    {
        return _compensate_non_equilibrium_initial_residuum;
    }

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

{
    std::vector<std::unique_ptr<BoundaryCondition>> bcs;
    bcs.reserve(_bc_configs.size());
 
    for (auto const& config : _bc_configs)
    {
        auto bc_vec = createBoundaryCondition(
            config, dof_table, _mesh, variable_id, integration_order,
            _shapefunction_order, parameters, process,
            all_process_variables_for_this_process, media);
        for (auto& bc : bc_vec)
        {
            // bc can be a nullptr if in parallel execution the bc isn't
            // associated to the particular subdomain
            if (bc != nullptr)
            {
                bcs.push_back(std::move(bc));
            }
        }
    }
 
    createBoundaryConditionsForDeactivatedSubDomains(dof_table, variable_id,
                                                     parameters, bcs);
 
    // Clear configs to trigger ConfigTree destruction and validation of
    // unprocessed parameters before the simulation starts.
    _bc_configs.clear();
 
    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 278 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< 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 374 of file ProcessVariable.cpp.

{
    std::vector<std::unique_ptr<SourceTermBase>> 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, bulk_mesh);
              });
 
    // Clear configs to trigger ConfigTree destruction and validation of
    // unprocessed parameters before the simulation starts.
    _source_term_configs.clear();
 
    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 80 of file ProcessVariable.h.

    {
        return _ids_of_active_elements;
    }

References _ids_of_active_elements.

◆ getDeactivatedSubdomains()

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

inline

Definition at line 73 of file ProcessVariable.h.

    {
        return _deactivated_subdomains;
    }

References _deactivated_subdomains.

◆ getInitialCondition()

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

inline

Definition at line 108 of file ProcessVariable.h.

    {
        return _initial_condition;
    }

References _initial_condition.

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

◆ getMesh()

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

Returns a mesh on which the process variable is defined.

Definition at line 232 of file ProcessVariable.cpp.

{
    return _mesh;
}

References _mesh.

◆ getName()

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

inline

Definition at line 68 of file ProcessVariable.h.

68{ return _name; }

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::ThermoMechanics::createThermoMechanicsProcess(), and ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::postTimestepConcreteProcess().

◆ getNumberOfGlobalComponents()

int ProcessLib::ProcessVariable::getNumberOfGlobalComponents ( ) const

inline

Returns the number of components of the process variable.

Definition at line 86 of file ProcessVariable.h.

86{ 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::ThermoMechanics::createThermoMechanicsProcess(), and ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::postTimestepConcreteProcess().

◆ getShapeFunctionOrder()

unsigned ProcessLib::ProcessVariable::getShapeFunctionOrder ( ) const

inline

Definition at line 113 of file ProcessVariable.h.

113{ 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 318 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, and _mesh.

Member Data Documentation

◆ _bc_configs

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

private

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

Referenced by ProcessVariable(), and compensateNonEquilibriumInitialResiduum().

◆ _deactivated_subdomains

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

private

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

Referenced by getActiveElementIDs(), and updateDeactivatedSubdomains().

◆ _initial_condition

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

private

Definition at line 154 of file ProcessVariable.h.

Referenced by ProcessVariable(), and getInitialCondition().

◆ _is_active

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

private

Definition at line 146 of file ProcessVariable.h.

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

◆ _mesh

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

private

Definition at line 124 of file ProcessVariable.h.

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

◆ _n_components

const int ProcessLib::ProcessVariable::_n_components

private

Definition at line 125 of file ProcessVariable.h.

Referenced by ProcessVariable(), and getNumberOfGlobalComponents().

◆ _name

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

private

Definition at line 123 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 139 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 157 of file ProcessVariable.h.

Referenced by ProcessVariable(), and createSourceTerms().

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

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