NeighborSearcher Class Reference

#include <neighbor_searcher.hpp>

Collaboration diagram for NeighborSearcher:

Public Member Functions
	NeighborSearcher ()=default
	NeighborSearcher (const double &re, const Domain &domain, const size_t &particleSize)
void	setNeighbors (Particles &particles)

Private Attributes
double	re
Domain	domain
Bucket	bucket

Detailed Description

Definition at line 7 of file neighbor_searcher.hpp.

Constructor & Destructor Documentation

NeighborSearcher() [1/2]

NeighborSearcher::NeighborSearcher ( )

default

NeighborSearcher() [2/2]

NeighborSearcher::NeighborSearcher	(	const double &	re,
		const Domain &	domain,
		const size_t &	particleSize )

Definition at line 5 of file neighbor_searcher.cpp.

                                                                                                     {
    this->re     = re;
    this->domain = domain;
    this->bucket = Bucket(re, domain, particleSize);
}

Member Function Documentation

setNeighbors()

void NeighborSearcher::setNeighbors

(

Particles &

particles

)

Definition at line 11 of file neighbor_searcher.cpp.

                                                        {
    bucket.storeParticles(particles);
 
#pragma omp parallel for
    for (auto& pi : particles) {
        if (pi.type == ParticleType::Ghost)
            continue;
 
        pi.neighbors.clear();
 
        int ix = (int) ((pi.position.x() - domain.xMin) / bucket.length) + 1;
        int iy = (int) ((pi.position.y() - domain.yMin) / bucket.length) + 1;
        int iz = (int) ((pi.position.z() - domain.zMin) / bucket.length) + 1;
 
        for (int jx = ix - 1; jx <= ix + 1; jx++) {
            for (int jy = iy - 1; jy <= iy + 1; jy++) {
                for (int jz = iz - 1; jz <= iz + 1; jz++) {
                    int jBucket = jx + jy * bucket.numX + jz * bucket.numX * bucket.numY;
                    int j       = bucket.first[jBucket];
 
                    while (j != -1) {
                        Particle& pj = particles[j];
 
                        double dist = (pj.position - pi.position).norm();
                        if (j != pi.id && dist < re) {
                            pi.neighbors.emplace_back(j, dist);
                        }
 
                        j = bucket.next[j];
                    }
                }
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

re

double NeighborSearcher::re

private

Definition at line 16 of file neighbor_searcher.hpp.

domain

Domain NeighborSearcher::domain

private

Definition at line 17 of file neighbor_searcher.hpp.

bucket

Bucket NeighborSearcher::bucket

private

Definition at line 18 of file neighbor_searcher.hpp.

---

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

• src/neighbor_searcher.hpp
• src/neighbor_searcher.cpp