#include <normal_calculation_utils.h>

Collaboration diagram for Kratos::NormalCalculationUtils:

Public Types
Type Definitions
typedef std::size_t	IndexType
	The index type definition. More...

typedef std::size_t	SizeType
	The size type definition. More...

typedef Node	NodeType

typedef Geometry< NodeType >	GeometryType
	Definition of geometries. More...

typedef ModelPart::ConditionType	ConditionType
	Condition type definition. More...

typedef ModelPart::ConditionsContainerType	ConditionsArrayType
	Conditions array definition. More...

using	NormalVariableType = Variable< array_1d< double, 3 > >
	Normal variable definition. More...

Public Member Functions
template<class TContainerType >
void	CalculateNormalsInContainer (ModelPart &rModelPart, const Variable< array_1d< double, 3 >> &rNormalVariable)

template<class TContainerType , bool TIsHistorical>
void	InitializeNormals (ModelPart &rModelPart, const Variable< array_1d< double, 3 >> &rNormalVariable)

template<class TContainerType , bool TIsHistorical>
void	CalculateUnitNormals (ModelPart &rModelPart, const bool EnforceGenericGeometryAlgorithm, const Variable< array_1d< double, 3 >> &rNormalVariable)

template<class TContainerType , bool TIsHistorical>
void	ComputeUnitNormalsFromAreaNormals (ModelPart &rModelPart, const Variable< array_1d< double, 3 >> &rNormalVariable)

template<>
ModelPart::ConditionsContainerType &	GetContainer (ModelPart &rModelPart)

Operations
template<class TContainerType >
void	CalculateNormalsInContainer (ModelPart &rModelPart, const NormalVariableType &rNormalVariable=NORMAL)
	It computes the normal in the conditions. More...

template<class TContainerType , bool TIsHistorical = true>
void	CalculateNormals (ModelPart &rModelPart, const bool EnforceGenericGeometryAlgorithm=false, const bool ConsiderUnitNormal=false, const NormalVariableType &rNormalVariable=NORMAL)
	It computes the mean of the normal in the entities and in all the nodes. More...

template<class TContainerType , bool TIsHistorical = true>
void	CalculateUnitNormals (ModelPart &rModelPart, const bool EnforceGenericGeometryAlgorithm=false, const NormalVariableType &rNormalVariable=NORMAL)
	It computes the mean of the normal in the entities and in all the nodes (unit normal version) More...

void	CalculateOnSimplex (ConditionsArrayType &rConditions, const std::size_t Dimension, const NormalVariableType &rNormalVariable=NORMAL)
	Calculates the "area normal" (vector oriented as the normal with a dimension proportional to the area). More...

void	CalculateOnSimplexNonHistorical (ConditionsArrayType &rConditions, const std::size_t Dimension, const NormalVariableType &rNormalVariable=NORMAL)
	Calculates the "area normal" in the non-historical database (vector oriented as the normal with a dimension proportional to the area). More...

void	CalculateNormalShapeDerivativesOnSimplex (ConditionsArrayType &rConditions, const std::size_t Dimension)
	Calculates nodal area normal shape sensitivities w.r.t. nodal coordinates of the condition. More...

void	CalculateOnSimplex (ModelPart &rModelPart, const std::size_t Dimension, const NormalVariableType &rNormalVariable=NORMAL)
	Calculates the area normal (vector oriented as the normal with a dimension proportional to the area). More...

void	CalculateOnSimplexNonHistorical (ModelPart &rModelPart, const std::size_t Dimension, const NormalVariableType &rNormalVariable=NORMAL)
	Calculates the area normal in the non-historical database (vector oriented as the normal with a dimension proportional to the area). More...

void	CalculateOnSimplex (ModelPart &rModelPart, const NormalVariableType &rNormalVariable=NORMAL)
	Calculates the area normal (vector oriented as the normal with a dimension proportional to the area). More...

void	CalculateOnSimplexNonHistorical (ModelPart &rModelPart, const NormalVariableType &rNormalVariable=NORMAL)
	Calculates the area normal in the non-historical database (vector oriented as the normal with a dimension proportional to the area). More...

void	SwapNormals (ModelPart &rModelPart)
	This function swaps the normal of all of the conditions in a model part. More...

template<class TValueType >
void	CalculateOnSimplex (ModelPart &rModelPart, const std::size_t Dimension, const Variable< TValueType > &rVariable, const TValueType Zero, const NormalVariableType &rNormalVariable=NORMAL)
	Calculates the area normal (vector oriented as the normal with a dimension proportional to the area) using only nodes marked with a flag variable. More...

template<class TValueType >
void	CalculateOnSimplex (ModelPart &rModelPart, const std::size_t Dimension, const Variable< TValueType > &rVariable)
	Calculates the area normal (vector oriented as the normal with a dimension proportional to the area) using only nodes marked with a flag variable. More...

template<class TValueType >
void	CalculateOnSimplex (ModelPart &rModelPart, const std::size_t Dimension, const Variable< TValueType > &rVariable, const TValueType Zero, const double rAlpha, const NormalVariableType &rNormalVariable=NORMAL)
	Calculates the area normal (vector oriented as the normal with a dimension proportional to the area) using only nodes marked with a flag variable and detecting corners. Corners are defined as nodes that recieves more than 2 normals from their neighbor conditions with a difference in angle greater than Alpha . More...

template<class TValueType >
void	CalculateOnSimplexLowMemory (ModelPart &rModelPart, int Dimension, const Variable< TValueType > &rVariable, const TValueType Zero, const double rAlpha, const NormalVariableType &rNormalVariable=NORMAL)
	Calculates the area normal (vector oriented as the normal with a dimension proportional to the area) using only nodes marked with a flag variable and detecting corners. Corners are defined as nodes that recieves more than 2 normals from their neighbor conditions with a difference in angle greater than Alpha . (Low memory version) More...

Member Typedef Documentation

◆ ConditionsArrayType

typedef ModelPart::ConditionsContainerType Kratos::NormalCalculationUtils::ConditionsArrayType

Conditions array definition.

◆ ConditionType

typedef ModelPart::ConditionType Kratos::NormalCalculationUtils::ConditionType

Condition type definition.

◆ GeometryType

typedef Geometry<NodeType> Kratos::NormalCalculationUtils::GeometryType

Definition of geometries.

◆ IndexType

typedef std::size_t Kratos::NormalCalculationUtils::IndexType

The index type definition.

◆ NodeType

typedef Node Kratos::NormalCalculationUtils::NodeType

◆ NormalVariableType

using Kratos::NormalCalculationUtils::NormalVariableType = Variable<array_1d<double,3> >

Normal variable definition.

◆ SizeType

typedef std::size_t Kratos::NormalCalculationUtils::SizeType

The size type definition.

Member Function Documentation

◆ CalculateNormals()

template<class TContainerType , bool TIsHistorical = true>

void Kratos::NormalCalculationUtils::CalculateNormals	(	ModelPart &	rModelPart,
		const bool	EnforceGenericGeometryAlgorithm = `false`,
		const bool	ConsiderUnitNormal = `false`,
		const NormalVariableType &	rNormalVariable = `NORMAL`
	)

It computes the mean of the normal in the entities and in all the nodes.

Parameters

rModelPart	The model part to compute
EnforceGenericGeometryAlgorithm	If enforce the generic algorithm for any kind of geometry
ConsiderUnitNormal	In order to consider directly the unit normal instead of the area normal multiplied with a coefficient
rNormalVariable	Component variable storing the normal value

Template Parameters

TEntity	The entity type considered
TIsHistorical	Specifies if the historical or non-historical nodal database is used

◆ CalculateNormalShapeDerivativesOnSimplex()

void Kratos::NormalCalculationUtils::CalculateNormalShapeDerivativesOnSimplex	(	ConditionsArrayType &	rConditions,
		const std::size_t	Dimension
	)

Calculates nodal area normal shape sensitivities w.r.t. nodal coordinates of the condition.

Parameters

rConditions	List of conditions where shape sensitivities need to be calculated.
Dimension	Dimensionality of the conditions

◆ CalculateNormalsInContainer() [1/2]

template<class TContainerType >

void Kratos::NormalCalculationUtils::CalculateNormalsInContainer	(	ModelPart &	rModelPart,
		const NormalVariableType &	rNormalVariable = `NORMAL`
	)

It computes the normal in the conditions.

Parameters

rModelPart	The model part to compute
rNormalVariable	Component variable storing the normal value

◆ CalculateNormalsInContainer() [2/2]

template<class TContainerType >

void Kratos::NormalCalculationUtils::CalculateNormalsInContainer	(	ModelPart &	rModelPart,
		const Variable< array_1d< double, 3 >> &	rNormalVariable
	)

◆ CalculateOnSimplex() [1/6]

void Kratos::NormalCalculationUtils::CalculateOnSimplex	(	ConditionsArrayType &	rConditions,
		const std::size_t	Dimension,
		const NormalVariableType &	rNormalVariable = `NORMAL`
	)

Calculates the "area normal" (vector oriented as the normal with a dimension proportional to the area).

This is done on the base of the Conditions provided which should be understood as the surface elements of the area of interest.

Parameters

rConditions	A set of conditions defining the "skin" of a model
Dimension	Spatial dimension (2 or 3)
rNormalVariable	Component variable storing the normal value

Note: This function is not recommended for distributed (MPI) runs, as the user has to ensure that the calculated normals are assembled between processes. The overload of this function that takes a ModelPart is preferable in ths case, as it performs the required communication.

◆ CalculateOnSimplex() [2/6]

void Kratos::NormalCalculationUtils::CalculateOnSimplex	(	ModelPart &	rModelPart,
		const NormalVariableType &	rNormalVariable = `NORMAL`
	)

Calculates the area normal (vector oriented as the normal with a dimension proportional to the area).

This is done on the base of the Conditions provided which should be understood as the surface elements of the area of interest.

Parameters

rModelPart	ModelPart of the problem. Must have a set of conditions defining the "skin" of the domain
rNormalVariable	Component variable storing the normal value

Note: Use this fuction instead of its overload taking a Conditions array for MPI applications, as it will take care of communication between partitions.

◆ CalculateOnSimplex() [3/6]

void Kratos::NormalCalculationUtils::CalculateOnSimplex	(	ModelPart &	rModelPart,
		const std::size_t	Dimension,
		const NormalVariableType &	rNormalVariable = `NORMAL`
	)

Calculates the area normal (vector oriented as the normal with a dimension proportional to the area).

This is done on the base of the Conditions provided which should be understood as the surface elements of the area of interest.

Parameters

rModelPart	ModelPart of the problem. Must have a set of conditions defining the "skin" of the domain
Dimension	Spatial dimension (2 or 3)
rNormalVariable	Component variable storing the normal value

Note: Use this fuction instead of its overload taking a Conditions array for MPI applications, as it will take care of communication between partitions.

◆ CalculateOnSimplex() [4/6]

template<class TValueType >

void Kratos::NormalCalculationUtils::CalculateOnSimplex	(	ModelPart &	rModelPart,
		const std::size_t	Dimension,
		const Variable< TValueType > &	rVariable
	)

inline

Calculates the area normal (vector oriented as the normal with a dimension proportional to the area) using only nodes marked with a flag variable.

This function is equivalent to other implementations of CalculateOnSimplex, but instead of using all conditions in the array, it only uses those that contain a value of rVariable != Zero. This is useful in problems where a part of the boundary is a slip condition, as it provides more reasonable values for the normals on the border between this area and other parts of the boundary. This function is safe to use in MPI.

Parameters

rModelPart	ModelPart of the problem. Must have a set of conditions defining the "skin" of the domain.
Dimension	Spatial dimension (2 or 3).
rVariable	The Kratos::Variable used to indicate which parts of the boundary will be used to calculate the normals. Conditions where rVariable == Zero will be skipped.

◆ CalculateOnSimplex() [5/6]

template<class TValueType >

void Kratos::NormalCalculationUtils::CalculateOnSimplex	(	ModelPart &	rModelPart,
		const std::size_t	Dimension,
		const Variable< TValueType > &	rVariable,
		const TValueType	Zero,
		const double	rAlpha,
		const NormalVariableType &	rNormalVariable = `NORMAL`
	)

inline

Calculates the area normal (vector oriented as the normal with a dimension proportional to the area) using only nodes marked with a flag variable and detecting corners. Corners are defined as nodes that recieves more than 2 normals from their neighbor conditions with a difference in angle greater than Alpha .

This function is equivalent to other implementations of CalculateOnSimplex, but instead of using all conditions in the array, it only uses those that contain a value of rVariable != Zero. This is useful in problems where a part of the boundary is a slip condition, as it provides more reasonable values for the normals on the border between this area and other parts of the boundary. This function is safe to use in MPI.

Parameters

rModelPart	ModelPart of the problem. Must have a set of conditions defining the "skin" of the domain.
Dimension	Spatial dimension (2 or 3).
rVariable	The Kratos::Variable used to indicate which parts of the boundary will be used to calculate the normals. Conditions where rVariable == Zero will be skipped.
rAlpha	the maximum angle to distinguish normals.
rNormalVariable	Component variable storing the normal value

◆ CalculateOnSimplex() [6/6]

template<class TValueType >

void Kratos::NormalCalculationUtils::CalculateOnSimplex	(	ModelPart &	rModelPart,
		const std::size_t	Dimension,
		const Variable< TValueType > &	rVariable,
		const TValueType	Zero,
		const NormalVariableType &	rNormalVariable = `NORMAL`
	)

inline

Calculates the area normal (vector oriented as the normal with a dimension proportional to the area) using only nodes marked with a flag variable.

This function is equivalent to other implementations of CalculateOnSimplex, but instead of using all conditions in the array, it only uses those that contain a value of rVariable != Zero. This is useful in problems where a part of the boundary is a slip condition, as it provides more reasonable values for the normals on the border between this area and other parts of the boundary. This function is safe to use in MPI.

Parameters

rModelPart	ModelPart of the problem. Must have a set of conditions defining the "skin" of the domain.
Dimension	Spatial dimension (2 or 3).
rVariable	The Kratos::Variable used to indicate which parts of the boundary will be used to calculate the normals.
Zero	The 'off' value for the flag. Conditions where rVariable == Zero will be skipped for normal calculation.
rNormalVariable	Component variable storing the normal value

◆ CalculateOnSimplexLowMemory()

template<class TValueType >

void Kratos::NormalCalculationUtils::CalculateOnSimplexLowMemory	(	ModelPart &	rModelPart,
		int	Dimension,
		const Variable< TValueType > &	rVariable,
		const TValueType	Zero,
		const double	rAlpha,
		const NormalVariableType &	rNormalVariable = `NORMAL`
	)

inline

Calculates the area normal (vector oriented as the normal with a dimension proportional to the area) using only nodes marked with a flag variable and detecting corners. Corners are defined as nodes that recieves more than 2 normals from their neighbor conditions with a difference in angle greater than Alpha . (Low memory version)

This function is equivalent to other implementations of CalculateOnSimplex, but instead of using all conditions in the array, it only uses those that contain a value of rVariable != Zero. This is useful in problems where a part of the boundary is a slip condition, as it provides more reasonable values for the normals on the border between this area and other parts of the boundary. This function is safe to use in MPI.

Parameters

rModelPart	ModelPart of the problem. Must have a set of conditions defining the "skin" of the domain.
Dimension	Spatial dimension (2 or 3).
rVariable	The Kratos::Variable used to indicate which parts of the boundary will be used to calculate the normals. Conditions where rVariable == Zero will be skipped.
rAlpha	the maximum angle to distinguish normals.
rNormalVariable	Component variable storing the normal value

◆ CalculateOnSimplexNonHistorical() [1/3]

void Kratos::NormalCalculationUtils::CalculateOnSimplexNonHistorical	(	ConditionsArrayType &	rConditions,
		const std::size_t	Dimension,
		const NormalVariableType &	rNormalVariable = `NORMAL`
	)

Calculates the "area normal" in the non-historical database (vector oriented as the normal with a dimension proportional to the area).

This is done on the base of the Conditions provided which should be understood as the surface elements of the area of interest.

Parameters

rConditions	A set of conditions defining the "skin" of a model
Dimension	Spatial dimension (2 or 3)
rNormalVariable	Component variable storing the normal value

Note: This function is not recommended for distributed (MPI) runs, as the user has to ensure that the calculated normals are assembled between processes. The overload of this function that takes a ModelPart is preferable in ths case, as it performs the required communication.

◆ CalculateOnSimplexNonHistorical() [2/3]

void Kratos::NormalCalculationUtils::CalculateOnSimplexNonHistorical	(	ModelPart &	rModelPart,
		const NormalVariableType &	rNormalVariable = `NORMAL`
	)

Calculates the area normal in the non-historical database (vector oriented as the normal with a dimension proportional to the area).

This is done on the base of the Conditions provided which should be understood as the surface elements of the area of interest.

Parameters

rModelPart	ModelPart of the problem. Must have a set of conditions defining the "skin" of the domain
rNormalVariable	Component variable storing the normal value

Note: Use this fuction instead of its overload taking a Conditions array for MPI applications, as it will take care of communication between partitions.

◆ CalculateOnSimplexNonHistorical() [3/3]

void Kratos::NormalCalculationUtils::CalculateOnSimplexNonHistorical	(	ModelPart &	rModelPart,
		const std::size_t	Dimension,
		const NormalVariableType &	rNormalVariable = `NORMAL`
	)

Calculates the area normal in the non-historical database (vector oriented as the normal with a dimension proportional to the area).

This is done on the base of the Conditions provided which should be understood as the surface elements of the area of interest.

Parameters

rModelPart	ModelPart of the problem. Must have a set of conditions defining the "skin" of the domain
Dimension	Spatial dimension (2 or 3)
rNormalVariable	Component variable storing the normal value

Note: Use this fuction instead of its overload taking a Conditions array for MPI applications, as it will take care of communication between partitions.

◆ CalculateUnitNormals() [1/2]

template<class TContainerType , bool TIsHistorical>

void Kratos::NormalCalculationUtils::CalculateUnitNormals	(	ModelPart &	rModelPart,
		const bool	EnforceGenericGeometryAlgorithm,
		const Variable< array_1d< double, 3 >> &	rNormalVariable
	)

◆ CalculateUnitNormals() [2/2]

template<class TContainerType , bool TIsHistorical = true>

void Kratos::NormalCalculationUtils::CalculateUnitNormals	(	ModelPart &	rModelPart,
		const bool	EnforceGenericGeometryAlgorithm = `false`,
		const NormalVariableType &	rNormalVariable = `NORMAL`
	)

It computes the mean of the normal in the entities and in all the nodes (unit normal version)

Parameters

rModelPart	The model part to compute
EnforceGenericGeometryAlgorithm	If enforce the generic algorithm for any kind of geometry
rNormalVariable	Component variable storing the normal value

Template Parameters

TEntity	The entity type considered
TIsHistorical	Specifies if the historical or non-historical nodal database is used

◆ ComputeUnitNormalsFromAreaNormals()

template<class TContainerType , bool TIsHistorical>

void Kratos::NormalCalculationUtils::ComputeUnitNormalsFromAreaNormals	(	ModelPart &	rModelPart,
		const Variable< array_1d< double, 3 >> &	rNormalVariable
	)

◆ GetContainer()

template<>

ModelPart::ElementsContainerType & Kratos::NormalCalculationUtils::GetContainer ( ModelPart & rModelPart )

◆ InitializeNormals()

template<class TContainerType , bool TIsHistorical>

void Kratos::NormalCalculationUtils::InitializeNormals	(	ModelPart &	rModelPart,
		const Variable< array_1d< double, 3 >> &	rNormalVariable
	)

◆ SwapNormals()

void Kratos::NormalCalculationUtils::SwapNormals ( ModelPart & rModelPart )

This function swaps the normal of all of the conditions in a model part.

This is done by swapping the two first nodes in the geometry and is thus appropriate for simplicial elements

Parameters

rModelPart ModelPart of the problem. Must have a set of conditions defining the "skin" of the domain

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

/home/runner/work/Documentation/Documentation/master/kratos/utilities/normal_calculation_utils.h
/home/runner/work/Documentation/Documentation/master/kratos/utilities/normal_calculation_utils.cpp

Public Types

Public Member Functions

Member Typedef Documentation

◆ ConditionsArrayType

◆ ConditionType

◆ GeometryType

◆ IndexType

◆ NodeType

◆ NormalVariableType

◆ SizeType

Member Function Documentation

◆ CalculateNormals()

◆ CalculateNormalShapeDerivativesOnSimplex()

◆ CalculateNormalsInContainer() [1/2]

◆ CalculateNormalsInContainer() [2/2]

◆ CalculateOnSimplex() [1/6]

◆ CalculateOnSimplex() [2/6]

◆ CalculateOnSimplex() [3/6]

◆ CalculateOnSimplex() [4/6]

◆ CalculateOnSimplex() [5/6]

◆ CalculateOnSimplex() [6/6]

◆ CalculateOnSimplexLowMemory()

◆ CalculateOnSimplexNonHistorical() [1/3]

◆ CalculateOnSimplexNonHistorical() [2/3]

◆ CalculateOnSimplexNonHistorical() [3/3]

◆ CalculateUnitNormals() [1/2]

◆ CalculateUnitNormals() [2/2]

◆ ComputeUnitNormalsFromAreaNormals()

◆ GetContainer()

◆ InitializeNormals()

◆ SwapNormals()