anonymous_namespace{ParallelVectorMatrixAssembler.cpp} Namespace Reference

Functions
void	assembleWithJacobianOneElement (const std::size_t mesh_item_id, ProcessLib::LocalAssemblerInterface &local_assembler, const NumLib::LocalToGlobalIndexMap &dof_table, const double t, const double dt, const GlobalVector &x, const GlobalVector &x_prev, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data, ProcessLib::AbstractJacobianAssembler &jacobian_assembler, ProcessLib::Assembly::MultiMatrixElementCache &cache)
void	assembleWithJacobianForStaggeredSchemeOneElement (const std::size_t mesh_item_id, ProcessLib::LocalAssemblerInterface &local_assembler, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, const double t, const double dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data, ProcessLib::AbstractJacobianAssembler &jacobian_assembler, ProcessLib::Assembly::MultiMatrixElementCache &cache)
std::vector< std::tuple< std::ptrdiff_t, std::reference_wrapper< ProcessLib::LocalAssemblerInterface > > >	collectActiveLocalAssemblers (BaseLib::PolymorphicRandomAccessContainerView< ProcessLib::LocalAssemblerInterface > const &local_assemblers, std::vector< std::size_t > const &active_elements)
	Returns a vector of active element ids with corresponding local assemblers.
void	runAssembly (std::vector< std::tuple< std::ptrdiff_t, std::reference_wrapper< ProcessLib::LocalAssemblerInterface > > > const &ids_local_assemblers, ThreadException &exception, auto local_matrix_output, auto assemble)
int	getNumberOfThreads ()

Function Documentation

assembleWithJacobianForStaggeredSchemeOneElement()

void anonymous_namespace{ParallelVectorMatrixAssembler.cpp}::assembleWithJacobianForStaggeredSchemeOneElement	(	const std::size_t	mesh_item_id,
		ProcessLib::LocalAssemblerInterface &	local_assembler,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	dof_tables,
		const double	t,
		const double	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	x_prev,
		int const	process_id,
		std::vector< double > &	local_b_data,
		std::vector< double > &	local_Jac_data,
		ProcessLib::AbstractJacobianAssembler &	jacobian_assembler,
		ProcessLib::Assembly::MultiMatrixElementCache &	cache )

Definition at line 60 of file ParallelVectorMatrixAssembler.cpp.

{
    std::vector<std::vector<GlobalIndexType>> indices_of_processes;
    indices_of_processes.reserve(dof_tables.size());
    transform(cbegin(dof_tables), cend(dof_tables),
              back_inserter(indices_of_processes),
              [&](auto const* dof_table)
              { return NumLib::getIndices(mesh_item_id, *dof_table); });
 
    auto local_coupled_xs =
        ProcessLib::getCoupledLocalSolutions(x, indices_of_processes);
    auto const local_x = MathLib::toVector(local_coupled_xs);
 
    auto local_coupled_x_prevs =
        ProcessLib::getCoupledLocalSolutions(x_prev, indices_of_processes);
    auto const local_x_prev = MathLib::toVector(local_coupled_x_prevs);
 
    std::vector<GlobalIndexType> const& indices =
        indices_of_processes[process_id];
 
    local_b_data.clear();
    local_Jac_data.clear();
 
    jacobian_assembler.assembleWithJacobianForStaggeredScheme(
        local_assembler, t, dt, local_x, local_x_prev, process_id, local_b_data,
        local_Jac_data);
 
    if (local_Jac_data.empty())
    {
        OGS_FATAL(
            "No Jacobian has been assembled! This might be due to "
            "programming errors in the local assembler of the "
            "current process.");
    }
 
    cache.add(local_b_data, local_Jac_data, indices);
}

References ProcessLib::Assembly::MultiMatrixElementCache::add(), ProcessLib::AbstractJacobianAssembler::assembleWithJacobianForStaggeredScheme(), ProcessLib::getCoupledLocalSolutions(), NumLib::getIndices(), OGS_FATAL, and MathLib::toVector().

assembleWithJacobianOneElement()

void anonymous_namespace{ParallelVectorMatrixAssembler.cpp}::assembleWithJacobianOneElement	(	const std::size_t	mesh_item_id,
		ProcessLib::LocalAssemblerInterface &	local_assembler,
		const NumLib::LocalToGlobalIndexMap &	dof_table,
		const double	t,
		const double	dt,
		const GlobalVector &	x,
		const GlobalVector &	x_prev,
		std::vector< double > &	local_b_data,
		std::vector< double > &	local_Jac_data,
		ProcessLib::AbstractJacobianAssembler &	jacobian_assembler,
		ProcessLib::Assembly::MultiMatrixElementCache &	cache )

Definition at line 28 of file ParallelVectorMatrixAssembler.cpp.

{
    std::vector<GlobalIndexType> const& indices =
        NumLib::getIndices(mesh_item_id, dof_table);
 
    local_b_data.clear();
    local_Jac_data.clear();
 
    auto const local_x = x.get(indices);
    auto const local_x_prev = x_prev.get(indices);
    jacobian_assembler.assembleWithJacobian(local_assembler, t, dt, local_x,
                                            local_x_prev, local_b_data,
                                            local_Jac_data);
 
    if (local_Jac_data.empty())
    {
        OGS_FATAL(
            "No Jacobian has been assembled! This might be due to "
            "programming errors in the local assembler of the "
            "current process.");
    }
 
    cache.add(local_b_data, local_Jac_data, indices);
}

References ProcessLib::Assembly::MultiMatrixElementCache::add(), ProcessLib::AbstractJacobianAssembler::assembleWithJacobian(), MathLib::EigenVector::get(), NumLib::getIndices(), and OGS_FATAL.

collectActiveLocalAssemblers()

std::vector< std::tuple< std::ptrdiff_t, std::reference_wrapper< ProcessLib::LocalAssemblerInterface > > > anonymous_namespace{ParallelVectorMatrixAssembler.cpp}::collectActiveLocalAssemblers	(	BaseLib::PolymorphicRandomAccessContainerView< ProcessLib::LocalAssemblerInterface > const &	local_assemblers,
		std::vector< std::size_t > const &	active_elements )

Returns a vector of active element ids with corresponding local assemblers.

Definition at line 110 of file ParallelVectorMatrixAssembler.cpp.

{
    auto create_ids_asm_pairs = [&](auto const& element_ids)
    {
        std::vector<std::tuple<
            std::ptrdiff_t,
            std::reference_wrapper<ProcessLib::LocalAssemblerInterface>>>
            result;
        result.reserve(static_cast<std::size_t>(element_ids.size()));
        for (auto const id : element_ids)
        {
            result.push_back({id, local_assemblers[id]});
        }
        return result;
    };
 
    if (active_elements.empty())
    {
        return create_ids_asm_pairs(ranges::views::iota(
            static_cast<std::size_t>(0), local_assemblers.size()));
    }
    return create_ids_asm_pairs(active_elements);
}

getNumberOfThreads()

int anonymous_namespace{ParallelVectorMatrixAssembler.cpp}::getNumberOfThreads

(

)

Definition at line 172 of file ParallelVectorMatrixAssembler.cpp.

{
    char const* const num_threads_env = std::getenv("OGS_ASM_THREADS");
 
    if (!num_threads_env)
    {
        return 1;
    }
 
    if (std::strlen(num_threads_env) == 0)
    {
        OGS_FATAL("The environment variable OGS_ASM_THREADS is set but empty.");
    }
 
    std::string num_threads_str{num_threads_env};
    BaseLib::trim(num_threads_str);
 
    std::istringstream num_threads_iss{num_threads_str};
    int num_threads = -1;
 
    num_threads_iss >> num_threads;
 
    if (!num_threads_iss)
    {
        OGS_FATAL("Error parsing OGS_ASM_THREADS (= \"{}\").", num_threads_env);
    }
 
    if (!num_threads_iss.eof())
    {
        OGS_FATAL(
            "Error parsing OGS_ASM_THREADS (= \"{}\"): not read entirely, the "
            "remainder is \"{}\"",
            num_threads_env,
            num_threads_iss.str().substr(num_threads_iss.tellg()));
    }
 
    if (num_threads < 1)
    {
        OGS_FATAL(
            "You asked (via OGS_ASM_THREADS) to assemble with {} < 1 thread.",
            num_threads);
    }
 
    return num_threads;
}

References OGS_FATAL, and BaseLib::trim().

runAssembly()

void anonymous_namespace{ParallelVectorMatrixAssembler.cpp}::runAssembly	(	std::vector< std::tuple< std::ptrdiff_t, std::reference_wrapper< ProcessLib::LocalAssemblerInterface > > > const &	ids_local_assemblers,
		ThreadException &	exception,
		auto	local_matrix_output,
		auto	assemble )

Definition at line 137 of file ParallelVectorMatrixAssembler.cpp.

{
    std::ptrdiff_t n_elements =
        static_cast<std::ptrdiff_t>(ids_local_assemblers.size());
 
#pragma omp for nowait
    for (std::ptrdiff_t i = 0; i < n_elements; ++i)
    {
        if (exception)
        {
            continue;
        }
        auto [element_id, loc_asm] = ids_local_assemblers[i];
 
        try
        {
            assemble(element_id, loc_asm);
        }
        catch (...)
        {
            exception.capture();
            continue;
        }
 
        local_matrix_output(element_id);
    }
}

References ThreadException::capture().