ReflectiveBoundaryType Class Reference

#include <ReflectiveBoundaryType.h>

Collaboration diagram for ReflectiveBoundaryType:

Static Public Member Functions
static void	pre (LinkedCellsContainer &container)
	Applies the preconditioning step for the reflective boundary condition. More...
static void	applyBoundaryConditions (LinkedCellsContainer &container)
	Applies the boundary conditions for the reflective boundary condition. More...

Static Private Member Functions
static std::array< double, 3 >	calculateReflectiveBoundaryForce (Particle &p, double distance, LinkedCellsContainer::BoundarySide side)
	Calculates the force of the reflective boundary for the given particle. More...

Detailed Description

Definition at line 7 of file ReflectiveBoundaryType.h.

Member Function Documentation

applyBoundaryConditions()

void ReflectiveBoundaryType::applyBoundaryConditions ( LinkedCellsContainer &  container )

static

Applies the boundary conditions for the reflective boundary condition.

Parameters

container

The container to apply the boundary conditions to.

This method adds the force of the reflective boundary to all particles that are in halo cells with the reflective boundary condition.

Definition at line 11 of file ReflectiveBoundaryType.cpp.

                                                                                    {
    if (container.boundary_types[0] == LinkedCellsContainer::BoundaryCondition::REFLECTIVE) {
        for (Cell* cell : container.left_boundary_cell_references) {
            for (Particle* p : cell->getParticleReferences()) {
                if (p->isLocked()) continue;
                double distance = p->getX()[0];
                p->setF(p->getF() + calculateReflectiveBoundaryForce(*p, distance, LinkedCellsContainer::BoundarySide::LEFT));
            }
        }
    }
 
    if (container.boundary_types[1] == LinkedCellsContainer::BoundaryCondition::REFLECTIVE) {
        for (Cell* cell : container.right_boundary_cell_references) {
            for (Particle* p : cell->getParticleReferences()) {
                if (p->isLocked()) continue;
                double distance = container.domain_size[0] - p->getX()[0];
                p->setF(p->getF() + calculateReflectiveBoundaryForce(*p, distance, LinkedCellsContainer::BoundarySide::RIGHT));
            }
        }
    }
 
    if (container.boundary_types[2] == LinkedCellsContainer::BoundaryCondition::REFLECTIVE) {
        for (Cell* cell : container.bottom_boundary_cell_references) {
            for (Particle* p : cell->getParticleReferences()) {
                if (p->isLocked()) continue;
                double distance = p->getX()[1];
                p->setF(p->getF() + calculateReflectiveBoundaryForce(*p, distance, LinkedCellsContainer::BoundarySide::BOTTOM));
            }
        }
    }
 
    if (container.boundary_types[3] == LinkedCellsContainer::BoundaryCondition::REFLECTIVE) {
        for (Cell* cell : container.top_boundary_cell_references) {
            for (Particle* p : cell->getParticleReferences()) {
                if (p->isLocked()) continue;
                double distance = container.domain_size[1] - p->getX()[1];
                p->setF(p->getF() + calculateReflectiveBoundaryForce(*p, distance, LinkedCellsContainer::BoundarySide::TOP));
            }
        }
    }
 
    if (container.boundary_types[4] == LinkedCellsContainer::BoundaryCondition::REFLECTIVE) {
        for (Cell* cell : container.back_boundary_cell_references) {
            for (Particle* p : cell->getParticleReferences()) {
                if (p->isLocked()) continue;
                double distance = p->getX()[2];
                p->setF(p->getF() + calculateReflectiveBoundaryForce(*p, distance, LinkedCellsContainer::BoundarySide::BACK));
            }
        }
    }
 
    if (container.boundary_types[5] == LinkedCellsContainer::BoundaryCondition::REFLECTIVE) {
        for (Cell* cell : container.front_boundary_cell_references) {
            for (Particle* p : cell->getParticleReferences()) {
                if (p->isLocked()) continue;
                double distance = container.domain_size[2] - p->getX()[2];
                p->setF(p->getF() + calculateReflectiveBoundaryForce(*p, distance, LinkedCellsContainer::BoundarySide::FRONT));
            }
        }
    }
}

calculateReflectiveBoundaryForce()

std::array< double, 3 > ReflectiveBoundaryType::calculateReflectiveBoundaryForce ( Particle &  p, double  distance, LinkedCellsContainer::BoundarySide  side  )

staticprivate

Calculates the force of the reflective boundary for the given particle.

Parameters

p	The particle to calculate the force for.
distance	The distance of the particle to the boundary.
side	The side of the boundary.

Returns

The force of the reflective boundary for the given particle.

Definition at line 73 of file ReflectiveBoundaryType.cpp.

                                                                                                                      {
    LennardJonesForce force = LennardJonesForce();
 
    if (2 * distance >= std::pow(2, 1.0 / 6) * p.getSigma()) {
        return {0, 0, 0};
    }
 
    Particle ghost_particle = Particle(p);
    ghost_particle.setX(p.getX() - std::array<double, 3>{2 * distance, 0, 0});
 
    auto force_vector_left_side = force.calculateForce(p, ghost_particle);
 
    switch (side) {
        case LinkedCellsContainer::BoundarySide::LEFT:
            return force_vector_left_side;
        case LinkedCellsContainer::BoundarySide::RIGHT:
            return {-force_vector_left_side[0], 0, 0};
        case LinkedCellsContainer::BoundarySide::BOTTOM:
            return {0, force_vector_left_side[0], 0};
        case LinkedCellsContainer::BoundarySide::TOP:
            return {0, -force_vector_left_side[0], 0};
        case LinkedCellsContainer::BoundarySide::BACK:
            return {0, 0, force_vector_left_side[0]};
        case LinkedCellsContainer::BoundarySide::FRONT:
            return {0, 0, -force_vector_left_side[0]};
    }
 
    Logger::logger->error("Faulty reflective boundary condition");
    return {0, 0, 0};
}

pre()

void ReflectiveBoundaryType::pre ( LinkedCellsContainer &  container )

static

Applies the preconditioning step for the reflective boundary condition.

Parameters

container

The container to apply the boundary conditions to.

This method is empty, as the reflective boundary condition does not require any special treatment.

Definition at line 7 of file ReflectiveBoundaryType.cpp.

                                                               {
 
};

---

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

• ReflectiveBoundaryType.h
• ReflectiveBoundaryType.cpp