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:

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.

    :  
      _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");
 
            if (!component_id)
            {
                if (_n_components == 1)
                {
                    // default value for single component vars.
                    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.

    {
        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 214 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 248 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, 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.

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

    {
        return _ids_of_active_elements;
    }

References _ids_of_active_elements.

Referenced by ProcessLib::ComponentTransport::ComponentTransportProcess::assembleConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleConcreteProcess(), ProcessLib::HT::HTProcess::assembleConcreteProcess(), ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleConcreteProcess(), ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleConcreteProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleConcreteProcess(), ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >::assembleConcreteProcess(), ProcessLib::TES::TESProcess::assembleConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleConcreteProcess(), ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::assembleConcreteProcess(), ProcessLib::AssemblyMixin< Process >::assembleGeneric(), ProcessLib::ComponentTransport::ComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HT::HTProcess::assembleWithJacobianConcreteProcess(), ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::assembleWithJacobianConcreteProcess(), ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsComponentTransport::RichardsComponentTransportProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsFlow::RichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::assembleWithJacobianConcreteProcess(), ProcessLib::TES::TESProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::assembleWithJacobianConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPP::TwoPhaseFlowWithPPProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TwoPhaseFlowWithPrho::TwoPhaseFlowWithPrhoProcess::assembleWithJacobianConcreteProcess(), ProcessLib::HeatConduction::HeatConductionProcess::assembleWithJacobianConcreteProcess(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::HeatConduction::HeatConductionProcess::computeSecondaryVariableConcrete(), ProcessLib::HeatTransportBHE::HeatTransportBHEProcess::computeSecondaryVariableConcrete(), ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::LiquidFlow::LiquidFlowProcess::computeSecondaryVariableConcrete(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::computeSecondaryVariableConcrete(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >::computeSecondaryVariableConcrete(), ProcessLib::ComponentTransport::ComponentTransportProcess::computeSecondaryVariableConcrete(), ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >::computeSecondaryVariableConcrete(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::postIterationConcreteProcess(), ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::postNonLinearSolverConcreteProcess(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::postNonLinearSolverConcreteProcess(), ProcessLib::SteadyStateDiffusion::SteadyStateDiffusion::postTimestepConcreteProcess(), ProcessLib::HT::HTProcess::postTimestepConcreteProcess(), ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::postTimestepConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::postTimestepConcreteProcess(), ProcessLib::LiquidFlow::LiquidFlowProcess::postTimestepConcreteProcess(), ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >::postTimestepConcreteProcess(), ProcessLib::ThermoHydroMechanics::ThermoHydroMechanicsProcess< DisplacementDim >::postTimestepConcreteProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::postTimestepConcreteProcess(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::postTimestepConcreteProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::postTimestepConcreteProcess(), ProcessLib::ThermoRichardsFlow::ThermoRichardsFlowProcess::postTimestepConcreteProcess(), ProcessLib::ThermoRichardsMechanics::ThermoRichardsMechanicsProcess< DisplacementDim, ConstitutiveTraits >::postTimestepConcreteProcess(), ProcessLib::LargeDeformation::LargeDeformationProcess< DisplacementDim >::postTimestepConcreteProcess(), ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::postTimestepConcreteProcess(), ProcessLib::SmallDeformation::SmallDeformationProcess< DisplacementDim >::postTimestepConcreteProcess(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::postTimestepConcreteProcess(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::postTimestepConcreteProcess(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::preAssembleConcreteProcess(), ProcessLib::ThermalTwoPhaseFlowWithPP::ThermalTwoPhaseFlowWithPPProcess::preTimestepConcreteProcess(), ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::preTimestepConcreteProcess(), ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::preTimestepConcreteProcess(), ProcessLib::TH2M::TH2MProcess< DisplacementDim >::preTimestepConcreteProcess(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::preTimestepConcreteProcess(), ProcessLib::ThermoMechanics::ThermoMechanicsProcess< DisplacementDim >::preTimestepConcreteProcess(), ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::preTimestepConcreteProcess(), ProcessLib::RichardsMechanics::RichardsMechanicsProcess< DisplacementDim >::setInitialConditionsConcreteProcess(), ProcessLib::ComponentTransport::ComponentTransportProcess::solveReactionEquation(), ProcessLib::AssemblyMixinBase::updateActiveElements(), and ProcessLib::AssemblyMixinBase::updateActiveElementsImpl().

getDeactivatedSubdomains()

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

inline

Definition at line 80 of file ProcessVariable.h.

    {
        return _deactivated_subdomains;
    }

References _deactivated_subdomains.

getInitialCondition()

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

inline

Definition at line 114 of file ProcessVariable.h.

    {
        return _initial_condition;
    }

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

{
    return _mesh;
}

References _mesh.

getName()

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

(

)

const

Definition at line 203 of file ProcessVariable.cpp.

{
    return _name;
}

References _name.

Referenced by ProcessLib::ThermoRichardsFlow::checkProcessVariableComponents(), ProcessLib::ThermoRichardsMechanics::checkProcessVariableComponents(), 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.

{ return _n_components; }

References _n_components.

Referenced by ProcessLib::ThermoRichardsFlow::checkProcessVariableComponents(), ProcessLib::ThermoRichardsMechanics::checkProcessVariableComponents(), ProcessLib::Process::constructMonolithicProcessDofTable(), 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.

{ 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 288 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