MeshLib::Properties Class Reference

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 32 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_view name, MeshItemType mesh_item_type, std::size_t n_property_values, 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=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_view name, MeshItemType mesh_item_type, std::size_t n_property_values, 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/6]

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 53 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/6]

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 54 of file Properties.h.

createNewPropertyVector() [3/6]

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/6]

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.

{
 
class Properties

Referenced by CreateStructuredGridDialog::accept(), MeshLib::addPropertyToMesh(), ApplicationUtils::addVtkGhostTypeProperty(), castPropertyVectorToPropertyVector(), MeshToolsLib::RasterToMesh::convert(), MeshLib::VtkMeshConverter::convertTypedArray(), copyDoubleValuedFieldDataToPointCloud(), anonymous_namespace{MeshRevision.cpp}::copyProperties(), ApplicationUtils::copyPropertyVector(), MeshLib::IO::NodePartitionedMeshReader::createPropertyVectorPart(), MeshLib::IO::NodePartitionedMeshReader::createSpecificPropertyVectorPart(), 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().

createNewPropertyVector() [5/6]

template<typename T >

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

Definition at line 34 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>(n_property_values, std::string(name),
                              mesh_item_type, n_components))));
    return static_cast<PropertyVector<T>*>((entry_info.first)->second);
}

References ERR().

createNewPropertyVector() [6/6]

template<typename T >

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

Definition at line 35 of file Properties.h.

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 92 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 93 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(), 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 105 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 106 of file Properties.h.

getPropertyVector() [1/10]

template<typename T >

PropertyVector< T > * MeshLib::Properties::getPropertyVector

(

std::string_view

name

)

Definition at line 150 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 151 of file Properties.h.

getPropertyVector() [3/10]

template<typename T >

PropertyVector< T > const * MeshLib::Properties::getPropertyVector

(

std::string_view

name

)

const

Definition at line 142 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 143 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::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::HydroMechanicsProcess(), 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 226 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 227 of file Properties.h.

{
 
class Properties
{
public:
    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_view name,
                                               MeshItemType mesh_item_type,
                                               std::size_t n_property_values,
                                               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 = 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;
    // Counts properties of given mesh item type.
    std::map<std::string, PropertyVectorBase*>::size_type size(
        MeshItemType const mesh_item_type) const;
 
private:
    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.");
            return "";
            break;
        default:
            OGS_FATAL(
                "Unknown mesh item type {:s}. At the moment mapping names only "
                "for mesh item types 'Node', 'Cell', 'Edge', and 'Face' are "
                "specified.",
                MeshLib::toString(mesh_item_type));
            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 187 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 188 of file Properties.h.

{
    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.");
            return "";
            break;
        default:
            OGS_FATAL(
                "Unknown mesh item type {:s}. At the moment mapping names only "
                "for mesh item types 'Node', 'Cell', 'Edge', and 'Face' are "
                "specified.",
                MeshLib::toString(mesh_item_type));
            return "";
    }
}
 
#include "Properties-impl.h"
 
} // end namespace MeshLib

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 170 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 171 of file Properties.h.

       :
    std::map<std::string, PropertyVectorBase*> _properties;
}; // end class
 
template <typename Function>
void applyToPropertyVectors(Properties const& properties, Function f);

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 176 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:

• MeshLib/Properties.h
• MeshLib/Properties-impl.h
• MeshLib/Properties.cpp