#include <geometryelement.h>

Public Member Functions
void	boundingBox ()

void	writeElement () const

void	calcNormal (const MFloat const vertices, MFloat normal) const
	Calculates the normal vector from the geometry element vertices. More...

void	calcCentroid (const MFloat const vertices, MFloat centroid) const
	Calculate the centroid of the geometry element vertices. More...

void	getVertices (MFloat *vertices) const
	Return the vertices of the geometry element. More...

void	allocateElements (void , void , MInt &)

Static Public Member Functions
static void	init (MInt NotUsed(dimensions), MInt, MInt)

static MInt	staticElementSize ()

Public Attributes
MInt	m_segmentId

MInt	m_bndCndId

MInt	m_originalId

MFloat **	m_vertices

MFloat *	m_normal

MFloat *	m_minMax

Detailed Description

template<MInt nDim>
class GeometryElement< nDim >

Representation of the geometrical concept of an element

Collector class! In 2D an element consists of two vertices and is part of a segment. In 3D an element consists of at least 3 vertices and is part of a segment.

Definition at line 20 of file geometryelement.h.

Member Function Documentation

◆ allocateElements()

template<MInt nDim>

void GeometryElement< nDim >::allocateElements	(	void *	tmpPointer,
		void *	,
		MInt &
	)

Definition at line 24 of file geometryelement.cpp.

                                                                               {
  //  TRACE();
 
  m_vertices = (MFloat**)tmpPointer;
  // Jump memory for pointers to pointers
  for(MInt i = 0; i < nDim; i++) {
    tmpPointer = (void*)((MFloat**)tmpPointer + 1);
  }
 
  for(MInt i = 0; i < nDim; i++) {
    // Set pointers to pointers
    m_vertices[i] = (MFloat*)tmpPointer;
    // Jump memory for values
    tmpPointer = (void*)((MFloat*)tmpPointer + nDim);
  }
  m_normal = (MFloat*)tmpPointer;
  tmpPointer = (void*)((MFloat*)tmpPointer + nDim);
  m_minMax = (MFloat*)tmpPointer;
}

◆ boundingBox()

template<MInt nDim>

void GeometryElement< nDim >::boundingBox

Definition at line 45 of file geometryelement.cpp.

                                        {
  //  TRACE();
 
  for(MInt j = 0; j < nDim; j++) {
    m_minMax[j] = m_vertices[0][j];
    m_minMax[j + nDim] = m_vertices[0][j];
  }
  for(MInt i = 0; i < nDim; i++) {
    for(MInt j = 0; j < nDim; j++) {
      // Find maximum
      m_minMax[j + nDim] = (m_minMax[j + nDim] < m_vertices[i][j]) ? m_vertices[i][j] : m_minMax[j + nDim];
      // Find minimum
      m_minMax[j] = (m_minMax[j] > m_vertices[i][j]) ? m_vertices[i][j] : m_minMax[j];
    }
  }
}

◆ calcCentroid()

template<MInt nDim>

void GeometryElement< nDim >::calcCentroid	(	const MFloat *const	vertices,
		MFloat *	centroid
	)		const

Author: Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Rodrigo Miguez

Date: 2014-03-19, 2019-10-31

Parameters

[in]	vertices	Geometry element vertices
[out]	centroid	After a call to calcCentroid(), `centroid` holds the centroid of the element. Must point to storage of at least size nDim.

Definition at line 159 of file geometryelement.cpp.

                                                                                             {
  TRACE();
 
  // Calculate sums over vertices and divide by dimensions (works for 2D and 3D)
  // Example 2D:
  // vertices: (x0, y0), (x1, y1)
  // centroid: ((x0 + x1)/2, (y0 + y1)/2)
  for(MInt dim = 0; dim < nDim; dim++) {
    centroid[dim] = 0.0;
    for(MInt vertexId = 0; vertexId < nDim; vertexId++) {
      centroid[dim] += vertices[(vertexId * nDim) + dim];
    }
    centroid[dim] /= static_cast<MFloat>(nDim);
  }
}

◆ calcNormal()

template<MInt nDim>

void GeometryElement< nDim >::calcNormal	(	const MFloat *const	vertices,
		MFloat *	normal
	)		const

Author: Michael Schlottke (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de, Rodrigo Miguez

Date: 2014-03-18, 2019-10-31

Parameters

[in]	vertices	Geometry element vertices
[out]	normal	After a call to calcNormal(), `normal` holds the normalized normal vector. Must point to storage of at least size nDim.

Definition at line 103 of file geometryelement.cpp.

                                                                                         {
  TRACE();
 
  using Vec2D = array<MFloat, 2>;
  using Vec3D = array<MFloat, 3>;
 
  // Since the used algorithms depend on the dimension, we need to branch here
  IF_CONSTEXPR(nDim == 2) {
    Vec2D edge, norm;
 
    // Calculate edge vector
    edge[0] = vertices[2] - vertices[0];
    edge[1] = vertices[3] - vertices[1];
 
    // Calculate vector normal to edge
    norm[0] = edge[1];
    norm[1] = -edge[0];
 
    // Normalize normal vector and copy to result
    maia::math::normalize(norm);
    copy(norm.begin(), norm.end(), normal);
  }
  else IF_CONSTEXPR(nDim == 3) {
    Vec3D edge0, edge1, norm;
 
    // Calculate edge vectors
    edge0[0] = vertices[3] - vertices[0];
    edge0[1] = vertices[4] - vertices[1];
    edge0[2] = vertices[5] - vertices[2];
    edge1[0] = vertices[6] - vertices[0];
    edge1[1] = vertices[7] - vertices[1];
    edge1[2] = vertices[8] - vertices[2];
 
    // Calculate vector normal to plane
    norm = maia::math::cross(edge0, edge1);
 
    // Normalize normal vector and copy to result
    maia::math::normalize(norm);
    copy(norm.begin(), norm.end(), normal);
  }
  else {
    TERMM(1, "Bad number of dimensions.");
  }
}

◆ getVertices()

template<MInt nDim>

void GeometryElement< nDim >::getVertices ( MFloat * vertices ) const

Author: Rodrigo Barros Miguez (rodrigo) rodri.nosp@m.go.m.nosp@m.iguez.nosp@m.@rwt.nosp@m.h-aac.nosp@m.hen..nosp@m.de

Date: June 2019

Parameters

[out] vertices After a call to getVertices(), 'vertices' holds the vertices of the geometry element.

Definition at line 184 of file geometryelement.cpp.

                                                              {
  TRACE();
 
  IF_CONSTEXPR(nDim == 2) {
    // Copy vertices information to vectors
    vertices[0] = m_vertices[0][0];
    vertices[1] = m_vertices[0][1];
    vertices[2] = m_vertices[1][0];
    vertices[3] = m_vertices[1][1];
  }
  else IF_CONSTEXPR(nDim == 3) {
    // Copy vertices information to vectors
    vertices[0] = m_vertices[0][0];
    vertices[1] = m_vertices[0][1];
    vertices[2] = m_vertices[0][2];
    vertices[3] = m_vertices[1][0];
    vertices[4] = m_vertices[1][1];
    vertices[5] = m_vertices[1][2];
    vertices[6] = m_vertices[2][0];
    vertices[7] = m_vertices[2][1];
    vertices[8] = m_vertices[2][2];
  }
}

◆ init()

template<MInt nDim>

static void GeometryElement< nDim >::init	(	MInt	NotUseddimensions,
		MInt	,
		MInt
	)

inlinestatic

Definition at line 38 of file geometryelement.h.

                                                            {
      //    TRACE();
  };

◆ staticElementSize()

template<MInt nDim>

static MInt GeometryElement< nDim >::staticElementSize ( )

inlinestatic

Definition at line 42 of file geometryelement.h.

42{ return (nDim + 3) * nDim * sizeof(MFloat) + sizeof(MFloat*) * nDim; }

◆ writeElement()

template<MInt nDim>

void GeometryElement< nDim >::writeElement

Definition at line 63 of file geometryelement.cpp.

                                               {
  TRACE();
 
  cerr.precision(10);
  cerr << "------------------------------" << endl;
  // M_Normal vector only in 3D (for now)
  IF_CONSTEXPR(nDim == 3) { cerr << "M_Normal : " << m_normal[0] << " " << m_normal[1] << " " << m_normal[2] << endl; }
 
  for(MInt i = 0; i < nDim; i++) {
    cerr << "Vertex " << i << ": ";
    for(MInt j = 0; j < nDim; j++) {
      cerr << m_vertices[i][j] << " ";
    }
    cerr << endl;
  }
  cerr << "Bounding box: " << endl << "m_min: ";
 
  for(MInt i = 0; i < nDim; i++) {
    cerr << m_minMax[i] << " ";
  }
  cerr << endl;
  cerr << "Bounding box: " << endl << "m_max: ";
 
  for(MInt i = 0; i < nDim; i++) {
    cerr << m_minMax[i + nDim] << " ";
  }
  cerr << endl;
}

Member Data Documentation

◆ m_bndCndId

template<MInt nDim>

MInt GeometryElement< nDim >::m_bndCndId

Definition at line 23 of file geometryelement.h.

◆ m_minMax

template<MInt nDim>

MFloat* GeometryElement< nDim >::m_minMax

Definition at line 29 of file geometryelement.h.

◆ m_normal

template<MInt nDim>

MFloat* GeometryElement< nDim >::m_normal

Definition at line 26 of file geometryelement.h.

◆ m_originalId

template<MInt nDim>

MInt GeometryElement< nDim >::m_originalId

Definition at line 24 of file geometryelement.h.

◆ m_segmentId

template<MInt nDim>

MInt GeometryElement< nDim >::m_segmentId

Definition at line 22 of file geometryelement.h.

◆ m_vertices

template<MInt nDim>

MFloat** GeometryElement< nDim >::m_vertices

Definition at line 25 of file geometryelement.h.

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

/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/GEOM/geometry.h
/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/GEOM/geometryelement.h
/home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/GEOM/geometryelement.cpp

Public Member Functions

Static Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

◆ allocateElements()

◆ boundingBox()

◆ calcCentroid()

◆ calcNormal()

◆ getVertices()

◆ init()

◆ staticElementSize()

◆ writeElement()

Member Data Documentation

◆ m_bndCndId

◆ m_minMax

◆ m_normal

◆ m_originalId

◆ m_segmentId

◆ m_vertices