ProcessLib::StokesFlow Namespace Reference

Namespaces
	anonymous_namespace{CreateStokesFlowProcess.cpp}
	detail

Classes
struct	IntegrationPointData
class	StokesFlowLocalAssemblerInterface
class	LocalDataInitializer
class	LocalAssemblerData
class	StokesFlowProcess
struct	StokesFlowProcessData

Functions
template<int GlobalDim, template< typename, typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>
void	createLocalAssemblers (const unsigned, std::vector< MeshLib::Element * > const &mesh_elements, NumLib::LocalToGlobalIndexMap const &dof_table, const unsigned shapefunction_order, std::vector< std::unique_ptr< LocalAssemblerInterface >> &local_assemblers, ExtraCtorArgs &&... extra_ctor_args)
template<int GlobalDim>
std::unique_ptr< Process >	createStokesFlowProcess (std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media)
template std::unique_ptr< Process >	createStokesFlowProcess< 2 > (std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< ProcessVariable > const &variables, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, unsigned const integration_order, BaseLib::ConfigTree const &config, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &media)

Function Documentation

createLocalAssemblers()

template<int GlobalDim, template< typename, typename, typename, int > class LocalAssemblerImplementation, typename LocalAssemblerInterface , typename... ExtraCtorArgs>

void ProcessLib::StokesFlow::createLocalAssemblers	(	const unsigned	,
		std::vector< MeshLib::Element * > const &	mesh_elements,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		const unsigned	shapefunction_order,
		std::vector< std::unique_ptr< LocalAssemblerInterface >> &	local_assemblers,
		ExtraCtorArgs &&...	extra_ctor_args
	)

Creates local assemblers for each element of the given mesh.

Template Parameters

LocalAssemblerImplementation	the individual local assembler type
LocalAssemblerInterface	the general local assembler interface
ExtraCtorArgs	types of additional constructor arguments. Those arguments will be passed to the constructor of LocalAssemblerImplementation.

The first two template parameters cannot be deduced from the arguments. Therefore they always have to be provided manually.

Definition at line 70 of file CreateLocalAssemblers.h.

{
    DBUG("Create local assemblers.");
 
    detail::createLocalAssemblers<GlobalDim, LocalAssemblerImplementation>(
        dof_table, shapefunction_order, mesh_elements, local_assemblers,
        std::forward<ExtraCtorArgs>(extra_ctor_args)...);
}

References DBUG().

Referenced by ProcessLib::StokesFlow::StokesFlowProcess< GlobalDim >::initializeConcreteProcess().

createStokesFlowProcess()

template<int GlobalDim>

std::unique_ptr< Process > ProcessLib::StokesFlow::createStokesFlowProcess	(	std::string	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &	media
	)

Input File Parameter:

prj__processes__process__type

Input File Parameter:

prj__processes__process__StokesFlow__coupling_scheme

Input File Parameter:

prj__processes__process__StokesFlow__process_variables

Input File Parameter:

prj__processes__process__StokesFlow__process_variables__liquid_velocity

Input File Parameter:

prj__processes__process__StokesFlow__process_variables__pressure

Input File Parameter:

prj__processes__process__StokesFlow__specific_body_force

Input File Parameter:

prj__processes__process__StokesFlow__use_stokes_brinkman_form

Definition at line 54 of file CreateStokesFlowProcess.cpp.

{
    config.checkConfigParameter("type", "StokesFlow");
 
    DBUG("Create StokesFlowProcess.");
 
    auto const coupling_scheme =
        config.getConfigParameter<std::string>("coupling_scheme",
                                               "monolithic_scheme");
    const bool use_monolithic_scheme = (coupling_scheme != "staggered");
 
    // Process variable.
    auto const pv_config = config.getConfigSubtree("process_variables");
 
    std::vector<std::vector<std::reference_wrapper<ProcessVariable>>>
        process_variables;
 
    // Collect all process variables in a vector before allocation
    // liquid_velocity first, pressure then
    auto const collected_process_variables = findProcessVariables(
        variables, pv_config,
        {
         "liquid_velocity",
         "pressure"});
 
    // Check number of components for each process variable
    auto const variable_v = collected_process_variables[0];
    if (variable_v.get().getNumberOfGlobalComponents() != GlobalDim)
    {
        OGS_FATAL(
            "Number of components of the process variable '{:s}' is different "
            "from the global dimension: got {:d}, expected {:d}",
            variable_v.get().getName(),
            variable_v.get().getNumberOfGlobalComponents(),
            GlobalDim);
    }
 
    auto const variable_p = collected_process_variables[1];
    if (variable_p.get().getNumberOfGlobalComponents() != 1)
    {
        OGS_FATAL(
            "Pressure process variable '{:s}' is not a scalar variable but has "
            "{:d} components.",
            variable_p.get().getName(),
            variable_p.get().getNumberOfGlobalComponents());
    }
 
    // Allocate the collected process variables into a two-dimensional vector,
    // depending on what coupling scheme is adopted
    if (use_monolithic_scheme)  // monolithic scheme.
    {
        process_variables.push_back(std::move(collected_process_variables));
    }
    else  // staggered scheme.
    {
        OGS_FATAL(
            "The staggered coupling scheme for StokesFlowProcess is not "
            "implemented.");
    }
 
    // Specific body force
    Eigen::VectorXd specific_body_force = Eigen::VectorXd::Zero(GlobalDim);
    auto const b =
        config.getConfigParameter<std::vector<double>>("specific_body_force");
    if (b.size() != GlobalDim)
    {
        OGS_FATAL(
            "The size of the specific body force vector does not match the "
            "global dimension. Vector size is {:d}, global "
            "dimension is {:d}",
            b.size(), GlobalDim);
    }
    std::copy_n(b.data(), b.size(), specific_body_force.data());
 
    bool const use_stokes_brinkman_form =
        config.getConfigParameter<bool>("use_stokes_brinkman_form", false);
 
    auto media_map =
        MaterialPropertyLib::createMaterialSpatialDistributionMap(media, mesh);
 
    DBUG("Check the media properties of StokesFlow process ...");
    checkMPLProperties(mesh, *media_map, use_stokes_brinkman_form);
    DBUG("Media properties verified.");
 
    StokesFlowProcessData process_data{std::move(media_map),
                                       std::move(specific_body_force),
                                       use_stokes_brinkman_form};
 
    SecondaryVariableCollection secondary_variables;
 
    ProcessLib::createSecondaryVariables(config, secondary_variables);
 
    return std::make_unique<StokesFlowProcess<GlobalDim>>(
        std::move(name), mesh, std::move(jacobian_assembler), parameters,
        integration_order, std::move(process_variables),
        std::move(process_data), std::move(secondary_variables),
        use_monolithic_scheme);
}

References BaseLib::ConfigTree::checkConfigParameter(), ProcessLib::StokesFlow::anonymous_namespace{CreateStokesFlowProcess.cpp}::checkMPLProperties(), MaterialPropertyLib::createMaterialSpatialDistributionMap(), ProcessLib::createSecondaryVariables(), DBUG(), ProcessLib::findProcessVariables(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtree(), MaterialPropertyLib::name, and OGS_FATAL.

createStokesFlowProcess< 2 >()

template std::unique_ptr< Process > ProcessLib::StokesFlow::createStokesFlowProcess< 2 >	(	std::string	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< ProcessVariable > const &	variables,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		unsigned const	integration_order,
		BaseLib::ConfigTree const &	config,
		std::map< int, std::shared_ptr< MaterialPropertyLib::Medium >> const &	media
	)

Referenced by ProjectData::parseProcesses().