MeshToolsLib::anonymous_namespace{OverwriteMeshFieldDataByMaterialIDs.cpp} Namespace Reference

Classes
struct	WriteGroup

Functions
std::vector< WriteGroup >	collectWriteGroups (InitialConditionDataSet const &initial_condition, MeshLib::PropertyVector< double > const &pv, MeshLib::Properties const &properties)

Function Documentation

collectWriteGroups()

std::vector< WriteGroup > MeshToolsLib::anonymous_namespace{OverwriteMeshFieldDataByMaterialIDs.cpp}::collectWriteGroups	(	InitialConditionDataSet const &	initial_condition,
		MeshLib::PropertyVector< double > const &	pv,
		MeshLib::Properties const &	properties )

Collects the write groups for initial_condition according to its mesh item type. The three supported item types (integration point, cell, node) differ only in which slots are written and where a parameter is evaluated; everything else is shared by overwriteMeshFieldDataByMaterialIDs().

Definition at line 37 of file OverwriteMeshFieldDataByMaterialIDs.cpp.

{
    auto const& mesh = *initial_condition.mesh;
    auto const& element_ids =
        initial_condition.element_ids_for_selected_materials;
 
    std::vector<WriteGroup> groups;
 
    switch (initial_condition.mesh_item_type)
    {
        case MeshLib::MeshItemType::IntegrationPoint:
        {
            auto const element_ip_data_offsets =
                getIntegrationPointDataOffsetsOfMeshElements(mesh.getElements(),
                                                             pv, properties);
            // getIntegrationPointDataOffsetsOfMeshElements() returns an empty
            // vector for a property whose name does not contain "_ip" (it is
            // then not treated as integration-point data). Indexing it by
            // element id below would be an out-of-bounds access.
            if (element_ip_data_offsets.empty())
            {
                OGS_FATAL(
                    "overwrite_mesh_data: integration-point property '{:s}' "
                    "carries no integration-point data offsets. Only fields "
                    "whose name contains '_ip' are treated as "
                    "integration-point data.",
                    initial_condition.variable_name);
            }
            auto const n = pv.getNumberOfGlobalComponents();
            groups.reserve(element_ids.size());
            for (auto const element_id : element_ids)
            {
                // A parameter is evaluated once per element at the centroid and
                // written to all of the element's integration points (a single
                // write group spanning them). This is exact for the intended
                // constant-per-material use case. Do not turn this into a
                // per-integration-point evaluation without also reproducing the
                // exact integration rule and point ordering used by the process
                // local assembler that wrote this field: computing the points
                // in a different order would associate values with the wrong
                // slots.
                ParameterLib::SpatialPosition pos;
                pos.setElementID(element_id);
                pos.setCoordinates(
                    MeshLib::getCenterOfGravity(*mesh.getElement(element_id)));
                // The offsets are flat (already multiplied by the number of
                // components); divide to obtain slot (integration point)
                // indices.
                groups.push_back({pos, element_ip_data_offsets[element_id] / n,
                                  element_ip_data_offsets[element_id + 1] / n});
            }
            break;
        }
        case MeshLib::MeshItemType::Cell:
        {
            groups.reserve(element_ids.size());
            for (auto const element_id : element_ids)
            {
                ParameterLib::SpatialPosition pos;
                pos.setElementID(element_id);
                pos.setCoordinates(
                    MeshLib::getCenterOfGravity(*mesh.getElement(element_id)));
                groups.push_back({pos, element_id, element_id + 1});
            }
            break;
        }
        case MeshLib::MeshItemType::Node:
        {
            for (auto const element_id : element_ids)
            {
                for (auto const* node : mesh.getElement(element_id)->nodes())
                {
                    std::size_t const node_id = node->getID();
                    // Evaluate the parameter at the node position, not the
                    // element centre.
                    groups.push_back(
                        {ParameterLib::SpatialPosition{node_id, {}, *node},
                         node_id, node_id + 1});
                }
            }
            break;
        }
        default:
            OGS_FATAL(
                "The mesh item type of the initial condition for property "
                "'{:s}' is not supported. Only integration point, cell, and "
                "node data are supported.",
                initial_condition.variable_name);
    }
 
    return groups;
}

References MeshLib::Cell, collectWriteGroups(), MeshToolsLib::InitialConditionDataSet::element_ids_for_selected_materials, MeshLib::getCenterOfGravity(), MeshToolsLib::getIntegrationPointDataOffsetsOfMeshElements(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::IntegrationPoint, MeshToolsLib::InitialConditionDataSet::mesh, MeshToolsLib::InitialConditionDataSet::mesh_item_type, MeshLib::Node, OGS_FATAL, ParameterLib::SpatialPosition::setCoordinates(), ParameterLib::SpatialPosition::setElementID(), and MeshToolsLib::InitialConditionDataSet::variable_name.

Referenced by collectWriteGroups().