Functions
bool	isSimulationDomain (MeshLib::Mesh const &mesh, ProcessLib::Process const &process)

std::vector< std::unique_ptr< NumLib::LocalToGlobalIndexMap > >	computeDofTablesForSubmesh (ProcessLib::Process const &process, MeshLib::Mesh const &submesh, std::size_t const n_processes)

std::vector< NumLib::LocalToGlobalIndexMap const * >	toNonOwning (std::vector< std::unique_ptr< NumLib::LocalToGlobalIndexMap > > const &dof_tables)

std::vector< NumLib::LocalToGlobalIndexMap const * >	getDofTablesOfAllProcesses (ProcessLib::Process const &process, std::size_t const n_processes)

decltype(auto)	computeOutputMeshDofTables (ProcessLib::Process const &process, MeshLib::Mesh const &output_mesh, std::vector< NumLib::LocalToGlobalIndexMap const * > const &bulk_mesh_dof_tables)

std::vector< std::reference_wrapper< const std::vector< std::reference_wrapper< ProcessLib::ProcessVariable > > > >	getProcessVariablesOfAllProcesses (ProcessLib::Process const &process, std::size_t const n_processes)

std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > const *	getIntegrationPointWriters (ProcessLib::Process const &process, MeshLib::Mesh const &output_mesh)

Function Documentation

◆ computeDofTablesForSubmesh()

std::vector< std::unique_ptr< NumLib::LocalToGlobalIndexMap > > anonymous_namespace{ProcessOutputData.cpp}::computeDofTablesForSubmesh	(	ProcessLib::Process const &	process,
		MeshLib::Mesh const &	submesh,
		std::size_t const	n_processes )

Definition at line 26 of file ProcessOutputData.cpp.

{
    std::vector<std::unique_ptr<NumLib::LocalToGlobalIndexMap>>
        submesh_dof_tables;
    submesh_dof_tables.reserve(n_processes);
 
    for (std::size_t i = 0; i < n_processes; ++i)
    {
        submesh_dof_tables.push_back(
            process.getDOFTable(i).deriveBoundaryConstrainedMap(
                MeshLib::MeshSubset{submesh, submesh.getNodes()}));
    }
 
    return submesh_dof_tables;
}

References NumLib::LocalToGlobalIndexMap::deriveBoundaryConstrainedMap(), and ProcessLib::Process::getDOFTable().

Referenced by computeOutputMeshDofTables().

◆ computeOutputMeshDofTables()

decltype(auto) anonymous_namespace{ProcessOutputData.cpp}::computeOutputMeshDofTables	(	ProcessLib::Process const &	process,
		MeshLib::Mesh const &	output_mesh,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	bulk_mesh_dof_tables )

Computes the d.o.f. tables for the given output_mesh.

These are the passed bulk_mesh_dof_tables for output of the entire simulation domain of the given process. In the case of submesh output d.o.f. tables for the submesh will be computed.

Returns: A pair of (vector of d.o.f. table pointers, vector of d.o.f. table storage), where the latter is populated in the case of submesh output only.

Each element in the returned vectors corresponds to a specific process_id of the process.

Definition at line 84 of file ProcessOutputData.cpp.

{
    if (isSimulationDomain(output_mesh, process))
    {
        return std::pair(
            bulk_mesh_dof_tables /* will be copied */,
            std::vector<std::unique_ptr<NumLib::LocalToGlobalIndexMap>>{});
    }
 
    auto const n_processes = bulk_mesh_dof_tables.size();
 
    // TODO Currently these d.o.f. tables will be recomputed every time we write
    // output. That should be avoided in the future.
    auto container_that_owns_output_mesh_dof_tables =
        computeDofTablesForSubmesh(process, output_mesh, n_processes);
 
    auto output_mesh_dof_tables =
        toNonOwning(container_that_owns_output_mesh_dof_tables);
 
    return std::pair(std::move(output_mesh_dof_tables),
                     std::move(container_that_owns_output_mesh_dof_tables));
}

References computeDofTablesForSubmesh(), isSimulationDomain(), and toNonOwning().

◆ getDofTablesOfAllProcesses()

std::vector< NumLib::LocalToGlobalIndexMap const * > anonymous_namespace{ProcessOutputData.cpp}::getDofTablesOfAllProcesses	(	ProcessLib::Process const &	process,
		std::size_t const	n_processes )

Definition at line 59 of file ProcessOutputData.cpp.

{
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables_of_all_procs(
        n_processes);
 
    for (std::size_t proc_id = 0; proc_id < n_processes; ++proc_id)
    {
        dof_tables_of_all_procs[proc_id] = &process.getDOFTable(proc_id);
    }
 
    return dof_tables_of_all_procs;
}

References ProcessLib::Process::getDOFTable().

◆ getIntegrationPointWriters()

std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > const * anonymous_namespace{ProcessOutputData.cpp}::getIntegrationPointWriters	(	ProcessLib::Process const &	process,
		MeshLib::Mesh const &	output_mesh )

Definition at line 130 of file ProcessOutputData.cpp.

{
    return isSimulationDomain(output_mesh, process)
               ? &process.getIntegrationPointWriters()
               : nullptr;
}

References ProcessLib::Process::getIntegrationPointWriters(), and isSimulationDomain().

◆ getProcessVariablesOfAllProcesses()

std::vector< std::reference_wrapper< const std::vector< std::reference_wrapper< ProcessLib::ProcessVariable > > > > anonymous_namespace{ProcessOutputData.cpp}::getProcessVariablesOfAllProcesses	(	ProcessLib::Process const &	process,
		std::size_t const	n_processes )

Definition at line 113 of file ProcessOutputData.cpp.

{
    std::vector<std::reference_wrapper<
        const std::vector<std::reference_wrapper<ProcessLib::ProcessVariable>>>>
        pvs_of_all_procs;
    pvs_of_all_procs.reserve(n_processes);
 
    for (std::size_t proc_id = 0; proc_id < n_processes; ++proc_id)
    {
        pvs_of_all_procs.emplace_back(process.getProcessVariables(proc_id));
    }
 
    return pvs_of_all_procs;
}

References ProcessLib::Process::getProcessVariables().

◆ isSimulationDomain()

bool anonymous_namespace{ProcessOutputData.cpp}::isSimulationDomain	(	MeshLib::Mesh const &	mesh,
		ProcessLib::Process const &	process )

Checks if the given mesh is the simulation domain of the given process.

Definition at line 19 of file ProcessOutputData.cpp.

{
    return mesh == process.getMesh();
}

References ProcessLib::Process::getMesh().

Referenced by computeOutputMeshDofTables(), and getIntegrationPointWriters().

◆ toNonOwning()

std::vector< NumLib::LocalToGlobalIndexMap const * > anonymous_namespace{ProcessOutputData.cpp}::toNonOwning ( std::vector< std::unique_ptr< NumLib::LocalToGlobalIndexMap > > const & dof_tables )

Definition at line 44 of file ProcessOutputData.cpp.

{
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table_pointers;
 
    dof_table_pointers.reserve(dof_tables.size());
    transform(cbegin(dof_tables), cend(dof_tables),
              back_inserter(dof_table_pointers),
              [](std::unique_ptr<NumLib::LocalToGlobalIndexMap> const& p)
              { return p.get(); });
 
    return dof_table_pointers;
}