Class to calculate the harmonic force on a particle. More...

#include <HarmonicForce.h>

Inheritance diagram for HarmonicForce:

Collaboration diagram for HarmonicForce:

Public Member Functions
	HarmonicForce (const std::variant< SimulationParams::DirectSumType, SimulationParams::LinkedCellsType > &container_data)
	Constructor for the GlobalDownwardsGravity class. More...

std::array< double, 3UL >	calculateForce (Particle &p) const override
	Calculates the harmonic force on a particle supplied by all its connected neighbors. More...

	operator std::string () const override
	Returns "HarmonicForce" as string. More...

Public Member Functions inherited from SimpleForceSource
virtual	~SimpleForceSource ()=default
	Virtual destructor for correct cleanup of derived classes. More...

Private Attributes
bool	is_finite_container

std::array< double, 3 >	domain_size

Detailed Description

Class to calculate the harmonic force on a particle.

Definition at line 12 of file HarmonicForce.h.

Constructor & Destructor Documentation

◆ HarmonicForce()

HarmonicForce::HarmonicForce ( const std::variant< SimulationParams::DirectSumType, SimulationParams::LinkedCellsType > & container_data )

explicit

Constructor for the GlobalDownwardsGravity class.

Definition at line 6 of file HarmonicForce.cpp.

                                                                                                                              {
     if (std::holds_alternative<SimulationParams::DirectSumType>(container_data)) {
         is_finite_container = false;
     } else {
         is_finite_container = true;
         domain_size = std::get<SimulationParams::LinkedCellsType>(container_data).domain_size;
     }
 }

Member Function Documentation

◆ calculateForce()

std::array< double, 3UL > HarmonicForce::calculateForce ( Particle & p ) const

overridevirtual

Calculates the harmonic force on a particle supplied by all its connected neighbors.

Parameters

p Particle

Returns: std::array<double, 3UL> Force vector

Implements SimpleForceSource.

Definition at line 15 of file HarmonicForce.cpp.

                                                                      {
     auto total_harmonic_force = std::array<double, 3UL>{0, 0, 0};
  
     for (auto& [ptr_diff, l_0, k] : p.getConnectedParticles()) {
         Particle* connected_particle = &p + ptr_diff;
         auto displacement = connected_particle->getX() - p.getX();
  
         if (is_finite_container) {
             for (size_t i = 0; i < displacement.size(); i++) {
                 if (std::abs(displacement[i]) > domain_size[i] * 0.5) {
                     bool is_positive = displacement[i] > 0;
                     if (is_positive) {
                         displacement[i] -= domain_size[i];
                     } else {
                         displacement[i] += domain_size[i];
                     }
                 }
             }
         }
  
         const double dist = ArrayUtils::L2Norm(displacement);
  
         const auto f_harmonic = (k * (dist - l_0) / dist) * displacement;
  
         total_harmonic_force = total_harmonic_force + f_harmonic;
     }
  
     return total_harmonic_force;
 }

◆ operator std::string()

HarmonicForce::operator std::string ( ) const

explicitoverridevirtual

Returns "HarmonicForce" as string.

Implements SimpleForceSource.

Definition at line 45 of file HarmonicForce.cpp.

45 { return "HarmonicForce"; }

Member Data Documentation

◆ domain_size

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

private

Definition at line 14 of file HarmonicForce.h.

◆ is_finite_container

bool HarmonicForce::is_finite_container