olb::PLattice< T, PARTICLETYPE > Class Template Reference

#include <pLattice.h>

Inheritance diagram for olb::PLattice< T, PARTICLETYPE >:

Collaboration diagram for olb::PLattice< T, PARTICLETYPE >:

Public Member Functions
	PLattice (ParticleSystem3D< T, PARTICLETYPE > &pSys, T overlap, T spacing)
void	sort ()
int	getMatches (int pInt, std::vector< std::pair< size_t, T > > &matches)
Public Member Functions inherited from olb::ContactDetection< T, PARTICLETYPE >
	ContactDetection (ParticleSystem3D< T, PARTICLETYPE > &pSys)
	ContactDetection (ParticleSystem3D< T, PARTICLETYPE > &pSys, std::string name)
virtual	~ContactDetection ()
std::string	getName ()

Additional Inherited Members
Protected Attributes inherited from olb::ContactDetection< T, PARTICLETYPE >
ParticleSystem3D< T, PARTICLETYPE > &	_pSys
std::string	_name

Detailed Description

template<typename T, template< typename U > class PARTICLETYPE>
class olb::PLattice< T, PARTICLETYPE >

Definition at line 32 of file pLattice.h.

Constructor & Destructor Documentation

PLattice()

template<typename T , template< typename U > class PARTICLETYPE>

olb::PLattice< T, PARTICLETYPE >::PLattice	(	ParticleSystem3D< T, PARTICLETYPE > &	pSys,
		T	overlap,
		T	spacing )

Definition at line 61 of file pLattice.h.

  : ContactDetection<T, PARTICLETYPE>(pSys, "PLattice"),
    _physPos(3, T()),
    _physExtend(3, T()),
    _intExtend(3, 0),
    _overlap(overlap),
    _spacing(spacing)
{
 
  _physPos = this->_pSys.getPhysPos();
  _physExtend = this->_pSys.getPhysExtend();
 
  int intOverlap = util::ceil(overlap / _spacing);
  std::cout << "intOverlap: " << intOverlap << std::endl;
  for (int i = 0; i < 3; i++) {
    _physPos[i] -= overlap;
    _intExtend[i] = util::ceil(_physExtend[i] / _spacing + 2 * intOverlap + 1);
    std::cout << "intExtend[" << i << "]: " << _physExtend[i] << std::endl;
  }
 
  std::cout << "intOverlap: " << intOverlap << std::endl;
 
  _pLattice.resize(_intExtend[0]);
  for (int iX = 0; iX < _intExtend[0]; ++iX) {
    _pLattice[iX].resize(_intExtend[1]);
    for (int iY = 0; iY < _intExtend[1]; ++iY) {
      _pLattice[iX][iY].resize(_intExtend[2]);
      for (int iZ = 0; iZ < _intExtend[2]; ++iZ) {
      }
    }
  }
//  cout << "intExtend " << _intExtend[0] << " "<< _intExtend[1] << " "<< _intExtend[2] << " " << std::endl;
}

References olb::ContactDetection< T, PARTICLETYPE >::_pSys, and olb::util::ceil().

Here is the call graph for this function:

Member Function Documentation

getMatches()

template<typename T , template< typename U > class PARTICLETYPE>

int olb::PLattice< T, PARTICLETYPE >::getMatches ( int pInt, std::vector< std::pair< size_t, T > > & matches )

virtual

Reimplemented from olb::ContactDetection< T, PARTICLETYPE >.

Definition at line 189 of file pLattice.h.

{
  matches.clear();
  PARTICLETYPE<T>& p = this->_pSys[pInt];
  int iX = util::floor((p.getPos()[0] - _physPos[0]) / _spacing);
  int iY = util::floor((p.getPos()[1] - _physPos[1]) / _spacing);
  int iZ = util::floor((p.getPos()[2] - _physPos[2]) / _spacing);
 
  typename std::list<int>::iterator it = _pLattice[iX][iY][iZ].begin();
  std::vector<T>& pos = p.getPos();
  for (; it != _pLattice[iX][iY][iZ].end(); ++it) {
    if (*it != -1) {
      std::vector<T>& pos2 = this->_pSys[*it].getPos();
      matches.push_back(
        std::make_pair<size_t, T>(
          *it,
          util::pow(pos[0] - pos2[0], 2) + util::pow(pos[1] - pos2[1], 2)
          + util::pow(pos[2] - pos2[2], 2)));
    }
  }
  return matches.size();
}

References olb::util::floor(), and olb::util::pow().

Here is the call graph for this function:

sort()

template<typename T , template< typename U > class PARTICLETYPE>

void olb::PLattice< T, PARTICLETYPE >::sort ( )

virtual

Reimplemented from olb::ContactDetection< T, PARTICLETYPE >.

Definition at line 97 of file pLattice.h.

{
//  _pLattice.clear();
  for (int i = 0; i < _intExtend[0]; i++) {
    for (int j = 0; j < _intExtend[1]; j++) {
      for (int k = 0; k < _intExtend[2]; k++) {
        _pLattice[i][j][k].clear();
      }
    }
  }
 
  std::vector<T> pos(3, T());
  for (unsigned int i = 0; i < this->_pSys.sizeInclShadow(); i++) {
    pos = this->_pSys[i].getPos();
#if OLB_DEBUG
    int aa = (pos[0] - _physPos[0]) / _spacing;
    int bb = (pos[1] - _physPos[1]) / _spacing;
    int cc = (pos[2] - _physPos[2]) / _spacing;
 
    OLB_PRECONDITION( aa >= 0);
    OLB_PRECONDITION( bb >= 0);
    OLB_PRECONDITION( cc >= 0);
    OLB_PRECONDITION( aa < _intExtend[0]);
    OLB_PRECONDITION( bb < _intExtend[1]);
    OLB_PRECONDITION( cc < _intExtend[2]);
#endif
 
    _pLattice[(int) util::floor((pos[0] - _physPos[0]) / _spacing)][(int) util::floor(
          (pos[1] - _physPos[1]) / _spacing)][(int) util::floor(
                   (pos[2] - _physPos[2]) / _spacing)].push_back(i);
  }
 
  int iX = 0, iY = 0, iZ = 0;
  int x = 0, y = 0, z = 0;
  for (unsigned int s = 0; s < this->_pSys.size(); s++) {
    pos = this->_pSys[s].getPos();
    iX = util::floor((pos[0] - _physPos[0]) / _spacing);
    iY = util::floor((pos[1] - _physPos[1]) / _spacing);
    iZ = util::floor((pos[2] - _physPos[2]) / _spacing);
    //
    if (_pLattice[iX][iY][iZ].back() != -1) {
 
      int a = 1, b = 1, c = 1;
      int d = -1, e = -1, f = -1;
      if (iX <= 0) {
        d = 0;
      }
      if (iY <= 0) {
        e = 0;
      }
      if (iZ <= 0) {
        f = 0;
      }
      if (iX >= _intExtend[0]) {
        a = 0;
      }
      if (iY >= _intExtend[1]) {
        b = 0;
      }
      if (iZ >= _intExtend[2]) {
        c = 0;
      }
 
      typename std::list<int>::iterator it;
      for (int i = d; i <= a; i++) {
        for (int j = e; j <= b; j++) {
          for (int k = f; k <= c; k++) {
            if (i != 0 || j != 0 || k != 0) {
              it = _pLattice[iX + i][iY + j][iZ + k].begin();
              int size = _pLattice[iX + i][iY + j][iZ + k].size();
              for (int lauf = 0; lauf < size; lauf++, it++) {
                if (*it != -1) {
                  pos = this->_pSys[*it].getPos();
                  T rad = this->_pSys[*it].getRad();
                  x = util::floor((pos[0] - _physPos[0] - i * rad) / _spacing);
                  y = util::floor((pos[1] - _physPos[1] - j * rad) / _spacing);
                  z = util::floor((pos[2] - _physPos[2] - k * rad) / _spacing);
                  if (x != iX || y != iY || z != iZ) {
                    _pLattice[iX][iY][iZ].push_back(*it);
                  }
                }
              }
            }
          }
        }
      }
      _pLattice[iX][iY][iZ].push_back(-1);
    }
  }
}

References olb::util::floor(), and OLB_PRECONDITION.

Here is the call graph for this function:

---

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

• src/particles/subgrid3DLegacyFramework/contactDetection/pLattice.h