LinkedCellsContainer Class Reference

Extension of the ParticleContainer class using a linked cells data structure for improved performance over the direct sum approach. More...

#include <LinkedCellsContainer.h>

Inheritance diagram for LinkedCellsContainer:

Collaboration diagram for LinkedCellsContainer:

Public Types
enum class	BoundaryCondition { OUTFLOW , REFLECTIVE , PERIODIC }
	Boundary type enum for labeling the sides of the domain. More...
enum class	BoundarySide {   LEFT , RIGHT , BOTTOM , TOP ,   BACK , FRONT }
	Boundary side enum for labeling the sides of the domain. More...

Public Member Functions
	LinkedCellsContainer (const std::array< double, 3 > &domain_size, double cutoff_radius, const std::array< BoundaryCondition, 6 > &boundary_types={BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW}, int n=0)
	Construct a new Linked Cells Particle Container object. More...
void	addParticle (const Particle &p) override
	Adds a particle to the container. More...
void	addParticle (Particle &&p) override
	Adds a particle to the container. More...
void	prepareForceCalculation () override
	Prepares everything for the force calculations (must be called before applySimpleForces and applyPairwiseForces) More...
void	applySimpleForces (const std::vector< std::shared_ptr< SimpleForceSource >> &simple_force_sources) override
	Applies the given simple force sources to the particles. More...
void	applyPairwiseForces (const std::vector< std::shared_ptr< PairwiseForceSource >> &force_sources) override
	Applies the given force sources to the particles. More...
void	applyTargettedForces (const std::vector< std::shared_ptr< TargettedForceSource >> &targetted_force_sources, double curr_simulation_time) override
	Applies the given targetted force sources to the particles. More...
void	reserve (size_t n) override
	Reserves space for n particles. This is useful if the number of particles is known in advance and prevents reallocation of memory for the internal dynamic array of particles, when inserting new particles. More...
size_t	size () const override
	Returns the number of particles in the container. More...
Particle &	operator[] (int i) override
	Overload of the [] operator to access the particles in the container. More...
std::vector< Particle >::iterator	begin () override
	The begin iterator for the internal data structure. More...
std::vector< Particle >::iterator	end () override
	The end iterator for the internal data structure. More...
std::vector< Particle >::const_iterator	begin () const override
	The begin const iterator for the internal data structure. More...
std::vector< Particle >::const_iterator	end () const override
	The end const iterator for the internal data structure. More...
const std::vector< Particle > &	getParticles () const override
	Returns a vector of all particles in the container. More...
const std::array< double, 3 > &	getDomainSize () const
	Returns the domain size. More...
double	getCutoffRadius () const
	Returns the cutoff radius. More...
const std::vector< Cell > &	getCells ()
	Returns the cells. More...
const std::vector< Cell * > &	getBoundaryCells () const
	Returns the pointers of the boundary cells. More...
const std::array< double, 3 > &	getCellSize () const
	Returns the cell size. More...
const std::array< int, 3 > &	getDomainNumCells () const
	Returns the number of cells in each dimension. More...
int	cellCoordToCellIndex (int cx, int cy, int cz) const
	Maps the cell coordinates to the corresponding index in the internal cell vector. More...
Cell *	particlePosToCell (const std::array< double, 3 > &pos)
	Maps the particle position to the corresponding cell index in the internal cell vector. More...
Cell *	particlePosToCell (double x, double y, double z)
	Maps the particle position to the corresponding cell index in the internal cell vector. More...
Public Member Functions inherited from ParticleContainer
virtual	~ParticleContainer ()=default
	Virtual destructor for correct deconstruction of inheriting classes. More...

Static Public Member Functions
static std::string	boundaryConditionToString (const BoundaryCondition &bc)
	Returns a string description of a boundary condition. More...

Private Member Functions
void	initCells ()
	Populates the cell vector and sets the cells types. More...
void	initCellNeighbourReferences ()
	Sets the neighbour references for each cell in the cell vector. More...
void	initIterationOrders ()
	Sets the iteration orders for parallel execution. More...
void	updateCellsParticleReferences ()
	Updates the particle references in the cells. This is necessary after a reallocation of the internal particle vector. More...
void	deleteHaloParticles ()
	Removes all particles in the halo cells from the particles vector. ATTENTION: A particle reference update must be triggered manually after this operation! More...

Private Attributes
std::vector< std::vector< Cell * > >	iteration_orders
std::vector< Particle >	particles
	Internal data structure for the particles. More...
std::array< double, 3 >	domain_size
	Domain size in each dimension. More...
double	cutoff_radius
	Cutoff radius for the force calculation. More...
std::array< BoundaryCondition, 6 >	boundary_types
	The boundary types for each side of the domain (order in array: left, right, bottom, top, back, front) More...
std::array< double, 3 >	cell_size
	Cell size in each dimension. More...
std::array< int, 3 >	domain_num_cells
	Number of cells in each dimension. More...
std::vector< Cell >	cells
	Internal data structure for the cells. More...
std::vector< Cell * >	domain_cell_references
	References to the domain cells. More...
std::vector< Cell * >	boundary_cell_references
	References to the boundary cells. More...
std::vector< Cell * >	halo_cell_references
	References to the halo cells. More...
std::vector< Cell * >	left_boundary_cell_references
	References to the boundary cells on the left (x = 0) More...
std::vector< Cell * >	right_boundary_cell_references
	References to the boundary cells on the right (x = domain_num_cells[0]-1) More...
std::vector< Cell * >	bottom_boundary_cell_references
	References to the boundary cells on the bottom (y = 0) More...
std::vector< Cell * >	top_boundary_cell_references
	References to the boundary cells on the top (y = domain_num_cells[1]-1) More...
std::vector< Cell * >	back_boundary_cell_references
	References to the boundary cells on the back (z = 0) More...
std::vector< Cell * >	front_boundary_cell_references
	References to the boundary cells on the front (z = domain_num_cells[2]-1) More...
std::vector< Cell * >	left_halo_cell_references
	References to the halo cells on the left (x = -1) More...
std::vector< Cell * >	right_halo_cell_references
	References to the halo cells on the right (x = domain_num_cells[0]) More...
std::vector< Cell * >	bottom_halo_cell_references
	References to the halo cells on the bottom (y = -1) More...
std::vector< Cell * >	top_halo_cell_references
	References to the halo cells on the top (y = domain_num_cells[1]) More...
std::vector< Cell * >	back_halo_cell_references
	References to the halo cells on the back (z = -1) More...
std::vector< Cell * >	front_halo_cell_references
	References to the halo cells on the front (z = domain_num_cells[2]) More...

Friends
class	ReflectiveBoundaryType
	Friend class to allow access to the internal data structures. More...
class	OutflowBoundaryType
	Friend class to allow access to the internal data structures. More...
class	PeriodicBoundaryType
	Friend class to allow access to the internal data structures. More...

Detailed Description

Extension of the ParticleContainer class using a linked cells data structure for improved performance over the direct sum approach.

Definition at line 14 of file LinkedCellsContainer.h.

Member Enumeration Documentation

BoundaryCondition

enum LinkedCellsContainer::BoundaryCondition

strong

Boundary type enum for labeling the sides of the domain.

Enumerator
OUTFLOW
REFLECTIVE
PERIODIC

Definition at line 21 of file LinkedCellsContainer.h.

{ OUTFLOW, REFLECTIVE, PERIODIC };

BoundarySide

enum LinkedCellsContainer::BoundarySide

strong

Boundary side enum for labeling the sides of the domain.

Enumerator
LEFT
RIGHT
BOTTOM
TOP
BACK
FRONT

Definition at line 26 of file LinkedCellsContainer.h.

{ LEFT, RIGHT, BOTTOM, TOP, BACK, FRONT };

Constructor & Destructor Documentation

LinkedCellsContainer()

LinkedCellsContainer::LinkedCellsContainer	(	const std::array< double, 3 > &	domain_size,
		double	cutoff_radius,
		const std::array< BoundaryCondition, 6 > &	boundary_types = {BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW, BoundaryCondition::OUTFLOW},
		int	n = 0
	)

Construct a new Linked Cells Particle Container object.

Parameters

domain_size	the size of the domain
cutoff_radius	the cutoff radius for the force calculation
boundary_types	the boundary types for each side of the domain (order in array: left, right, bottom, top, back, front)
n	the expected number of particles (for preallocation of memory)

Constructs a new Linked Cells Particle Container object using the specified domain size and cutoff radius. The expected number of particles is used to preallocate memory for the particle vector, which is highly recommended for known amounts of particles (improves performance as no std::vector resize is needed on inserts). The origin (left lower front corner of the boundary) is assumed to be at (0, 0, 0). The cutoff radius is used to determine the number of cells in each dimension, where the cell size is bigger or equal then the cutoff radius but adjusted to divide the domain size evenly into a whole number of cells. Ideally the domain size is a multiple of the cutoff and cube shaped. Internally, the domain is extended by one cell in each direction to allow for so called 'ghost' or 'halo' cells that are used for boundary condition handling. Therefore the valid cell coordinates range from -1 to domain_num_cells[i] in each dimension (i = 0 -> x; i = 1 -> y; i = 2 -> z).

Definition at line 18 of file LinkedCellsContainer.cpp.

    : domain_size(_domain_size), cutoff_radius(_cutoff_radius), boundary_types(_boundary_types) {
    domain_num_cells = {std::max(static_cast<int>(std::floor(_domain_size[0] / cutoff_radius)), 1),
                        std::max(static_cast<int>(std::floor(_domain_size[1] / cutoff_radius)), 1),
                        std::max(static_cast<int>(std::floor(_domain_size[2] / cutoff_radius)), 1)};
 
    cell_size = {_domain_size[0] / domain_num_cells[0], _domain_size[1] / domain_num_cells[1], _domain_size[2] / domain_num_cells[2]};
 
    // reserve the memory for the cells
    cells.reserve((domain_num_cells[0] + 2) * (domain_num_cells[1] + 2) * (domain_num_cells[2] + 2));
 
    // create the cells with the correct cell-type and add them to the cells vector and the corresponding cell reference vector
    initCells();
 
    // add the neighbour references to the cells
    initCellNeighbourReferences();
 
    // create the iteration orders
    initIterationOrders();
 
    // reserve the memory for the particles to prevent reallocation during insertion
    particles.reserve(_n);
 
    Logger::logger->debug("Created LinkedCellsContainer with boundaries [{}, {}, {}] and cutoff radius {}", domain_size[0], domain_size[1],
                          domain_size[2], cutoff_radius);
    Logger::logger->debug("Created LinkedCellsContainer with {} domain cells (of which {} are at the boundary) and {} halo cells",
                          domain_cell_references.size(), boundary_cell_references.size(), halo_cell_references.size());
    Logger::logger->debug("Cells per dimension: [{}, {}, {}]", domain_num_cells[0], domain_num_cells[1], domain_num_cells[2]);
    Logger::logger->debug("Calculated cell size: [{}, {}, {}]", cell_size[0], cell_size[1], cell_size[2]);
}

Member Function Documentation

addParticle() [1/2]

void LinkedCellsContainer::addParticle ( const Particle &  p )

overridevirtual

Adds a particle to the container.

Parameters

p	Particle to be added

Adds a particle to the container and correctly inserts it into the cell structure.

Implements ParticleContainer.

Definition at line 50 of file LinkedCellsContainer.cpp.

                                                        {
    Cell* cell = particlePosToCell(p.getX());
 
    if (cell == nullptr) {
        Logger::logger->error("Particle to insert is out of bounds, position: [{}, {}, {}]", p.getX()[0], p.getX()[1], p.getX()[2]);
        throw std::runtime_error("Attempted to insert particle out of bounds");
    }
    // if (cell->getCellType() == Cell::CellType::HALO) {
    //     Logger::logger->warn("Particle to insert is in halo cell. Position: [{}, {}, {}]", p.getX()[0], p.getX()[1], p.getX()[2]);
    //     throw std::runtime_error("Attempted to insert particle into halo cell");
    // }
 
    size_t old_capacity = particles.capacity();
    particles.push_back(p);
 
    if (old_capacity != particles.capacity()) {
        updateCellsParticleReferences();
    } else {
        cell->addParticleReference(&particles.back());
    }
}

addParticle() [2/2]

void LinkedCellsContainer::addParticle ( Particle &&  p )

overridevirtual

Adds a particle to the container.

Parameters

p	Particle to be added

Adds a particle to the container and correctly inserts it into the cell structure.

Implements ParticleContainer.

Definition at line 72 of file LinkedCellsContainer.cpp.

                                                   {
    Cell* cell = particlePosToCell(p.getX());
 
    if (cell == nullptr) {
        Logger::logger->error("Particle to insert is outside of cells. Position: [{}, {}, {}]", p.getX()[0], p.getX()[1], p.getX()[2]);
        throw std::runtime_error("Attempted to insert particle out of bounds");
    }
    // if (cell->getCellType() == Cell::CellType::HALO) {
    //     Logger::logger->warn("Particle to insert is in halo cell. Position: [{}, {}, {}]", p.getX()[0], p.getX()[1], p.getX()[2]);
    //     throw std::runtime_error("Attempted to insert particle into halo cell");
    // }
 
    size_t old_capacity = particles.capacity();
    particles.push_back(std::move(p));
 
    if (old_capacity != particles.capacity()) {
        updateCellsParticleReferences();
    } else {
        cell->addParticleReference(&particles.back());
    }
}

applyPairwiseForces()

void LinkedCellsContainer::applyPairwiseForces ( const std::vector< std::shared_ptr< PairwiseForceSource >> &  force_sources )

overridevirtual

Applies the given force sources to the particles.

Parameters

force_sources

List of force sources to be applied

Applies the given force sources to the particles in the container. Uses newton's third law to calculate the forces between the particles in an optimized way. Additionally to the functionality of the ParticleContainer class, this method uses the internal cell structure to reduce the number of force calculations necessary, depending on the cutoff radius.

Implements ParticleContainer.

Definition at line 117 of file LinkedCellsContainer.cpp.

                                                                                                                 {
    // apply the boundary conditions
    ReflectiveBoundaryType::applyBoundaryConditions(*this);
    size_t original_particle_length = PeriodicBoundaryType::applyBoundaryConditions(*this);
 
    for (auto& it_order : iteration_orders) {
#ifdef _OPENMP
#pragma omp parallel for schedule(dynamic)
#endif
        for (Cell* cell : it_order) {
            if (cell->getParticleReferences().empty()) continue;
 
            // Calculate cell internal forces
            for (auto it1 = cell->getParticleReferences().begin(); it1 != cell->getParticleReferences().end(); ++it1) {
                Particle* p = *it1;
                // calculate the forces between the particle and the particles in the same cell
                // uses direct sum with newtons third law
                for (auto it2 = (it1 + 1); it2 != cell->getParticleReferences().end(); ++it2) {
                    if (p->isLocked() && (*it2)->isLocked()) continue;
                    Particle* q = *it2;
                    std::array<double, 3> total_force{0, 0, 0};
                    for (auto& force : force_sources) {
                        total_force = total_force + force->calculateForce(*p, *q);
                    }
                    p->addF(total_force);
                    q->subF(total_force);
                }
            }
 
            // Calculate cell boundary forces
            for (Cell* neighbour_cell : cell->getNeighbourReferences()) {
                if (cell < neighbour_cell) continue;
                if (neighbour_cell->getParticleReferences().empty()) continue;
 
                for (Particle* p : cell->getParticleReferences()) {
                    for (Particle* neighbour_particle : neighbour_cell->getParticleReferences()) {
                        if (p->isLocked() && neighbour_particle->isLocked()) continue;
                        if (ArrayUtils::L2NormSquared(p->getX() - neighbour_particle->getX()) > cutoff_radius * cutoff_radius) continue;
 
                        auto total_force = std::array<double, 3>{0, 0, 0};
                        for (const auto& force_source : force_sources) {
                            total_force = total_force + force_source->calculateForce(*p, *neighbour_particle);
                        }
                        p->addF(total_force);
                        neighbour_particle->subF(total_force);
                    }
                }
            }
        }
    }
 
    // remove the periodic halo particles
    particles.erase(particles.begin() + original_particle_length, particles.end());
    updateCellsParticleReferences();
}

applySimpleForces()

void LinkedCellsContainer::applySimpleForces ( const std::vector< std::shared_ptr< SimpleForceSource >> &  simple_force_sources )

overridevirtual

Applies the given simple force sources to the particles.

Parameters

simple_force_sources

List of simple force sources to be applied

Applies the given simple force sources to the particles in the container.

Implements ParticleContainer.

Definition at line 108 of file LinkedCellsContainer.cpp.

                                                                                                                    {
    for (Particle& p : particles) {
        if (p.isLocked()) continue;
        for (const auto& force_source : simple_force_sources) {
            p.setF(p.getF() + force_source->calculateForce(p));
        }
    }
}

applyTargettedForces()

void LinkedCellsContainer::applyTargettedForces ( const std::vector< std::shared_ptr< TargettedForceSource >> &  targetted_force_sources, double  curr_simulation_time  )

overridevirtual

Applies the given targetted force sources to the particles.

Parameters

targetted_force_sources	List of targetted force sources to be applied
curr_simulation_time	Current simulation time

Applies the given targetted force sources to the particles in the container.

Implements ParticleContainer.

Definition at line 173 of file LinkedCellsContainer.cpp.

                                                                             {
    for (const auto& force_source : force_sources) {
        force_source->applyForce(particles, curr_simulation_time);
    }
}

begin() [1/2]

std::vector< Particle >::const_iterator LinkedCellsContainer::begin ( ) const

overridevirtual

The begin const iterator for the internal data structure.

Returns

Const iterator to the first particle

Implements ParticleContainer.

Definition at line 199 of file LinkedCellsContainer.cpp.

{ return particles.begin(); }

begin() [2/2]

std::vector< Particle >::iterator LinkedCellsContainer::begin ( )

overridevirtual

The begin iterator for the internal data structure.

Returns

Iterator to the first particle

Implements ParticleContainer.

Definition at line 195 of file LinkedCellsContainer.cpp.

{ return particles.begin(); }

boundaryConditionToString()

std::string LinkedCellsContainer::boundaryConditionToString ( const BoundaryCondition &  bc )

static

Returns a string description of a boundary condition.

Definition at line 240 of file LinkedCellsContainer.cpp.

                                                                                     {
    switch (bc) {
        case BoundaryCondition::OUTFLOW:
            return "Outflow";
        case BoundaryCondition::REFLECTIVE:
            return "Reflective";
        case BoundaryCondition::PERIODIC:
            return "Periodic";
        default:
            return "Unknown";
    }
};

cellCoordToCellIndex()

int LinkedCellsContainer::cellCoordToCellIndex	(	int	cx,
		int	cy,
		int	cz
	)		const

Maps the cell coordinates to the corresponding index in the internal cell vector.

Parameters

cx	x coordinate of the cell (valid range: -1 to domain_num_cells[0])
cy	y coordinate of the cell (valid range: -1 to domain_num_cells[1])
cz	z coordinate of the cell (valid range: -1 to domain_num_cells[2])

Returns

index of the cell if it exists, -1 otherwise

Definition at line 217 of file LinkedCellsContainer.cpp.

                                                                           {
    if (cx < -1 || cx > domain_num_cells[0] || cy < -1 || cy > domain_num_cells[1] || cz < -1 || cz > domain_num_cells[2]) {
        return -1;
    }
    return (cx + 1) * (domain_num_cells[1] + 2) * (domain_num_cells[2] + 2) + (cy + 1) * (domain_num_cells[2] + 2) + (cz + 1);
}

deleteHaloParticles()

void LinkedCellsContainer::deleteHaloParticles ( )

private

Removes all particles in the halo cells from the particles vector. ATTENTION: A particle reference update must be triggered manually after this operation!

Definition at line 410 of file LinkedCellsContainer.cpp.

                                               {
    for (Cell* cell : halo_cell_references) {
        for (Particle* p : cell->getParticleReferences()) {
            particles.erase(particles.begin() + (p - &particles[0]));
        }
    }
}

end() [1/2]

std::vector< Particle >::const_iterator LinkedCellsContainer::end ( ) const

overridevirtual

The end const iterator for the internal data structure.

Returns

Const end iterator for this container

Implements ParticleContainer.

Definition at line 201 of file LinkedCellsContainer.cpp.

{ return particles.end(); }

end() [2/2]

std::vector< Particle >::iterator LinkedCellsContainer::end ( )

overridevirtual

The end iterator for the internal data structure.

Returns

Iterator to the end of the container

Implements ParticleContainer.

Definition at line 197 of file LinkedCellsContainer.cpp.

{ return particles.end(); }

getBoundaryCells()

const std::vector< Cell * > & LinkedCellsContainer::getBoundaryCells

(

)

const

Returns the pointers of the boundary cells.

Returns

Vector of pointers to the boundary cells

Returns the pointers of the boundary cells in a vector.

Definition at line 211 of file LinkedCellsContainer.cpp.

{ return boundary_cell_references; }

getCells()

const std::vector< Cell > & LinkedCellsContainer::getCells

(

)

Returns the cells.

Returns

Cells

Returns the cells as a vector of Cell objects.

Definition at line 209 of file LinkedCellsContainer.cpp.

{ return cells; }

getCellSize()

const std::array< double, 3 > & LinkedCellsContainer::getCellSize

(

)

const

Returns the cell size.

Returns

Cell size

Returns the cell size as a 3D array.

Definition at line 213 of file LinkedCellsContainer.cpp.

{ return cell_size; }

getCutoffRadius()

double LinkedCellsContainer::getCutoffRadius

(

)

const

Returns the cutoff radius.

Returns

Cutoff radius

Returns the cutoff radius used for the force calculation.

Definition at line 207 of file LinkedCellsContainer.cpp.

{ return cutoff_radius; }

getDomainNumCells()

const std::array< int, 3 > & LinkedCellsContainer::getDomainNumCells

(

)

const

Returns the number of cells in each dimension.

Returns

Number of cells in each dimension

Returns the number of cells in each dimension as a 3D array.

Definition at line 215 of file LinkedCellsContainer.cpp.

{ return domain_num_cells; }

getDomainSize()

const std::array< double, 3 > & LinkedCellsContainer::getDomainSize

(

)

const

Returns the domain size.

Returns

Domain size

Returns the domain size as a 3D array.

Definition at line 205 of file LinkedCellsContainer.cpp.

{ return domain_size; }

getParticles()

const std::vector< Particle > & LinkedCellsContainer::getParticles ( ) const

overridevirtual

Returns a vector of all particles in the container.

Returns

Vector of all particles in the container

Implements ParticleContainer.

Definition at line 203 of file LinkedCellsContainer.cpp.

{ return particles; }

initCellNeighbourReferences()

void LinkedCellsContainer::initCellNeighbourReferences ( )

private

Sets the neighbour references for each cell in the cell vector.

Definition at line 316 of file LinkedCellsContainer.cpp.

                                                       {
    // Loop through each cell according to their cell coordinates
    for (int cx = -1; cx < domain_num_cells[0] + 1; ++cx) {
        for (int cy = -1; cy < domain_num_cells[1] + 1; ++cy) {
            for (int cz = -1; cz < domain_num_cells[2] + 1; ++cz) {
                Cell& cell = cells.at(cellCoordToCellIndex(cx, cy, cz));
 
                // Loop through each of the current cells neighbour cells according to their cell coordinates
                // except the current cell itself
                for (int dx = -1; dx < 2; ++dx) {
                    for (int dy = -1; dy < 2; ++dy) {
                        for (int dz = -1; dz < 2; ++dz) {
                            if (dx == 0 && dy == 0 && dz == 0) continue;
 
                            // Get the cell index of the current neighbour cell
                            int cell_index = cellCoordToCellIndex(cx + dx, cy + dy, cz + dz);
 
                            // If the neighbour cell would be out of bounds, skip it
                            if (cell_index == -1) continue;
 
                            // Add the neighbour to the current cells neighbour references
                            Cell& curr_neighbour = cells.at(cell_index);
                            cell.addNeighbourReference(&curr_neighbour);
                        }
                    }
                }
            }
        }
    }
}

initCells()

void LinkedCellsContainer::initCells ( )

private

Populates the cell vector and sets the cells types.

Definition at line 257 of file LinkedCellsContainer.cpp.

                                     {
    for (int cx = -1; cx < domain_num_cells[0] + 1; ++cx) {
        for (int cy = -1; cy < domain_num_cells[1] + 1; ++cy) {
            for (int cz = -1; cz < domain_num_cells[2] + 1; ++cz) {
                if (cx < 0 || cx >= domain_num_cells[0] || cy < 0 || cy >= domain_num_cells[1] || cz < 0 || cz >= domain_num_cells[2]) {
                    cells.emplace_back(Cell::CellType::HALO);
                    halo_cell_references.push_back(&cells.back());
 
                    if (cx == -1) {
                        left_halo_cell_references.push_back(&cells.back());
                    }
                    if (cx == domain_num_cells[0]) {
                        right_halo_cell_references.push_back(&cells.back());
                    }
                    if (cy == -1) {
                        bottom_halo_cell_references.push_back(&cells.back());
                    }
                    if (cy == domain_num_cells[1]) {
                        top_halo_cell_references.push_back(&cells.back());
                    }
                    if (cz == -1) {
                        back_halo_cell_references.push_back(&cells.back());
                    }
                    if (cz == domain_num_cells[2]) {
                        front_halo_cell_references.push_back(&cells.back());
                    }
                } else if (cx == 0 || cx == domain_num_cells[0] - 1 || cy == 0 || cy == domain_num_cells[1] - 1 || cz == 0 ||
                           cz == domain_num_cells[2] - 1) {
                    cells.emplace_back(Cell::CellType::BOUNDARY);
                    boundary_cell_references.push_back(&cells.back());
                    domain_cell_references.push_back(&cells.back());
 
                    if (cx == 0) {
                        left_boundary_cell_references.push_back(&cells.back());
                    }
                    if (cx == domain_num_cells[0] - 1) {
                        right_boundary_cell_references.push_back(&cells.back());
                    }
                    if (cy == 0) {
                        bottom_boundary_cell_references.push_back(&cells.back());
                    }
                    if (cy == domain_num_cells[1] - 1) {
                        top_boundary_cell_references.push_back(&cells.back());
                    }
                    if (cz == 0) {
                        back_boundary_cell_references.push_back(&cells.back());
                    }
                    if (cz == domain_num_cells[2] - 1) {
                        front_boundary_cell_references.push_back(&cells.back());
                    }
                } else {
                    cells.emplace_back(Cell::CellType::INNER);
                    domain_cell_references.push_back(&cells.back());
                }
            }
        }
    }
}

initIterationOrders()

void LinkedCellsContainer::initIterationOrders ( )

private

Sets the iteration orders for parallel execution.

Definition at line 347 of file LinkedCellsContainer.cpp.

                                               {
#if PARALLEL_V2
    Logger::logger->warn("Creating iteration orders for parallel v2");
    std::vector<Cell*> iteration_order;
 
    for (size_t num = 0; num < cells.size(); ++num) {
        iteration_order.push_back(&cells[num]);
    }
 
    // shuffle the iteration order
    std::random_device rd;
    std::mt19937 g(rd());
    std::shuffle(iteration_order.begin(), iteration_order.end(), g);
 
    iteration_orders.push_back(iteration_order);
#else
    Logger::logger->warn("Creating iteration orders for parallel v1 (c_18 traversal)");
 
    std::vector<std::array<int, 3>> start_offsets;
 
    int d_x = 2;
    int d_y = 3;
    int d_z = 3;
 
    for (int x = 0; x < d_x; ++x) {
        for (int y = 0; y < d_y; ++y) {
            for (int z = 0; z < d_z; ++z) {
                start_offsets.push_back({x - 1, y - 1, z - 1});
            }
        }
    }
 
    for (size_t i = 0; i < start_offsets.size(); ++i) {
        std::vector<Cell*> iteration_order;
        const std::array<int, 3>& start_offset = start_offsets[i];
 
        for (int cx = start_offset[0]; cx <= domain_num_cells[0]; cx += d_x) {
            for (int cy = start_offset[1]; cy <= domain_num_cells[1]; cy += d_y) {
                for (int cz = start_offset[2]; cz <= domain_num_cells[2]; cz += d_z) {
                    iteration_order.push_back(&cells.at(cellCoordToCellIndex(cx, cy, cz)));
                }
            }
        }
 
        iteration_orders.push_back(iteration_order);
    }
#endif
}

operator[]()

Particle & LinkedCellsContainer::operator[] ( int  i )

overridevirtual

Overload of the [] operator to access the particles in the container.

Parameters

i	Index of the particle

Returns

Particle

Implements ParticleContainer.

Definition at line 193 of file LinkedCellsContainer.cpp.

{ return particles[i]; }

particlePosToCell() [1/2]

Cell * LinkedCellsContainer::particlePosToCell

(

const std::array< double, 3 > &

pos

)

Maps the particle position to the corresponding cell index in the internal cell vector.

Parameters

pos	Position of the particle

Returns

index of the cell if it exists, -1 otherwise

Definition at line 224 of file LinkedCellsContainer.cpp.

{ return particlePosToCell(pos[0], pos[1], pos[2]); }

particlePosToCell() [2/2]

Cell * LinkedCellsContainer::particlePosToCell	(	double	x,
		double	y,
		double	z
	)

Maps the particle position to the corresponding cell index in the internal cell vector.

Parameters

x	x coordinate of the particle
y	y coordinate of the particle
z	z coordinate of the particle

Returns

index of the cell if it exists, -1 otherwise

Definition at line 226 of file LinkedCellsContainer.cpp.

                                                                          {
    int cx = static_cast<int>(std::floor(x / cell_size[0]));
    int cy = static_cast<int>(std::floor(y / cell_size[1]));
    int cz = static_cast<int>(std::floor(z / cell_size[2]));
 
    int cell_index = cellCoordToCellIndex(cx, cy, cz);
    if (cell_index == -1) {
        Logger::logger->error("Particle is outside of cells. Position: [{}, {}, {}]", x, y, z);
        throw std::runtime_error("A particle is outside of the cells");
    }
 
    return &cells[cell_index];
}

prepareForceCalculation()

void LinkedCellsContainer::prepareForceCalculation ( )

overridevirtual

Prepares everything for the force calculations (must be called before applySimpleForces and applyPairwiseForces)

Implements ParticleContainer.

Definition at line 94 of file LinkedCellsContainer.cpp.

                                                   {
    // update the particle references in the cells in case the particles have moved
    updateCellsParticleReferences();
 
    // delete particles from halo cells
    OutflowBoundaryType::pre(*this);
 
    // teleport particles to other side of container
    PeriodicBoundaryType::pre(*this);
 
    // update the particle references in the cells in case the particles have moved
    updateCellsParticleReferences();
}

reserve()

void LinkedCellsContainer::reserve ( size_t  n )

overridevirtual

Reserves space for n particles. This is useful if the number of particles is known in advance and prevents reallocation of memory for the internal dynamic array of particles, when inserting new particles.

Parameters

n	Total amount of particles expected to store in the container

Implements ParticleContainer.

Definition at line 180 of file LinkedCellsContainer.cpp.

                                           {
    Logger::logger->debug("Reserving space for {} particles", n);
 
    size_t old_capacity = particles.capacity();
    particles.reserve(n);
 
    if (old_capacity != particles.capacity()) {
        updateCellsParticleReferences();
    }
}

size()

size_t LinkedCellsContainer::size ( ) const

overridevirtual

Returns the number of particles in the container.

Returns

Number of particles in the container

Implements ParticleContainer.

Definition at line 191 of file LinkedCellsContainer.cpp.

{ return particles.size(); }

updateCellsParticleReferences()

void LinkedCellsContainer::updateCellsParticleReferences ( )

private

Updates the particle references in the cells. This is necessary after a reallocation of the internal particle vector.

Definition at line 396 of file LinkedCellsContainer.cpp.

                                                         {
    // clear the particle references in the cells
    for (Cell& cell : cells) {
        cell.clearParticleReferences();
    }
 
    // add the particle references to the cells
    for (Particle& p : particles) {
        Cell* cell = particlePosToCell(p.getX());
 
        cell->addParticleReference(&p);
    }
}

Friends And Related Function Documentation

OutflowBoundaryType

friend class OutflowBoundaryType

friend

Friend class to allow access to the internal data structures.

Definition at line 287 of file LinkedCellsContainer.h.

PeriodicBoundaryType

friend class PeriodicBoundaryType

friend

Friend class to allow access to the internal data structures.

Definition at line 292 of file LinkedCellsContainer.h.

ReflectiveBoundaryType

friend class ReflectiveBoundaryType

friend

Friend class to allow access to the internal data structures.

Definition at line 282 of file LinkedCellsContainer.h.

Member Data Documentation

back_boundary_cell_references

std::vector<Cell*> LinkedCellsContainer::back_boundary_cell_references

private

References to the boundary cells on the back (z = 0)

Definition at line 370 of file LinkedCellsContainer.h.

back_halo_cell_references

std::vector<Cell*> LinkedCellsContainer::back_halo_cell_references

private

References to the halo cells on the back (z = -1)

Definition at line 402 of file LinkedCellsContainer.h.

bottom_boundary_cell_references

std::vector<Cell*> LinkedCellsContainer::bottom_boundary_cell_references

private

References to the boundary cells on the bottom (y = 0)

Definition at line 360 of file LinkedCellsContainer.h.

bottom_halo_cell_references

std::vector<Cell*> LinkedCellsContainer::bottom_halo_cell_references

private

References to the halo cells on the bottom (y = -1)

Definition at line 392 of file LinkedCellsContainer.h.

boundary_cell_references

std::vector<Cell*> LinkedCellsContainer::boundary_cell_references

private

References to the boundary cells.

Definition at line 338 of file LinkedCellsContainer.h.

boundary_types

std::array<BoundaryCondition, 6> LinkedCellsContainer::boundary_types

private

The boundary types for each side of the domain (order in array: left, right, bottom, top, back, front)

Definition at line 313 of file LinkedCellsContainer.h.

cell_size

std::array<double, 3> LinkedCellsContainer::cell_size

private

Cell size in each dimension.

Definition at line 318 of file LinkedCellsContainer.h.

cells

std::vector<Cell> LinkedCellsContainer::cells

private

Internal data structure for the cells.

Definition at line 328 of file LinkedCellsContainer.h.

cutoff_radius

double LinkedCellsContainer::cutoff_radius

private

Cutoff radius for the force calculation.

Definition at line 308 of file LinkedCellsContainer.h.

domain_cell_references

std::vector<Cell*> LinkedCellsContainer::domain_cell_references

private

References to the domain cells.

Definition at line 333 of file LinkedCellsContainer.h.

domain_num_cells

std::array<int, 3> LinkedCellsContainer::domain_num_cells

private

Number of cells in each dimension.

Definition at line 323 of file LinkedCellsContainer.h.

domain_size

std::array<double, 3> LinkedCellsContainer::domain_size

private

Domain size in each dimension.

Definition at line 303 of file LinkedCellsContainer.h.

front_boundary_cell_references

std::vector<Cell*> LinkedCellsContainer::front_boundary_cell_references

private

References to the boundary cells on the front (z = domain_num_cells[2]-1)

Definition at line 375 of file LinkedCellsContainer.h.

front_halo_cell_references

std::vector<Cell*> LinkedCellsContainer::front_halo_cell_references

private

References to the halo cells on the front (z = domain_num_cells[2])

Definition at line 407 of file LinkedCellsContainer.h.

halo_cell_references

std::vector<Cell*> LinkedCellsContainer::halo_cell_references

private

References to the halo cells.

Definition at line 343 of file LinkedCellsContainer.h.

iteration_orders

std::vector<std::vector<Cell*> > LinkedCellsContainer::iteration_orders

private

Definition at line 15 of file LinkedCellsContainer.h.

left_boundary_cell_references

std::vector<Cell*> LinkedCellsContainer::left_boundary_cell_references

private

References to the boundary cells on the left (x = 0)

Definition at line 350 of file LinkedCellsContainer.h.

left_halo_cell_references

std::vector<Cell*> LinkedCellsContainer::left_halo_cell_references

private

References to the halo cells on the left (x = -1)

Definition at line 382 of file LinkedCellsContainer.h.

particles

std::vector<Particle> LinkedCellsContainer::particles

private

Internal data structure for the particles.

Definition at line 298 of file LinkedCellsContainer.h.

right_boundary_cell_references

std::vector<Cell*> LinkedCellsContainer::right_boundary_cell_references

private

References to the boundary cells on the right (x = domain_num_cells[0]-1)

Definition at line 355 of file LinkedCellsContainer.h.

right_halo_cell_references

std::vector<Cell*> LinkedCellsContainer::right_halo_cell_references

private

References to the halo cells on the right (x = domain_num_cells[0])

Definition at line 387 of file LinkedCellsContainer.h.

top_boundary_cell_references

std::vector<Cell*> LinkedCellsContainer::top_boundary_cell_references

private

References to the boundary cells on the top (y = domain_num_cells[1]-1)

Definition at line 365 of file LinkedCellsContainer.h.

top_halo_cell_references

std::vector<Cell*> LinkedCellsContainer::top_halo_cell_references

private

References to the halo cells on the top (y = domain_num_cells[1])

Definition at line 397 of file LinkedCellsContainer.h.

---

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

• LinkedCellsContainer.h
• LinkedCellsContainer.cpp