GeometryRoot Class Reference

#include <geometryroot.h>

Inheritance diagram for GeometryRoot:

Collaboration diagram for GeometryRoot:

Public Member Functions
	GeometryRoot ()
	GeometryRoot (const MInt noSolvers, const MInt nDim_, const MPI_Comm comm)
template<MInt nDim>
void	initGeometry (const MInt noSolvers)
MBool	isPointInside (const MFloat *const point)
MBool	isPointInsideNode (const MFloat *const point, const MInt node)
MBool	getCellIntersectingSurfaces (const MFloat *const coords, const MFloat cellHalfLength, MBool *const *const cutInfo)
MBool	getCellIntersectingSurfacesOfNode (const MFloat *const coords, const MFloat cellHalfLength, MBool *const cutInfo, const MInt node)
void	boundingBox (MFloat *const bBox)
void	boundingBoxOfNode (MFloat *const bBox, const MInt node)
MInt	noSegmentsOfNode (const MInt node)
MInt	noNodes ()
MInt	nodeSurfaceType (const MInt node)
template<MInt nDim>
void	setGeometryPointerToNode (Geometry< nDim > *&geometryPointer, const MInt node)
Public Member Functions inherited from GeometryBase
	GeometryBase ()
	GeometryBase (const MPI_Comm comm)
virtual MBool	isPointInside (const MFloat *const)
virtual MBool	isPointInsideNode (const MFloat *const, const MInt)
virtual MBool	getCellIntersectingSurfaces (const MFloat *const, const MFloat, MBool *const *const)
virtual MBool	getCellIntersectingSurfacesOfNode (const MFloat *const, const MFloat, MBool *const, const MInt)

Private Attributes
MInt	m_nDim
MInt	m_noSolverSurfaces
MInt *	m_solverSurfaceType = nullptr
SolverSurface **	m_solverSurface

Additional Inherited Members
Public Attributes inherited from GeometryBase
GeometryDistribution	m_distribution
MPI_Comm	m_mpiComm

Detailed Description

Definition at line 125 of file geometryroot.h.

Constructor & Destructor Documentation

GeometryRoot() [1/2]

GeometryRoot::GeometryRoot ( )

inline

Definition at line 127 of file geometryroot.h.

{};

GeometryRoot() [2/2]

GeometryRoot::GeometryRoot	(	const MInt	noSolvers,
		const MInt	nDim_,
		const MPI_Comm	comm
	)

Definition at line 205 of file geometryroot.cpp.

  : GeometryBase(comm), m_nDim(nDim_) {
  if(nDim_ == 2)
    initGeometry<2>(noSolvers);
  else
    initGeometry<3>(noSolvers);
}

Member Function Documentation

boundingBox()

void GeometryRoot::boundingBox

(

MFloat *const

bBox

)

Definition at line 278 of file geometryroot.cpp.

                                                 {
  // init temporary bounding box
  MFloat tmpBB[6];
  // init bounding box
  for(MInt dim = 0; dim < m_nDim; dim++) {
    bBox[dim] = numeric_limits<MFloat>::max();
    bBox[dim + m_nDim] = numeric_limits<MFloat>::lowest();
  }
  // check all surfaces for their extend
  for(MInt i = 0; i < m_noSolverSurfaces; i++) {
    // init temporary bounding box
    for(MInt dim = 0; dim < m_nDim; dim++) {
      tmpBB[dim] = numeric_limits<MFloat>::max();
      tmpBB[dim + m_nDim] = numeric_limits<MFloat>::lowest();
    }
    // get bounding box of surface
    m_solverSurface[i]->boundingBox(tmpBB);
    // get extrem values
    for(MInt dim = 0; dim < m_nDim; dim++) {
      bBox[dim] = mMin(bBox[dim], tmpBB[dim]);
      bBox[dim + m_nDim] = mMax(bBox[dim + m_nDim], tmpBB[dim + m_nDim]);
    }
  }
}

boundingBoxOfNode()

void GeometryRoot::boundingBoxOfNode	(	MFloat *const	bBox,
		const MInt	node
	)

Definition at line 303 of file geometryroot.cpp.

                                                                        {
  // init temporary bounding box
  MFloat tmpBB[6];
  // init bounding box
  for(MInt dim = 0; dim < m_nDim; dim++) {
    bBox[dim] = numeric_limits<MFloat>::max();
    bBox[dim + m_nDim] = numeric_limits<MFloat>::lowest();
  }
  // check all surfaces for their extend
  for(MInt i = 0; i < m_distribution.noSurfacesPerNode[node]; i++) {
    const MInt srfcId = m_distribution.nodeSurfaceIds[node][i];
    // init temporary bounding box
    for(MInt dim = 0; dim < m_nDim; dim++) {
      tmpBB[dim] = numeric_limits<MFloat>::max();
      tmpBB[dim + m_nDim] = numeric_limits<MFloat>::lowest();
    }
    // get bounding box of surface
    m_solverSurface[srfcId]->boundingBox(tmpBB);
    // get extrem values
    for(MInt dim = 0; dim < m_nDim; dim++) {
      bBox[dim] = mMin(bBox[dim], tmpBB[dim]);
      bBox[dim + m_nDim] = mMax(bBox[dim + m_nDim], tmpBB[dim + m_nDim]);
    }
  }
}

getCellIntersectingSurfaces()

MBool GeometryRoot::getCellIntersectingSurfaces ( const MFloat *const  coords, const MFloat  cellHalfLength, MBool *const *const  cutInfo  )

virtual

Reimplemented from GeometryBase.

Definition at line 367 of file geometryroot.cpp.

                                                                             {
  MBool retVal = false;
  for(MInt node = 0; node < m_distribution.noNodes; node++) {
    const MBool newCut = getCellIntersectingSurfacesOfNode(coords, cellHalfLength, cutInfo[node], node);
    retVal = retVal || newCut;
  }
 
  return retVal;
}

getCellIntersectingSurfacesOfNode()

MBool GeometryRoot::getCellIntersectingSurfacesOfNode ( const MFloat *const  coords, const MFloat  cellHalfLength, MBool *const  cutInfo, const MInt  node  )

virtual

Reimplemented from GeometryBase.

Definition at line 378 of file geometryroot.cpp.

                                                                                             {
  MBool retVal = false;
  for(MInt i = 0; i < m_distribution.noSurfacesPerNode[node]; i++) {
    const MInt srfcId = m_distribution.nodeSurfaceIds[node][i];
    const MInt cutOffset = 0; // needs to be set for the m_solverSurface to know where to set intersections
                              // but this depends on the concept: How many elements, i.e., different STL surfaces,
                              // can an adt contain?
    retVal =
        retVal || m_solverSurface[srfcId]->getCellIntersectingElements(coords, cellHalfLength, cutInfo + cutOffset);
  }
 
  return retVal;
}

initGeometry()

template<MInt nDim>

template void GeometryRoot::initGeometry< 3 >

(

const MInt

noSolvers

)

Definition at line 214 of file geometryroot.cpp.

                                                    {
  // how are the surfaces distributed among the nodes
  // right now, every node has one surface
  m_distribution.noNodes = noSolvers;
  mAlloc(m_distribution.noSurfacesPerNode, m_distribution.noNodes, AT_, 1, "noSurfacesPerSolver");
  mAlloc(m_distribution.nodeSurfaceIds, m_distribution.noNodes, m_distribution.noSurfacesPerNode, AT_,
         "noSurfacesPerNode");
  m_noSolverSurfaces = 0;
  for(MInt node = 0; node < m_distribution.noNodes; node++) {
    for(MInt srfc = 0; srfc < m_distribution.noSurfacesPerNode[node]; srfc++) {
      m_distribution.nodeSurfaceIds[node][srfc] = node;
      m_noSolverSurfaces++;
    }
  }
 
  // what kind of geometry/surface to expect
  mAlloc(m_solverSurfaceType, m_noSolverSurfaces, AT_, 0, "solverSurfaceType");
  for(MInt node = 0; node < m_distribution.noNodes; node++) {
    for(MInt srfc = 0; srfc < m_distribution.noSurfacesPerNode[node]; srfc++) {
      const MInt srfcId = m_distribution.nodeSurfaceIds[node][srfc];
      MString surfaceType = "STL";
      surfaceType = Context::getSolverProperty<MString>("solverSurfaceType", node, AT_, &surfaceType, srfc);
      m_solverSurfaceType[srfcId] = string2enum(surfaceType);
    }
  }
 
  // init
  m_solverSurface = new SolverSurface*[m_noSolverSurfaces];
  for(MInt i = 0; i < m_noSolverSurfaces; i++) {
    switch(m_solverSurfaceType[i]) {
      case STL: {
        m_solverSurface[i] = new SolverSTLSurface<nDim>(m_mpiComm, i);
        break;
      }
      case ANALYTIC_BOX: {
        // here we hardcode the box, just a usefull example
        MFloat bbox[2 * nDim];
        for(MInt dir = 0; dir < 2 * nDim; dir++) {
          bbox[dir] = Context::getSolverProperty<MFloat>("analyticSolverBoundingBox", i, AT_, dir);
        }
        m_solverSurface[i] = new SolverAnalyticBoxSurface<nDim>(bbox);
        break;
      }
      case ANALYTIC_SPHERE: {
        // here we hardcode the sphere, just a usefull example
        MFloat center[nDim];
        for(MInt dir = 0; dir < nDim; dir++) {
          center[dir] = Context::getSolverProperty<MFloat>("analyticSolverBoundingSphere", i, AT_, dir);
        }
        const MFloat radius = Context::getSolverProperty<MFloat>("analyticSolverBoundingSphere", i, AT_, nDim);
        m_solverSurface[i] = new SolverAnalyticSphereSurface<nDim>(center, radius);
        break;
      }
      default: {
        mTerm(1, AT_, "unknown surface type");
      }
    }
  }
}

isPointInside()

MBool GeometryRoot::isPointInside ( const MFloat *const  point )

virtual

Reimplemented from GeometryBase.

Definition at line 329 of file geometryroot.cpp.

                                                           {
  for(MInt node = 0; node < m_distribution.noNodes; node++) {
    if(isPointInsideNode(point, node)) {
      return true;
    }
  }
  return false;
}

isPointInsideNode()

MBool GeometryRoot::isPointInsideNode ( const MFloat *const  point, const MInt  node  )

virtual

Reimplemented from GeometryBase.

Definition at line 338 of file geometryroot.cpp.

                                                                                {
  MFloat bbox[2 * MAX_SPACE_DIMENSIONS];
  MFloat line[2 * MAX_SPACE_DIMENSIONS];
  MFloat bbExtend[MAX_SPACE_DIMENSIONS];
 
  boundingBoxOfNode(bbox, node);
 
  for(MInt dim = 0; dim < m_nDim; dim++) {
    line[dim] = point[dim];
    bbExtend[dim] = bbox[dim + m_nDim] - bbox[dim];
  }
 
  MBool retVal = true;
  for(MInt rayDim = 0; rayDim < m_nDim; rayDim++) { // why in all dimensions?
    for(MInt dim = 0; dim < m_nDim; dim++) {
      line[dim + m_nDim] = point[dim];
    }
    line[rayDim + m_nDim] += 2 * bbExtend[rayDim];
    MInt noIntersec = 0;
    for(MInt i = 0; i < m_distribution.noSurfacesPerNode[node]; i++) {
      MInt srfcId = m_distribution.nodeSurfaceIds[node][i];
      noIntersec += m_solverSurface[srfcId]->countLineIntersectingElements(line);
    }
    retVal = retVal && ((noIntersec % 2) == 1);
    if(!retVal) return false;
  }
  return true;
}

nodeSurfaceType()

MInt GeometryRoot::nodeSurfaceType ( const MInt  node )

inline

Definition at line 144 of file geometryroot.h.

{ return m_solverSurfaceType[node]; };

noNodes()

MInt GeometryRoot::noNodes ( )

inline

Definition at line 143 of file geometryroot.h.

{ return m_distribution.noNodes; };

noSegmentsOfNode()

MInt GeometryRoot::noSegmentsOfNode

(

const MInt

node

)

Definition at line 274 of file geometryroot.cpp.

                                                   {
  return m_solverSurface[node]->noSegments(); // temporary since there wil be several surfaces per node
}

setGeometryPointerToNode()

template<MInt nDim>

template void GeometryRoot::setGeometryPointerToNode< 3 >	(	Geometry< nDim > *&	geometryPointer,
		const MInt	node
	)

Definition at line 394 of file geometryroot.cpp.

                                                                                             {
  m_solverSurface[node]->setGeometryPointer(geometryPointer);
}

Member Data Documentation

m_nDim

MInt GeometryRoot::m_nDim

private

Definition at line 151 of file geometryroot.h.

m_noSolverSurfaces

MInt GeometryRoot::m_noSolverSurfaces

private

Definition at line 153 of file geometryroot.h.

m_solverSurface

SolverSurface** GeometryRoot::m_solverSurface

private

Definition at line 155 of file geometryroot.h.

m_solverSurfaceType

MInt* GeometryRoot::m_solverSurfaceType = nullptr

private

Definition at line 154 of file geometryroot.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/geometryroot.h
• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/GEOM/geometryroot.cpp