SoftBodyCuboidSpawner Class Reference

Class to spawn particles of a soft body in a cuboid. Implements the interface ParticleSpawner. More...

#include <SoftBodyCuboidSpawner.h>

Inheritance diagram for SoftBodyCuboidSpawner:

Collaboration diagram for SoftBodyCuboidSpawner:

Public Member Functions
	SoftBodyCuboidSpawner (const std::array< double, 3 > &lower_left_corner, const std::array< int, 3 > &grid_dimensions, double grid_spacing, double mass, const std::array< double, 3 > &initial_velocity, int type, double epsilon=1.0, double sigma=1.2, double spring_constant=300, ThirdDimension third_dimension=ThirdDimension::ENABLED, double initial_temperature=0.1)
	Constructor. More...
int	spawnParticles (std::vector< Particle > &particles) const override
	Spawns particles in the given container. More...
size_t	getEstimatedNumberOfParticles () const override
	Estimate the number of particles to be spawned. More...

Private Attributes
const std::array< double, 3 >	lower_left_corner
	Defines the lower left corner where the cuboid will be spawned. More...
const std::array< int, 3 >	grid_dimensions
	Defines how big the cuboid will be. Each entry defines the number of particles in the respective direction. More...
const double	grid_spacing
	Defines the spacing between neighboring particles in the cuboid. More...
const double	mass
	Defines the mass of the particles in the cuboid. More...
const int	type
	Defines the type of the particles in the cuboid. More...
double	epsilon
	Defines the Lennard-Jones epsilon parameter of the particles in the cuboid. More...
double	sigma
	Defines the Lennard-Jones sigma parameter of the particles in the cuboid. More...
const double	spring_constant
	Spring constant of the harmonic springs. More...
const std::array< double, 3 >	initial_velocity
	Defines the initial velocity of the particles in the cuboid. More...
const double	initial_temperature
	Defines the initial temperature of the particles in the cuboid. More...
const ThirdDimension	third_dimension
	Defines whether the third dimension is enabled. More...

Detailed Description

Class to spawn particles of a soft body in a cuboid. Implements the interface ParticleSpawner.

Implementation of the particle spawning in a soft body cuboid. This class is very similar to the CuboidSpawner, but it links neighboring particles with harmonic springs. The HarmonicForce then class calculates the force on the particles.

Definition at line 13 of file SoftBodyCuboidSpawner.h.

Constructor & Destructor Documentation

SoftBodyCuboidSpawner()

SoftBodyCuboidSpawner::SoftBodyCuboidSpawner	(	const std::array< double, 3 > &	lower_left_corner,
		const std::array< int, 3 > &	grid_dimensions,
		double	grid_spacing,
		double	mass,
		const std::array< double, 3 > &	initial_velocity,
		int	type,
		double	epsilon = 1.0,
		double	sigma = 1.2,
		double	spring_constant = 300,
		ThirdDimension	third_dimension = ThirdDimension::ENABLED,
		double	initial_temperature = 0.1
	)

Constructor.

Parameters

lower_left_corner	Lower left corner of the soft body
grid_dimensions	Grid dimensions
grid_spacing	Spacing between neighboring particles
mass	Mass of the particles
initial_velocity	Initial velocity of the particles, the velocity is then jittered by a Maxwell-Boltzmann distribution
type	Type of the particles in the cuboid
epsilon	Lennard-Jones epsilon parameter of the particles in the cuboid
sigma	Lennard-Jones sigma parameter of the particles in the cuboid
spring_constant	Spring constant of the harmonic springs
initial_temperature	Initial temperature of the particles
third_dimension	Whether to spawn particles in the third dimension

Constructor to initialize the cuboid spawner. The velocity of the particles is jittered by a Maxwell-Boltzmann distribution.

Definition at line 10 of file SoftBodyCuboidSpawner.cpp.

    : lower_left_corner(lower_left_corner),
      grid_dimensions(grid_dimensions),
      grid_spacing(grid_spacing),
      mass(mass),
      type(type),
      epsilon(epsilon),
      sigma(sigma),
      spring_constant(spring_constant),
      initial_velocity(initial_velocity),
      initial_temperature(initial_temperature),
      third_dimension(third_dimension) {}

Member Function Documentation

getEstimatedNumberOfParticles()

size_t SoftBodyCuboidSpawner::getEstimatedNumberOfParticles ( ) const

overridevirtual

Estimate the number of particles to be spawned.

returns the number of particles to be spawned by this spawner this can be used to reserve enought memory in the particle container

Implements ParticleSpawner.

Definition at line 88 of file SoftBodyCuboidSpawner.cpp.

                                                                  {
    return static_cast<size_t>(grid_dimensions[0]) * grid_dimensions[1] * grid_dimensions[2];
}

spawnParticles()

int SoftBodyCuboidSpawner::spawnParticles ( std::vector< Particle > &  particles ) const

overridevirtual

Spawns particles in the given container.

Parameters

particles

A vector of particles to spawn

Returns

Number of particles spawned Spawns particles in the given container.

Implements ParticleSpawner.

Definition at line 26 of file SoftBodyCuboidSpawner.cpp.

                                                                              {
    auto prev_size = particles.size();
    particles.reserve(particles.size() + getEstimatedNumberOfParticles());
    for (int i = 0; i < grid_dimensions[0]; i++) {
        for (int j = 0; j < grid_dimensions[1]; j++) {
            for (int k = 0; k < grid_dimensions[2]; k++) {
                const auto grid_pos = std::array<double, 3>{static_cast<double>(i), static_cast<double>(j), static_cast<double>(k)};
 
                const auto x = lower_left_corner + grid_spacing * grid_pos;
 
                Particle particle(x, initial_velocity, mass, type, epsilon, sigma);
                Thermostat::setParticleTemperature(initial_temperature, particle, third_dimension);
                particles.push_back(std::move(particle));
            }
        }
    }
 
    auto particle_pos_to_index = [this, &prev_size](const std::array<int, 3>& grid_pos) {
        if (grid_pos[0] < 0 || grid_pos[0] >= grid_dimensions[0] || grid_pos[1] < 0 || grid_pos[1] >= grid_dimensions[1] ||
            grid_pos[2] < 0 || grid_pos[2] >= grid_dimensions[2]) {
            return -1;
        }
 
        return static_cast<int>(prev_size) + grid_pos[2] + grid_dimensions[2] * grid_pos[1] +
               grid_dimensions[2] * grid_dimensions[1] * grid_pos[0];
    };
 
    // connect particles with harmonic springs
    for (int i = 0; i < grid_dimensions[0]; i++) {
        for (int j = 0; j < grid_dimensions[1]; j++) {
            for (int k = 0; k < grid_dimensions[2]; k++) {
                auto curr_index = particle_pos_to_index({i, j, k});
                auto& curr_particle = particles[curr_index];
 
                for (int l = -1; l <= 1; l++) {
                    for (int m = -1; m <= 1; m++) {
                        for (int n = -1; n <= 1; n++) {
                            if (l == 0 && m == 0 && n == 0) {
                                continue;
                            }
 
                            auto neighbor_index = particle_pos_to_index({i + l, j + m, k + n});
 
                            if (neighbor_index == -1) {
                                continue;
                            }
 
                            auto& neighbor_particle = particles[neighbor_index];
 
                            auto initial_distance = ArrayUtils::L2Norm(curr_particle.getX() - neighbor_particle.getX());
 
                            curr_particle.addConnectedParticle(&neighbor_particle - &curr_particle, initial_distance, spring_constant);
                        }
                    }
                }
            }
        }
    }
 
    return grid_dimensions[0] * grid_dimensions[1] * grid_dimensions[2];
}

Member Data Documentation

epsilon

double SoftBodyCuboidSpawner::epsilon

private

Defines the Lennard-Jones epsilon parameter of the particles in the cuboid.

Definition at line 43 of file SoftBodyCuboidSpawner.h.

grid_dimensions

const std::array<int, 3> SoftBodyCuboidSpawner::grid_dimensions

private

Defines how big the cuboid will be. Each entry defines the number of particles in the respective direction.

Definition at line 23 of file SoftBodyCuboidSpawner.h.

grid_spacing

const double SoftBodyCuboidSpawner::grid_spacing

private

Defines the spacing between neighboring particles in the cuboid.

Definition at line 28 of file SoftBodyCuboidSpawner.h.

initial_temperature

const double SoftBodyCuboidSpawner::initial_temperature

private

Defines the initial temperature of the particles in the cuboid.

Definition at line 63 of file SoftBodyCuboidSpawner.h.

initial_velocity

const std::array<double, 3> SoftBodyCuboidSpawner::initial_velocity

private

Defines the initial velocity of the particles in the cuboid.

Definition at line 58 of file SoftBodyCuboidSpawner.h.

lower_left_corner

const std::array<double, 3> SoftBodyCuboidSpawner::lower_left_corner

private

Defines the lower left corner where the cuboid will be spawned.

Definition at line 18 of file SoftBodyCuboidSpawner.h.

mass

const double SoftBodyCuboidSpawner::mass

private

Defines the mass of the particles in the cuboid.

Definition at line 33 of file SoftBodyCuboidSpawner.h.

sigma

double SoftBodyCuboidSpawner::sigma

private

Defines the Lennard-Jones sigma parameter of the particles in the cuboid.

Definition at line 48 of file SoftBodyCuboidSpawner.h.

spring_constant

const double SoftBodyCuboidSpawner::spring_constant

private

Spring constant of the harmonic springs.

Definition at line 53 of file SoftBodyCuboidSpawner.h.

third_dimension

const ThirdDimension SoftBodyCuboidSpawner::third_dimension

private

Defines whether the third dimension is enabled.

Definition at line 68 of file SoftBodyCuboidSpawner.h.

type

const int SoftBodyCuboidSpawner::type

private

Defines the type of the particles in the cuboid.

Definition at line 38 of file SoftBodyCuboidSpawner.h.

---

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

• SoftBodyCuboidSpawner.h
• SoftBodyCuboidSpawner.cpp