Description

Definition at line 55 of file IPositionBuilder.h.

Inheritance diagram for RandomPositionBuilder:

Collaboration diagram for RandomPositionBuilder:

Public Member Functions
	RandomPositionBuilder ()

	~RandomPositionBuilder () override

std::vector< std::vector< double > >	generatePositions (double layer_size, double density=0.0) const

Private Member Functions
std::vector< std::vector< double > >	generatePositionsImpl (double layer_size, double density=0.0) const override

double	positionVariance () const override

Constructor & Destructor Documentation

◆ RandomPositionBuilder()

RandomPositionBuilder::RandomPositionBuilder ( )

default

◆ ~RandomPositionBuilder()

RandomPositionBuilder::~RandomPositionBuilder ( )

overridedefault

Member Function Documentation

◆ generatePositions()

std::vector< std::vector< double > > IPositionBuilder::generatePositions	(	double	layer_size,
		double	density = `0.0`
	)		const

inherited

Definition at line 29 of file IPositionBuilder.cpp.

 {
     std::vector<std::vector<double>> positions = generatePositionsImpl(layer_size, density);
     double pos_var = positionVariance();
     if (pos_var > 0.0) {
         // random generator and distribution
         std::random_device rd;  // Will be used to obtain a seed for the random number engine
         std::mt19937 gen(rd()); // Standard mersenne_twister_engine seeded with rd()
         std::normal_distribution<double> dis(0.0, std::sqrt(pos_var));
         for (auto& position : positions) {
             for (auto& coordinate : position)
                 coordinate += dis(gen);
         }
     }
     return positions;
 }

References IPositionBuilder::generatePositionsImpl(), and IPositionBuilder::positionVariance().

Here is the call graph for this function:

◆ generatePositionsImpl()

std::vector< std::vector< double > > RandomPositionBuilder::generatePositionsImpl	(	double	layer_size,
		double	density = `0.0`
	)		const

overrideprivatevirtual

Implements IPositionBuilder.

Definition at line 66 of file IPositionBuilder.cpp.

 {
     std::vector<std::vector<double>> lattice_positions;
     std::vector<double> position;
  
     // to compute total number of particles we use the total particle density
     // and multiply by the area of the layer
     int num_particles = static_cast<int>(density * (2 * layer_size) * (2 * layer_size));
  
     // random generator and distribution
     std::random_device rd;  // Will be used to obtain a seed for the random number engine
     std::mt19937 gen(rd()); // Standard mersenne_twister_engine seeded with rd()
     std::uniform_real_distribution<double> dis(0.0, 1.0);
  
     for (int i = 1; i <= num_particles; ++i) {
         // generate random x and y coordinates
         position.push_back(dis(gen) * 2 * layer_size - layer_size); // x
         position.push_back(dis(gen) * 2 * layer_size - layer_size); // y
  
         lattice_positions.push_back(position);
         position.clear();
     }
     return lattice_positions;
 }

◆ positionVariance()

double RandomPositionBuilder::positionVariance ( ) const