Detailed Description

Property manager on mesh items. Class Properties manages scalar, vector or matrix properties. For instance in groundwater flow porosity is a scalar property and permeabilty can be stored as a tensor property. Properties are assigned to mesh items, i.e. Node or Element objects. The createNewPropertyVector() method first creates a PropertyVector of template type T (scalar, vector or matrix). This class stores the PropertyVector, accessible by a combination of the name and the type of the mesh item (Node or Element).

Definition at line 35 of file Properties.h.

#include <Properties.h>

Public Member Functions
template<typename T >
PropertyVector< T > *	createNewPropertyVector (std::string_view name, MeshItemType mesh_item_type, std::size_t n_components=1)

template<typename T >
PropertyVector< T > *	createNewPropertyVector (std::string const &name, std::size_t n_prop_groups, std::vector< std::size_t > const &item2group_mapping, MeshItemType mesh_item_type, std::size_t n_components=1)

template<typename T >
bool	existsPropertyVector (std::string_view name) const

template<typename T >
bool	existsPropertyVector (std::string_view name, MeshItemType const mesh_item_type, int const number_of_components) const

template<typename T >
PropertyVector< T > const *	getPropertyVector (std::string_view name) const

template<typename T >
PropertyVector< T > *	getPropertyVector (std::string_view name)

template<typename T >
PropertyVector< T > const *	getPropertyVector (std::string_view name, MeshItemType const item_type, int const n_components) const

template<typename T >
PropertyVector< T > *	getPropertyVector (std::string_view name, MeshItemType const item_type, int const n_components)

void	removePropertyVector (std::string_view name)

bool	hasPropertyVector (std::string_view name) const

template<typename T >
bool	hasPropertyVector (std::string const &name, MeshItemType const item_type) const

std::vector< std::string >	getPropertyVectorNames () const

std::vector< std::string >	getPropertyVectorNames (MeshLib::MeshItemType t) const

Properties	excludeCopyProperties (std::vector< std::size_t > const &exclude_elem_ids, std::vector< std::size_t > const &exclude_node_ids) const

Properties	excludeCopyProperties (std::vector< MeshItemType > const &exclude_mesh_item_types) const

	Properties ()=default

	Properties (Properties const &properties)

	Properties (Properties &&properties)=default

Properties &	operator= (Properties const &properties)

Properties &	operator= (Properties &&properties)=default

	~Properties ()

std::map< std::string, PropertyVectorBase * >::const_iterator	begin () const

std::map< std::string, PropertyVectorBase * >::const_iterator	end () const

std::map< std::string, PropertyVectorBase * >::iterator	begin ()

std::map< std::string, PropertyVectorBase * >::iterator	end ()

std::map< std::string, PropertyVectorBase * >::size_type	size () const

std::map< std::string, PropertyVectorBase * >::size_type	size (MeshItemType const mesh_item_type) const

template<typename T >
PropertyVector< T > *	createNewPropertyVector (std::string_view name, MeshItemType mesh_item_type, std::size_t n_components)

template<typename T >
PropertyVector< T > *	createNewPropertyVector (std::string const &name, std::size_t n_prop_groups, std::vector< std::size_t > const &item2group_mapping, MeshItemType mesh_item_type, std::size_t n_components)

template<typename T >
bool	existsPropertyVector (std::string_view name) const

template<typename T >
bool	existsPropertyVector (std::string_view name, MeshItemType const mesh_item_type, int const number_of_components) const

template<typename T >
PropertyVector< T > const *	getPropertyVector (std::string_view name) const

template<typename T >
PropertyVector< T > *	getPropertyVector (std::string_view name)

template<typename T >
bool	hasPropertyVector (std::string const &name, MeshItemType const item_type) const

template<typename T >
PropertyVector< T > const *	getPropertyVector (std::string_view name, MeshItemType const item_type, int const n_components) const

template<typename T >
PropertyVector< T > *	getPropertyVector (std::string_view name, MeshItemType const item_type, int const n_components)

template<typename T >
PropertyVector< T > const *	getPropertyVector (std::string_view name) const

template<typename T >
PropertyVector< T > const *	getPropertyVector (std::string_view name, MeshItemType const item_type, int const n_components) const

Private Attributes
std::map< std::string, PropertyVectorBase * >	_properties

Constructor & Destructor Documentation

◆ Properties() [1/3]

MeshLib::Properties::Properties ( )

default

◆ Properties() [2/3]

MeshLib::Properties::Properties ( Properties const & properties )

Definition at line 103 of file Properties.cpp.

    : _properties(properties._properties)
{
    for (auto& name_vector_pair : _properties)
    {
        PropertyVectorBase* t(name_vector_pair.second->clone({}));
        name_vector_pair.second = t;
    }
}

References _properties.

◆ Properties() [3/3]

MeshLib::Properties::Properties ( Properties && properties )

default

◆ ~Properties()

MeshLib::Properties::~Properties ( )

Definition at line 132 of file Properties.cpp.

{
    for (auto name_vector_pair : _properties)
    {
        delete name_vector_pair.second;
    }
}

References _properties.

Member Function Documentation

◆ begin() [1/2]

std::map< std::string, PropertyVectorBase * >::iterator MeshLib::Properties::begin ( )

Definition at line 152 of file Properties.cpp.

{
    return _properties.begin();
}

References _properties.

◆ begin() [2/2]

std::map< std::string, PropertyVectorBase * >::const_iterator MeshLib::Properties::begin ( ) const

Definition at line 140 of file Properties.cpp.

{
    return _properties.cbegin();
}

References _properties.

Referenced by size().

◆ createNewPropertyVector() [1/4]

template<typename T >

PropertyVector< T > * MeshLib::Properties::createNewPropertyVector	(	std::string const &	name,
		std::size_t	n_prop_groups,
		std::vector< std::size_t > const &	item2group_mapping,
		MeshItemType	mesh_item_type,
		std::size_t	n_components )

Definition at line 34 of file Properties-impl.h.

{
    // check if there is already a PropertyVector with the same name
    auto it(_properties.find(name));
    if (it != _properties.end()) {
        ERR("A property of the name '{:s}' already assigned to the mesh.",
            name);
        return nullptr;
    }
 
    // check entries of item2group_mapping for consistence
    for (std::size_t k(0); k<item2group_mapping.size(); k++) {
        std::size_t const group_id (item2group_mapping[k]);
        if (group_id >= n_prop_groups) {
            ERR("The mapping to property {:d} for item {:d} is not in the "
                "correct range [0,{:d}).",
                group_id, k, n_prop_groups);
            return nullptr;
        }
    }
 
    auto entry_info(
        _properties.insert(
            std::pair<std::string, PropertyVectorBase*>(
                name,
                new PropertyVector<T>(n_prop_groups,
                    item2group_mapping, name, mesh_item_type, n_components)
            )
        )
    );
    return static_cast<PropertyVector<T>*>((entry_info.first)->second);
}

References ERR().

◆ createNewPropertyVector() [2/4]

template<typename T >

PropertyVector< T > * MeshLib::Properties::createNewPropertyVector	(	std::string const &	name,
		std::size_t	n_prop_groups,
		std::vector< std::size_t > const &	item2group_mapping,
		MeshItemType	mesh_item_type,
		std::size_t	n_components = 1 )

Method creates a PropertyVector if a PropertyVector with the same name and the same type T was not already created before. In case there exists already such a PropertyVector a nullptr is returned. This method is used if only a small number of distinct property values in a property exist (e.g. mapping property groups to elements). In this case a mapping between mesh items and properties (stored on the heap), see the parameter item2group_mapping, is required.

Template Parameters

T	type of the property value

Parameters

name	the name of the property
n_prop_groups	number of distinct property groups
item2group_mapping	the mapping between mesh item and the property group
mesh_item_type	for instance node or element assigned properties
n_components	number of components for each tuple

Returns: A pointer to a PropertyVector on success and a nullptr otherwise.

Definition at line 35 of file Properties.h.

{
public:
    template <typename T>
    PropertyVector<T>* createNewPropertyVector(std::string_view name,
                                               MeshItemType mesh_item_type,
                                               std::size_t n_components = 1);
 

References createNewPropertyVector(), and createNewPropertyVector().

Referenced by createNewPropertyVector().

◆ createNewPropertyVector() [3/4]

template<typename T >

PropertyVector< T > * MeshLib::Properties::createNewPropertyVector	(	std::string_view	name,
		MeshItemType	mesh_item_type,
		std::size_t	n_components )

Definition at line 16 of file Properties-impl.h.

{
    auto it(_properties.find(std::string(name)));
    if (it != _properties.end()) {
        ERR("A property of the name '{:s}' is already assigned to the mesh.",
            name);
        return nullptr;
    }
    auto entry_info(_properties.insert(
        std::make_pair(std::string(name),
                       new PropertyVector<T>(std::string(name), mesh_item_type,
                                             n_components))));
    return static_cast<PropertyVector<T>*>((entry_info.first)->second);
}

References ERR().

◆ createNewPropertyVector() [4/4]

template<typename T >

PropertyVector< T > * MeshLib::Properties::createNewPropertyVector	(	std::string_view	name,
		MeshItemType	mesh_item_type,
		std::size_t	n_components = 1 )

Method creates a PropertyVector if a PropertyVector with the same name and the same type T was not already created before. In case there exists already such a PropertyVector a nullptr is returned. There are two versions of this method. This method is used when every mesh item at hand has its own property value, i.e. \(n\) mesh item and \(n\) different property values. The user has to ensure the correct usage of the vector later on.

Template Parameters

T	type of the property value

Parameters

name	the name of the property
mesh_item_type	for instance node or element assigned properties
n_components	number of components for each tuple

Returns: A pointer to a PropertyVector on success and a nullptr otherwise.

Definition at line 17 of file Properties.h.

25{

26

Referenced by CreateStructuredGridDialog::accept(), MeshLib::addPropertyToMesh(), ApplicationUtils::addVtkGhostTypeProperty(), castPropertyVectorToPropertyVector(), MeshToolsLib::RasterToMesh::convert(), MeshLib::VtkMeshConverter::convertTypedArray(), copyDoubleValuedFieldDataToPointCloud(), anonymous_namespace{MeshRevision.cpp}::copyProperties(), ApplicationUtils::copyPropertyVector(), createNewPropertyVector(), MeshToolsLib::MeshLayerMapper::createStaticLayers(), LayeredMeshGenerator::getMesh(), MeshLib::IO::Legacy::MeshIO::loadMeshFromFile(), main(), MeshToolsLib::MeshGenerator::VoxelGridFromMesh::mapArray(), FileIO::Gocad::GocadAsciiReader::parseProperties(), FileIO::Gocad::GocadAsciiReader::readData(), FileIO::GMSH::readGMSHMesh(), FileIO::GMSInterface::readMesh(), FileIO::SwmmInterface::readSwmmInputToLineMesh(), FileIO::TetGenInterface::readTetGenMesh(), MeshToolsLib::Mesh2MeshPropertyInterpolation::setPropertiesForMesh(), and writeDataToMesh().

◆ end() [1/2]

std::map< std::string, PropertyVectorBase * >::iterator MeshLib::Properties::end ( )

Definition at line 157 of file Properties.cpp.

{
    return _properties.end();
}

References _properties.

◆ end() [2/2]

std::map< std::string, PropertyVectorBase * >::const_iterator MeshLib::Properties::end ( ) const

Definition at line 146 of file Properties.cpp.

{
    return _properties.cend();
}

References _properties.

Referenced by size().

◆ excludeCopyProperties() [1/2]

Properties MeshLib::Properties::excludeCopyProperties ( std::vector< MeshItemType > const & exclude_mesh_item_types ) const

copy all PropertyVector objects stored in the (internal) map but PropertyVector objects with the given MeshItemType are excluded.

Definition at line 81 of file Properties.cpp.

{
    Properties new_properties;
    for (auto name_vector_pair : _properties)
    {
        if (std::find(exclude_mesh_item_types.begin(),
                      exclude_mesh_item_types.end(),
                      name_vector_pair.second->getMeshItemType()) !=
            exclude_mesh_item_types.end())
        {
            continue;
        }
 
        std::vector<std::size_t> const exclude_positions{};
        new_properties._properties.insert(
            std::make_pair(name_vector_pair.first,
                           name_vector_pair.second->clone(exclude_positions)));
    }
    return new_properties;
}

References _properties.

◆ excludeCopyProperties() [2/2]

Properties MeshLib::Properties::excludeCopyProperties	(	std::vector< std::size_t > const &	exclude_elem_ids,
		std::vector< std::size_t > const &	exclude_node_ids ) const

copy all PropertyVector objects stored in the (internal) map but only those nodes/elements of a PropertyVector whose ids are not in the vectors exclude_*_ids.

Definition at line 57 of file Properties.cpp.

{
    Properties exclude_copy;
    for (auto name_vector_pair : _properties)
    {
        if (name_vector_pair.second->getMeshItemType() == MeshItemType::Cell)
        {
            exclude_copy._properties.insert(std::make_pair(
                name_vector_pair.first,
                name_vector_pair.second->clone(exclude_elem_ids)));
        }
        else if (name_vector_pair.second->getMeshItemType() ==
                 MeshItemType::Node)
        {
            exclude_copy._properties.insert(std::make_pair(
                name_vector_pair.first,
                name_vector_pair.second->clone(exclude_node_ids)));
        }
    }
    return exclude_copy;
}

References _properties, MeshLib::Cell, and MeshLib::Node.

Referenced by MeshToolsLib::convertToLinearMesh(), MeshToolsLib::createQuadraticOrderMesh(), MeshToolsLib::removeElements(), and MeshToolsLib::removeNodes().

◆ existsPropertyVector() [1/4]

template<typename T >

bool MeshLib::Properties::existsPropertyVector ( std::string_view name ) const

Definition at line 73 of file Properties-impl.h.

{
    auto it(_properties.find(std::string(name)));
    // Check that a PropertyVector with the appropriate name exists.
    if (it == _properties.end())
    {
        return false;
    }
    // Check that the PropertyVector has the correct data type.
    return dynamic_cast<PropertyVector<T> const*>(it->second) != nullptr;
}

◆ existsPropertyVector() [2/4]

template<typename T >

bool MeshLib::Properties::existsPropertyVector ( std::string_view name ) const

Checks if a property vector with given name and the given type exists.

Parameters

name	name of the requested property vector

Definition at line 74 of file Properties.h.

Referenced by MeshLib::ElementStatus::ElementStatus(), ProcessLib::SolutionDependentDirichletBoundaryCondition::SolutionDependentDirichletBoundaryCondition(), MeshElementRemovalDialog::accept(), ProcessLib::addBulkMeshPropertyToSubMesh(), MeshToolsLib::addLayerToMesh(), ProcessLib::checkParametersOfDirichletBoundaryCondition(), copyDoubleValuedFieldDataToPointCloud(), anonymous_namespace{MeshRevision.cpp}::copyProperties(), MeshLib::getIntegrationPointMetaData(), MeshLib::getOrCreateMeshProperty(), getSurfaceIntegratedValuesForNodes(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::initializeConcreteProcess(), MeshToolsLib::Mesh2MeshPropertyInterpolation::interpolateElementPropertiesToNodeProperties(), main(), MeshElementRemovalDialog::on_scalarArrayComboBox_currentIndexChanged(), reorderProperty(), MeshLib::scaleMeshPropertyVector(), ProcessLib::setIPDataInitialConditions(), MeshToolsLib::Mesh2MeshPropertyInterpolation::setPropertiesForMesh(), MeshLib::IO::Legacy::MeshIO::write(), FileIO::TetGenInterface::write2dElements(), and MeshLib::IO::VtuInterface::writeVTU().

◆ existsPropertyVector() [3/4]

template<typename T >

bool MeshLib::Properties::existsPropertyVector	(	std::string_view	name,
		MeshItemType const	mesh_item_type,
		int const	number_of_components ) const

Definition at line 86 of file Properties-impl.h.

{
    auto const it = _properties.find(std::string(name));
    if (it == _properties.end())
    {
        return false;
    }
 
    auto property = dynamic_cast<PropertyVector<T>*>(it->second);
    if (property == nullptr)
    {
        WARN("Property {} exists but does not have the requested type {}.",
             name, typeid(T).name());
        return false;
    }
    if (property->getMeshItemType() != mesh_item_type)
    {
        WARN(
            "Property {} exists but does not have the requested mesh item type "
            "{}.",
            name, toString(mesh_item_type));
        return false;
    }
    if (property->getNumberOfGlobalComponents() != number_of_components)
    {
        WARN(
            "Property {} exists but does not have the requested number of "
            "components {}",
            name, number_of_components);
        return false;
    }
    return true;
}

References WARN().

◆ existsPropertyVector() [4/4]

template<typename T >

bool MeshLib::Properties::existsPropertyVector	(	std::string_view	name,
		MeshItemType const	mesh_item_type,
		int const	number_of_components ) const

Checks if a property vector with given type T, name, mesh_item_type, and number_of_components exists.

Definition at line 87 of file Properties.h.

◆ getPropertyVector() [1/10]

template<typename T >

PropertyVector< T > * MeshLib::Properties::getPropertyVector ( std::string_view name )

Definition at line 131 of file Properties-impl.h.

{
    auto it(_properties.find(std::string(name)));
    if (it == _properties.end())
    {
        OGS_FATAL(
            "A PropertyVector with the specified name '{:s}' is not available.",
            name);
    }
    if (!dynamic_cast<PropertyVector<T>*>(it->second))
    {
        OGS_FATAL(
            "The PropertyVector '{:s}' has a different type than the requested "
            "PropertyVector.",
            name);
    }
    return dynamic_cast<PropertyVector<T>*>(it->second);
}

References OGS_FATAL.

◆ getPropertyVector() [2/10]

template<typename T >

PropertyVector< T > * MeshLib::Properties::getPropertyVector ( std::string_view name )

Returns a property vector with given name or aborts calling OGS_FATAL if no such property vector exists.

Definition at line 132 of file Properties.h.

◆ getPropertyVector() [3/10]

template<typename T >

PropertyVector< T > const * MeshLib::Properties::getPropertyVector ( std::string_view name ) const

Definition at line 123 of file Properties-impl.h.

{
    return const_cast<PropertyVector<T> const*>(
        const_cast<Properties*>(this)->getPropertyVector<T>(name));
}

References getPropertyVector().

◆ getPropertyVector() [4/10]

template<typename T >

PropertyVector< T > const * MeshLib::Properties::getPropertyVector ( std::string_view name ) const

Definition at line 124 of file Properties.h.

◆ getPropertyVector() [5/10]

template<typename T >

PropertyVector< T > const * MeshLib::Properties::getPropertyVector ( std::string_view name ) const

Returns a property vector with given name or aborts calling OGS_FATAL if no such property vector exists.

Referenced by ProcessLib::LIE::PostProcessTool::PostProcessTool(), ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::SmallDeformationProcess(), ProcessLib::addBulkMeshPropertyToSubMesh(), MeshToolsLib::addLayerToMesh(), MeshLib::bulkElementIDs(), MeshLib::bulkNodeIDs(), castPropertyVectorToPropertyVector(), MeshToolsLib::ElementValueModification::condense(), anonymous_namespace{MeshRevision.cpp}::copyProperties(), copyPropertyVector(), ParameterLib::createGroupBasedParameter(), ParameterLib::createMeshElementParameter(), ParameterLib::createMeshNodeParameter(), ParameterLib::createRandomFieldMeshElementParameter(), extractMatGroup(), getPropertyVector(), getRegularElements(), getSurfaceIntegratedValuesForNodes(), MeshToolsLib::Mesh2MeshPropertyInterpolation::interpolateElementPropertiesToNodeProperties(), MeshToolsLib::MeshGenerator::VoxelGridFromMesh::mapArray(), MeshElementRemovalDialog::on_scalarArrayComboBox_currentIndexChanged(), FileIO::Gocad::GocadAsciiReader::parseElements(), FileIO::Gocad::GocadAsciiReader::parseLineSegments(), ApplicationUtils::NodeWiseMeshPartitioner::partitionOtherMesh(), ApplicationUtils::NodeWiseMeshPartitioner::renumberBulkIdsProperty(), reorderProperty(), MeshToolsLib::ElementValueModification::replace(), MeshGeoToolsLib::resetMeshElementProperty(), MeshLib::scaleMeshPropertyVector(), MeshLib::ElementSearch::searchByPropertyValueRange(), MeshToolsLib::ElementValueModification::setByElementType(), setMaterialIDs(), MeshToolsLib::Mesh2MeshPropertyInterpolation::setPropertiesForMesh(), anonymous_namespace{IdentifySubdomainMesh.cpp}::updateOrCheckExistingSubdomainProperty(), MeshLib::IO::Legacy::MeshIO::write(), FileIO::TetGenInterface::write2dElements(), FileIO::TetGenInterface::write3dElements(), and MeshLib::IO::VtuInterface::writeVTU().

◆ getPropertyVector() [6/10]

template<typename T >

PropertyVector< T > * MeshLib::Properties::getPropertyVector	(	std::string_view	name,
		MeshItemType const	item_type,
		int const	n_components )

Definition at line 207 of file Properties-impl.h.

{
    auto const it = _properties.find(std::string(name));
    if (it == _properties.end())
    {
        OGS_FATAL(
            "A PropertyVector with name '{:s}' does not exist in the mesh.",
            name);
    }
 
    auto property = dynamic_cast<PropertyVector<T>*>(it->second);
    if (property == nullptr)
    {
        OGS_FATAL(
            "Could not cast the data type of the PropertyVector '{:s}' to "
            "requested data type.",
            name);
    }
    if (property->getMeshItemType() != item_type)
    {
        OGS_FATAL(
            "The PropertyVector '{:s}' has type '{:s}'. A '{:s}' field is "
            "requested.",
            name, toString(property->getMeshItemType()), toString(item_type));
    }
    if (property->getNumberOfGlobalComponents() != n_components)
    {
        OGS_FATAL(
            "PropertyVector '{:s}' has {:d} components, {:d} components are "
            "needed.",
            name, property->getNumberOfGlobalComponents(), n_components);
    }
    return property;
}

References OGS_FATAL.

◆ getPropertyVector() [7/10]

template<typename T >

PropertyVector< T > * MeshLib::Properties::getPropertyVector	(	std::string_view	name,
		MeshItemType const	item_type,
		int const	n_components )

Non-const version of getPropertyVector returns a property vector with given name, item_type and number_of_components or calls OGS_FATAL if no such property vector exists.

Definition at line 208 of file Properties.h.

               :
            OGS_FATAL(
                "Unknown mesh item type. At the moment only for mesh item "
                "types 'Node', 'Cell', and 'Face' mapping names are "
                "specified.");
            return "";
    }
}
 
#include "Properties-impl.h"
 
} // end namespace MeshLib

◆ getPropertyVector() [8/10]

template<typename T >

PropertyVector< T > const * MeshLib::Properties::getPropertyVector	(	std::string_view	name,
		MeshItemType const	item_type,
		int const	n_components ) const

Definition at line 168 of file Properties-impl.h.

{
    auto const it = _properties.find(std::string(name));
    if (it == _properties.end())
    {
        OGS_FATAL(
            "A PropertyVector with name '{:s}' does not exist in the mesh.",
            name);
    }
 
    auto property = dynamic_cast<PropertyVector<T>*>(it->second);
    if (property == nullptr)
    {
        OGS_FATAL(
            "Could not cast the data type of the PropertyVector '{:s}' (type: "
            "'{:s}') to the requested data type '{:s}'.",
            name, typeid(decltype(*it->second)).name(),
            typeid(PropertyVector<T>).name());
    }
    if (property->getMeshItemType() != item_type)
    {
        OGS_FATAL(
            "The PropertyVector '{:s}' has type '{:s}'. A '{:s}' field is "
            "requested.",
            name, toString(property->getMeshItemType()), toString(item_type));
    }
    if (property->getNumberOfGlobalComponents() != n_components)
    {
        OGS_FATAL(
            "PropertyVector '{:s}' has {:d} components, {:d} components are "
            "needed.",
            name, property->getNumberOfGlobalComponents(), n_components);
    }
    return property;
}

References OGS_FATAL.

◆ getPropertyVector() [9/10]

template<typename T >

PropertyVector< T > const * MeshLib::Properties::getPropertyVector	(	std::string_view	name,
		MeshItemType const	item_type,
		int const	n_components ) const

Definition at line 169 of file Properties.h.

       :
    std::map<std::string, PropertyVectorBase*> _properties;
}; // end class
 
template <typename Function>
void applyToPropertyVectors(Properties const& properties, Function f);
 
constexpr std::string_view getBulkIDString(MeshItemType mesh_item_type)
{
    switch (mesh_item_type)
    {
        case MeshItemType::Node:
            return "bulk_node_ids";
            break;
        case MeshItemType::Cell:
            return "bulk_element_ids";
            break;
        case MeshItemType::Edge:
            return "bulk_edge_ids";
            break;
        case MeshItemType::Face:
            return "bulk_face_ids";
            break;
        case MeshItemType::IntegrationPoint:
            OGS_FATAL("MeshItemType::IntegrationPoint is not handled.");

◆ getPropertyVector() [10/10]

template<typename T >

PropertyVector< T > const * MeshLib::Properties::getPropertyVector	(	std::string_view	name,
		MeshItemType const	item_type,
		int const	n_components ) const

Returns a property vector with given name, item_type and number_of_components or aborts calling OGS_FATAL if no such property vector exists.

◆ getPropertyVectorNames() [1/2]

std::vector< std::string > MeshLib::Properties::getPropertyVectorNames ( ) const

Definition at line 34 of file Properties.cpp.

{
    std::vector<std::string> names;
    std::transform(_properties.begin(), _properties.end(),
                   std::back_inserter(names),
                   [](auto const& pair) { return std::string(pair.first); });
    return names;
}

References _properties.

Referenced by anonymous_namespace{MeshRevision.cpp}::copyProperties(), main(), and ProcessLib::Output::prepareSubmesh().

◆ getPropertyVectorNames() [2/2]

std::vector< std::string > MeshLib::Properties::getPropertyVectorNames ( MeshLib::MeshItemType t ) const

Definition at line 43 of file Properties.cpp.

{
    std::vector<std::string> names;
    for (auto p : _properties)
    {
        if (p.second->getMeshItemType() == t)
        {
            names.push_back(std::string(p.first));
        }
    }
    return names;
}

References _properties.

◆ hasPropertyVector() [1/3]

template<typename T >

bool MeshLib::Properties::hasPropertyVector	(	std::string const &	name,
		MeshItemType const	item_type ) const

Definition at line 151 of file Properties-impl.h.

{
    auto const it = _properties.find(name);
 
    if (it == _properties.end())
    {
        return false;
    }
 
    auto property = dynamic_cast<PropertyVector<T>*>(it->second);
 
    return (property == nullptr) ? false
                                 : property->getMeshItemType() == item_type;
}

References MeshLib::PropertyVectorBase::getMeshItemType().

◆ hasPropertyVector() [2/3]

template<typename T >

bool MeshLib::Properties::hasPropertyVector	(	std::string const &	name,
		MeshItemType const	item_type ) const

Check if a PropertyVector accessible by the name and by the item type is already stored within the Properties object.

Parameters

name	the name of the property, e.g. porosity.
item_type	the type of mesh entity, e.g. CELL.

Definition at line 152 of file Properties.h.

◆ hasPropertyVector() [3/3]

bool MeshLib::Properties::hasPropertyVector ( std::string_view name ) const

Check if a PropertyVector accessible by the name is already stored within the Properties object.

Parameters

name	the name of the property (for instance porosity)

Definition at line 29 of file Properties.cpp.

{
    return _properties.find(std::string(name)) != _properties.end();
}

References _properties.

Referenced by ProcessLib::LIE::PostProcessTool::PostProcessTool(), ProcessLib::checkParametersOfDirichletBoundaryCondition(), and ApplicationUtils::NodeWiseMeshPartitioner::renumberBulkIdsProperty().

◆ operator=() [1/2]

Properties & MeshLib::Properties::operator= ( Properties && properties )

default

◆ operator=() [2/2]

Properties & MeshLib::Properties::operator= ( Properties const & properties )

Definition at line 113 of file Properties.cpp.

{
    if (&properties == this)
    {
        return *this;
    }
 
    _properties = properties._properties;
    std::vector<std::size_t> exclude_positions;
    for (auto& name_vector_pair : _properties)
    {
        PropertyVectorBase* t(
            name_vector_pair.second->clone(exclude_positions));
        name_vector_pair.second = t;
    }
 
    return *this;
}

References _properties.

◆ removePropertyVector()

void MeshLib::Properties::removePropertyVector ( std::string_view name )

Definition at line 17 of file Properties.cpp.

{
    auto it(_properties.find(std::string(name)));
    if (it == _properties.end())
    {
        WARN("A property of the name '{:s}' does not exist.", name);
        return;
    }
    delete it->second;
    _properties.erase(it);
}

References _properties, and WARN().

◆ size() [1/2]

std::map< std::string, PropertyVectorBase * >::size_type MeshLib::Properties::size ( ) const

Definition at line 162 of file Properties.cpp.

{
    return _properties.size();
}

References _properties.

Referenced by ApplicationUtils::writeProperties().

◆ size() [2/2]

std::map< std::string, PropertyVectorBase * >::size_type MeshLib::Properties::size ( MeshItemType const mesh_item_type ) const

Definition at line 167 of file Properties.cpp.

{
    return count_if(begin(), end(),
                    [&](auto const p)
                    { return p.second->getMeshItemType() == mesh_item_type; });
}

References begin(), and end().

Member Data Documentation

◆ _properties

std::map<std::string, PropertyVectorBase*> MeshLib::Properties::_properties

private

A mapping from property's name to the stored object of any type. See addProperty() and getProperty() documentation.

Definition at line 173 of file Properties.h.

Referenced by Properties(), ~Properties(), begin(), begin(), end(), end(), excludeCopyProperties(), excludeCopyProperties(), getPropertyVectorNames(), getPropertyVectorNames(), hasPropertyVector(), operator=(), removePropertyVector(), and size().

The documentation for this class was generated from the following files:

Detailed Description

Public Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ Properties() [1/3]

◆ Properties() [2/3]

◆ Properties() [3/3]

◆ ~Properties()

Member Function Documentation

◆ begin() [1/2]

◆ begin() [2/2]

◆ createNewPropertyVector() [1/4]

◆ createNewPropertyVector() [2/4]

◆ createNewPropertyVector() [3/4]

◆ createNewPropertyVector() [4/4]

◆ end() [1/2]

◆ end() [2/2]

◆ excludeCopyProperties() [1/2]

◆ excludeCopyProperties() [2/2]

◆ existsPropertyVector() [1/4]

◆ existsPropertyVector() [2/4]

◆ existsPropertyVector() [3/4]

◆ existsPropertyVector() [4/4]

◆ getPropertyVector() [1/10]

◆ getPropertyVector() [2/10]

◆ getPropertyVector() [3/10]

◆ getPropertyVector() [4/10]

◆ getPropertyVector() [5/10]

◆ getPropertyVector() [6/10]

◆ getPropertyVector() [7/10]

◆ getPropertyVector() [8/10]

◆ getPropertyVector() [9/10]

◆ getPropertyVector() [10/10]

◆ getPropertyVectorNames() [1/2]

◆ getPropertyVectorNames() [2/2]

◆ hasPropertyVector() [1/3]

◆ hasPropertyVector() [2/3]

◆ hasPropertyVector() [3/3]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ removePropertyVector()

◆ size() [1/2]

◆ size() [2/2]

Member Data Documentation

◆ _properties