AddProcessDataToMesh.cpp File Reference

Detailed Description

Copyright

Copyright (c) 2012-2024, OpenGeoSys Community (http://www.opengeosys.org) Distributed under a Modified BSD License. See accompanying file LICENSE.txt or http://www.opengeosys.org/project/license

Definition in file AddProcessDataToMesh.cpp.

#include "AddProcessDataToMesh.h"
#include "InfoLib/GitInfo.h"
#include "MeshLib/Utils/IntegrationPointWriter.h"
#include "MeshLib/Utils/getOrCreateMeshProperty.h"
#include "NumLib/TimeStepping/Time.h"
#include "ProcessLib/Output/SecondaryVariable.h"
#include "ProcessLib/ProcessVariable.h"
#include "MeshLib/NodePartitionedMesh.h"
#include "NumLib/DOF/LocalToGlobalIndexMap.h"

Include dependency graph for AddProcessDataToMesh.cpp:

Go to the source code of this file.

Namespaces
namespace	ProcessLib

Functions
static void	addOgsVersion (MeshLib::Mesh &mesh)
static void	addSecondaryVariableNodes (NumLib::Time const &t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, ProcessLib::SecondaryVariable const &var, std::string const &output_name, MeshLib::Mesh &mesh)
static void	addSecondaryVariableResiduals (NumLib::Time const &t, std::vector< GlobalVector * > const &x, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_table, ProcessLib::SecondaryVariable const &var, std::string const &output_name, MeshLib::Mesh &mesh)
static std::vector< double >	copySolutionVector (GlobalVector const &x)
MeshLib::PropertyVector< std::size_t > const *	getBulkNodeIdMapForPetscIfNecessary (MeshLib::Mesh const &mesh, NumLib::LocalToGlobalIndexMap const &dof_table, NumLib::LocalToGlobalIndexMap const &bulk_mesh_dof_table)
static GlobalIndexType	getIndexForComponentInSolutionVector (std::size_t const mesh_id, std::size_t const node_id, bool const is_ghost_node, int const global_component_id, GlobalVector const &x, NumLib::LocalToGlobalIndexMap const &dof_table, NumLib::LocalToGlobalIndexMap const &bulk_mesh_dof_table, MeshLib::PropertyVector< std::size_t > const *const bulk_node_id_map)
static bool	isGhostNode (MeshLib::Mesh const &mesh, std::size_t const node_id)
static std::set< std::string >	addPrimaryVariablesToMesh (MeshLib::Mesh &mesh, GlobalVector const &x, std::vector< std::reference_wrapper< ProcessLib::ProcessVariable > > const &process_variables, std::set< std::string > const &output_variables, NumLib::LocalToGlobalIndexMap const &dof_table, NumLib::LocalToGlobalIndexMap const &bulk_mesh_dof_table)
static void	addSecondaryVariablesToMesh (ProcessLib::SecondaryVariableCollection const &secondary_variables, std::set< std::string > &names_of_already_output_variables, NumLib::Time const &t, std::vector< GlobalVector * > const &xs, MeshLib::Mesh &mesh, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, bool const output_residuals)
void	ProcessLib::addProcessDataToMesh (NumLib::Time const &t, std::vector< GlobalVector * > const &xs, int const process_id, ProcessOutputData const &process_output_data, bool const output_secondary_variables, OutputDataSpecification const &process_output)

Function Documentation

addOgsVersion()

static void addOgsVersion ( MeshLib::Mesh & mesh )

static

Copies the ogs_version string containing the release number and the git hash.

Definition at line 26 of file AddProcessDataToMesh.cpp.

{
    auto& ogs_version_field = *MeshLib::getOrCreateMeshProperty<char>(
        mesh, GitInfoLib::GitInfo::OGS_VERSION,
        MeshLib::MeshItemType::IntegrationPoint, 1);
 
    ogs_version_field.assign(GitInfoLib::GitInfo::ogs_version.begin(),
                             GitInfoLib::GitInfo::ogs_version.end());
}

References MeshLib::getOrCreateMeshProperty(), MeshLib::IntegrationPoint, GitInfoLib::GitInfo::OGS_VERSION, and GitInfoLib::GitInfo::ogs_version.

Referenced by ProcessLib::addProcessDataToMesh().

addPrimaryVariablesToMesh()

static std::set< std::string > addPrimaryVariablesToMesh ( MeshLib::Mesh & mesh, GlobalVector const & x, std::vector< std::reference_wrapper< ProcessLib::ProcessVariable > > const & process_variables, std::set< std::string > const & output_variables, NumLib::LocalToGlobalIndexMap const & dof_table, NumLib::LocalToGlobalIndexMap const & bulk_mesh_dof_table )

static

Adds data for the given process_variables to the given mesh, if they occur in output_variables.

Parameters

mesh	the mesh the data is added to.
x	the global solution vector providing the data.
process_variables	the primary variables comprising x.
output_variables	the names of variables that can be added to the mesh.
dof_table	the d.o.f. table related to the passed mesh and solution vector x.
bulk_mesh_dof_table	the d.o.f. table related to the entire simulation domain and the passed solution vector x.

Note

Usually mesh and the full simulation domain are the same. But if output should be written to a sub mesh, they will differ. In that case, also the two d.o.f. tables will be different from each other.

The dof_table must correspond to the mesh, to the solution vector x and to the process_variables. I.e., if there are, e.g., two primary variables in x, there must also be two variables in the dof_table and two entries in process_variables and so on.

The dof_table must correspond to the bulk_mesh_dof_table, i.e., the former must have been derived from the latter. In particular, both must have the same number of variables and components.

Returns

The names of all variables that have been written to the mesh.

Definition at line 239 of file AddProcessDataToMesh.cpp.

{
    if (dof_table.getNumberOfVariables() !=
            bulk_mesh_dof_table.getNumberOfVariables() ||
        dof_table.getNumberOfGlobalComponents() !=
            bulk_mesh_dof_table.getNumberOfGlobalComponents())
    {
        OGS_FATAL(
            "The d.o.f. table for the passed mesh must have the same number of "
            "variables and global components as the d.o.f. table for the full "
            "simulation domain. But the values differ: {} != {} (variables) or "
            "{} != {} (global components).",
            dof_table.getNumberOfVariables(),
            bulk_mesh_dof_table.getNumberOfVariables(),
            dof_table.getNumberOfGlobalComponents(),
            bulk_mesh_dof_table.getNumberOfGlobalComponents());
    }
 
    auto const number_of_dof_variables = dof_table.getNumberOfVariables();
 
    if (number_of_dof_variables != static_cast<int>(process_variables.size()))
    {
        OGS_FATAL(
            "The number of variables in the d.o.f. table differs from the "
            "number of primary variables of the process {} != {}.",
            number_of_dof_variables, process_variables.size());
    }
 
    auto const x_copy = copySolutionVector(x);
    std::set<std::string> names_of_already_output_variables;
 
    int global_component_offset_next = 0;
 
    auto const* const bulk_node_id_map = getBulkNodeIdMapForPetscIfNecessary(
        mesh, dof_table, bulk_mesh_dof_table);
 
    for (int variable_id = 0; variable_id < number_of_dof_variables;
         ++variable_id)
    {
        auto const& pv = process_variables[variable_id].get();
        auto const n_components = pv.getNumberOfGlobalComponents();
 
        // increase global component offset even if we do not add anything in
        // this iteration
        int global_component_offset = global_component_offset_next;
        global_component_offset_next += n_components;
 
        if (!output_variables.empty() &&
            !output_variables.contains(pv.getName()))
        {
            continue;
        }
 
        names_of_already_output_variables.insert(pv.getName());
 
        DBUG("  process variable {:s}", pv.getName());
 
        auto& output_data = *MeshLib::getOrCreateMeshProperty<double>(
            mesh, pv.getName(), MeshLib::MeshItemType::Node, n_components);
 
        // mesh subsets are the same for all components
        int const dummy_component_id = 0;
        auto const& mesh_subset =
            dof_table.getMeshSubset(variable_id, dummy_component_id);
        auto const mesh_id = mesh_subset.getMeshID();
 
        for (auto const* node : mesh_subset.getNodes())
        {
            auto const node_id = node->getID();
            auto const is_ghost_node = isGhostNode(mesh, node_id);
 
            for (int component_id = 0; component_id < n_components;
                 ++component_id)
            {
                auto const global_component_id =
                    global_component_offset + component_id;
 
                auto const in_index = getIndexForComponentInSolutionVector(
                    mesh_id, node_id, is_ghost_node, global_component_id, x,
                    dof_table, bulk_mesh_dof_table, bulk_node_id_map);
 
                // per node ordering of components
                auto const out_index = node_id * n_components + component_id;
 
                // request for index of linear quantities at higher order nodes
                // results in returning NumLib::MeshComponentMap::nop
                if (in_index == NumLib::MeshComponentMap::nop)
                {
                    output_data[out_index] = 0;
                    continue;
                }
 
                output_data[out_index] = x_copy[in_index];
            }
        }
    }
 
    return names_of_already_output_variables;
}

References copySolutionVector(), DBUG(), getBulkNodeIdMapForPetscIfNecessary(), getIndexForComponentInSolutionVector(), MeshLib::MeshSubset::getMeshID(), NumLib::LocalToGlobalIndexMap::getMeshSubset(), MeshLib::Mesh::getName(), NumLib::LocalToGlobalIndexMap::getNumberOfGlobalComponents(), NumLib::LocalToGlobalIndexMap::getNumberOfVariables(), MeshLib::getOrCreateMeshProperty(), isGhostNode(), MeshLib::Node, NumLib::MeshComponentMap::nop, and OGS_FATAL.

Referenced by ProcessLib::addProcessDataToMesh().

addSecondaryVariableNodes()

static void addSecondaryVariableNodes ( NumLib::Time const & t, std::vector< GlobalVector * > const & x, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables, ProcessLib::SecondaryVariable const & var, std::string const & output_name, MeshLib::Mesh & mesh )

static

Definition at line 36 of file AddProcessDataToMesh.cpp.

{
    DBUG("  secondary variable {:s}", output_name);
 
    auto& nodal_values_mesh = *MeshLib::getOrCreateMeshProperty<double>(
        mesh, output_name, MeshLib::MeshItemType::Node,
        var.fcts.num_components);
    if (nodal_values_mesh.size() !=
        mesh.getNumberOfNodes() * var.fcts.num_components)
    {
        OGS_FATAL(
            "Nodal property `{:s}' does not have the right number of "
            "components. Expected: {:d}, actual: {:d}",
            output_name,
            mesh.getNumberOfNodes() * var.fcts.num_components,
            nodal_values_mesh.size());
    }
 
    std::unique_ptr<GlobalVector> result_cache;
    auto const& nodal_values =
        var.fcts.eval_field(t(), x, dof_tables, result_cache);
 
#ifdef USE_PETSC
    std::size_t const global_vector_size =
        nodal_values.getLocalSize() + nodal_values.getGhostSize();
#else
    std::size_t const global_vector_size = nodal_values.size();
#endif
    if (nodal_values_mesh.size() != global_vector_size)
    {
        OGS_FATAL(
            "Secondary variable `{:s}' did not evaluate to the right number of "
            "components. Expected: {:d}, actual: {:d}.",
            var.name, nodal_values_mesh.size(), global_vector_size);
    }
 
    // Copy result
    nodal_values.copyValues(nodal_values_mesh);
}

References DBUG(), ProcessLib::SecondaryVariableFunctions::eval_field, ProcessLib::SecondaryVariable::fcts, MeshLib::Mesh::getNumberOfNodes(), MeshLib::getOrCreateMeshProperty(), ProcessLib::SecondaryVariable::name, MeshLib::Node, ProcessLib::SecondaryVariableFunctions::num_components, and OGS_FATAL.

Referenced by addSecondaryVariablesToMesh().

addSecondaryVariableResiduals()

static void addSecondaryVariableResiduals ( NumLib::Time const & t, std::vector< GlobalVector * > const & x, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_table, ProcessLib::SecondaryVariable const & var, std::string const & output_name, MeshLib::Mesh & mesh )

static

Definition at line 82 of file AddProcessDataToMesh.cpp.

{
    if (!var.fcts.eval_residuals)
    {
        return;
    }
 
    DBUG("  secondary variable {:s} residual", output_name);
    auto const& property_name_res = output_name + "_residual";
 
    auto& residuals_mesh = *MeshLib::getOrCreateMeshProperty<double>(
        mesh, property_name_res, MeshLib::MeshItemType::Cell,
        var.fcts.num_components);
    if (residuals_mesh.size() !=
        mesh.getNumberOfElements() * var.fcts.num_components)
    {
        OGS_FATAL(
            "Cell property `{:s}' does not have the right number of "
            "components. Expected: {:d}, actual: {:d}",
            property_name_res,
            mesh.getNumberOfElements() * var.fcts.num_components,
            residuals_mesh.size());
    }
 
    std::unique_ptr<GlobalVector> result_cache;
    auto const& residuals =
        var.fcts.eval_residuals(t(), x, dof_table, result_cache);
#ifdef USE_PETSC
    std::size_t const global_vector_size =
        residuals.getLocalSize() + residuals.getGhostSize();
#else
    std::size_t const global_vector_size = residuals.size();
#endif
    if (residuals_mesh.size() != global_vector_size)
    {
        OGS_FATAL(
            "The residual of secondary variable `{:s}' did not evaluate to the "
            "right number of components. Expected: {:d}, actual: {:d}.",
            var.name, residuals_mesh.size(), global_vector_size);
    }
 
    // Copy result
    residuals.copyValues(residuals_mesh);
}

References MeshLib::Cell, DBUG(), ProcessLib::SecondaryVariableFunctions::eval_residuals, ProcessLib::SecondaryVariable::fcts, MeshLib::Mesh::getNumberOfElements(), MeshLib::getOrCreateMeshProperty(), ProcessLib::SecondaryVariable::name, ProcessLib::SecondaryVariableFunctions::num_components, and OGS_FATAL.

Referenced by addSecondaryVariablesToMesh().

addSecondaryVariablesToMesh()

static void addSecondaryVariablesToMesh ( ProcessLib::SecondaryVariableCollection const & secondary_variables, std::set< std::string > & names_of_already_output_variables, NumLib::Time const & t, std::vector< GlobalVector * > const & xs, MeshLib::Mesh & mesh, std::vector< NumLib::LocalToGlobalIndexMap const * > const & dof_tables, bool const output_residuals )

static

Definition at line 346 of file AddProcessDataToMesh.cpp.

{
    for (auto const& external_variable_name : secondary_variables)
    {
        auto const& name = external_variable_name.first;
        if (!names_of_already_output_variables.insert(name).second)
        {
            // no insertion took place, output already done
            continue;
        }
 
        addSecondaryVariableNodes(t, xs, dof_tables,
                                  secondary_variables.get(name), name, mesh);
 
        if (output_residuals)
        {
            addSecondaryVariableResiduals(
                t, xs, dof_tables, secondary_variables.get(name), name, mesh);
        }
    }
}

References addSecondaryVariableNodes(), addSecondaryVariableResiduals(), and ProcessLib::SecondaryVariableCollection::get().

Referenced by ProcessLib::addProcessDataToMesh().

copySolutionVector()

static std::vector< double > copySolutionVector ( GlobalVector const & x )

static

Definition at line 133 of file AddProcessDataToMesh.cpp.

{
    std::vector<double> x_copy;
    x.copyValues(x_copy);
    return x_copy;
}

References MathLib::EigenVector::copyValues().

Referenced by addPrimaryVariablesToMesh().

getBulkNodeIdMapForPetscIfNecessary()

MeshLib::PropertyVector< std::size_t > const * getBulkNodeIdMapForPetscIfNecessary	(	MeshLib::Mesh const &	mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		NumLib::LocalToGlobalIndexMap const &	bulk_mesh_dof_table )

Definition at line 140 of file AddProcessDataToMesh.cpp.

{
#ifdef USE_PETSC
 
    if (&bulk_mesh_dof_table != &dof_table)
    {
        auto const bulk_id_string =
            MeshLib::getBulkIDString(MeshLib::MeshItemType::Node);
        if (!mesh.getProperties().existsPropertyVector<std::size_t>(
                bulk_id_string))
        {
            OGS_FATAL(
                "The required bulk node ids map does not exist in "
                "the boundary mesh '{:s}' or has the wrong data "
                "type (should be equivalent to C++ data type "
                "std::size_t which is an unsigned integer of size "
                "{:d} or UInt64 in vtk terminology).",
                mesh.getName(), sizeof(std::size_t));
        }
        return mesh.getProperties().getPropertyVector<std::size_t>(
            bulk_id_string);
    }
#endif
 
    return nullptr;
}

References MeshLib::getBulkIDString(), MeshLib::Node, and OGS_FATAL.

Referenced by addPrimaryVariablesToMesh().

getIndexForComponentInSolutionVector()

static GlobalIndexType getIndexForComponentInSolutionVector ( std::size_t const mesh_id, std::size_t const node_id, bool const is_ghost_node, int const global_component_id, GlobalVector const & x, NumLib::LocalToGlobalIndexMap const & dof_table, NumLib::LocalToGlobalIndexMap const & bulk_mesh_dof_table, MeshLib::PropertyVector< std::size_t > const *const bulk_node_id_map )

static

Definition at line 170 of file AddProcessDataToMesh.cpp.

{
#ifdef USE_PETSC
    if (is_ghost_node && &bulk_mesh_dof_table != &dof_table)
    {
        auto const bulk_node_id = (*bulk_node_id_map)[node_id];
        std::size_t const bulk_mesh_id = 0;
 
        MeshLib::Location const loc(bulk_mesh_id, MeshLib::MeshItemType::Node,
                                    bulk_node_id);
 
        // early return!
        return bulk_mesh_dof_table.getLocalIndex(
            loc, global_component_id, x.getRangeBegin(), x.getRangeEnd());
    }
#endif
 
    MeshLib::Location const loc(mesh_id, MeshLib::MeshItemType::Node, node_id);
 
    return dof_table.getLocalIndex(loc, global_component_id, x.getRangeBegin(),
                                   x.getRangeEnd());
}

References NumLib::LocalToGlobalIndexMap::getLocalIndex(), MathLib::EigenVector::getRangeBegin(), MathLib::EigenVector::getRangeEnd(), and MeshLib::Node.

Referenced by addPrimaryVariablesToMesh().

isGhostNode()

static bool isGhostNode ( MeshLib::Mesh const & mesh, std::size_t const node_id )

static

Definition at line 199 of file AddProcessDataToMesh.cpp.

{
#ifndef USE_PETSC
    return false;
#else
    return static_cast<MeshLib::NodePartitionedMesh const&>(mesh).isGhostNode(
        node_id);
#endif
}

References isGhostNode().

Referenced by addPrimaryVariablesToMesh(), and isGhostNode().