Stores information about interactions between two interactable objects; often particles but could be walls etc. By info about interactions one means the overlaps, contact point, forces, torques, relative velocities etc. More...

#include <BaseInteraction.h>

Inheritance diagram for BaseInteraction:

Public Member Functions
	BaseInteraction (BaseInteractable P, BaseInteractable I, unsigned timeStamp)
	A constructor takes the BaseInteractable objects which are interacting (come into contact) and time the interaction starts. More...

	BaseInteraction ()

	BaseInteraction (const BaseInteraction &p)
	Copy constructor. More...

	~BaseInteraction () override
	The destructor. It removes this interactions from the objects that were interacting, and writes the time to a file when needed. More...

virtual void	actionsOnErase ()
	If an interaction needs to do something before it gets erased, add it here. E.g. Liquid bridges rupture at the end of their lifetime, and the liquid bridge volume has to be redistributed. The reason this action is not done in the destructor is that this action should not be taken when erasing ghost interactions. More...

virtual void	computeForce ()
	Virtual function that contains the force law between the two objects interacting. More...

void	read (std::istream &is) override
	Interaction read function, which accepts an std::istream as input. More...

void	write (std::ostream &os) const override
	Interaction print function, which accepts an std::ostream as input. More...

void	writeToFStat (std::ostream &os, Mdouble time) const
	Writes forces data to the FStat file. More...

std::string	getName () const override
	Virtual function which allows interactions to be named. More...

virtual Mdouble	getElasticEnergy () const
	Returns a Mdouble which is the current about of Elastic energy in the interaction. More...

void	setDistance (Mdouble distance)
	Sets the interaction distance between the two interacting objects. More...

void	setNormal (Vec3D normal)
	Sets the normal vector between the two interacting objects. More...

void	setOverlap (Mdouble overlap)
	Set the overlap between the two interacting object. More...

void	setContactPoint (Vec3D contactPoint)
	Set the location of the contact point between the two interacting objects. More...

void	setTimeStamp (unsigned timeStamp)
	Updates the time step of the interacting. Note, time steps used to find completed interactions. More...

void	setSpecies (const BaseSpecies *species)
	Set the Species of the interaction; note this can either be a Species or MixedSpecies. More...

void	setP (BaseInteractable *P)
	Sets the first object involved in the interaction (normally a particle). More...

void	setI (BaseInteractable *I)
	Sets the second object involved in the interaction (often particle or wall). More...

void	importP (BaseInteractable *P)
	Sets the first object involved in the interaction (normally a particle). More...

void	importI (BaseInteractable *I)
	Sets the second object involved in the interaction (often particle or wall). More...

Vec3D	getIP () const

Vec3D	getIC () const

Vec3D	getCP () const

void	setLagrangeMultiplier (Mdouble multiplier)

Mdouble	getLagrangeMultiplier ()

void	setHandler (InteractionHandler *handler)
	Sets the pointer to the interaction hander which is storing this interaction. More...

InteractionHandler *	getHandler () const
	Gets a point to the interaction handlers to which this interaction belongs. More...

const Vec3D &	getForce () const
	Gets the current force (vector) between the two interacting objects. More...

const Vec3D &	getTorque () const
	Gets the current torque (vector) between the two interacting objects. More...

const Vec3D &	getNormal () const
	Gets the normal vector between the two interacting objects. More...

const Vec3D &	getContactPoint () const
	Gets constant reference to contact point (vector). More...

Mdouble	getOverlap () const
	Returns a Mdouble with the current overlap between the two interacting objects. More...

Mdouble	getOverlapVolume () const
	Returns the overlap volume between two interacting objects. More...

Mdouble	getContactRadius () const
	Returns a Mdouble with the current contact between the two interacting objects. More...

void	removeFromHandler ()
	Removes this interaction from its interaction hander. More...

void	copySwitchPointer (const BaseInteractable original, BaseInteractable ghost) const
	This copies the interactions of the original particle and replaces the original with the ghost copy. More...

void	gatherContactStatistics ()

BaseInteractable *	getP ()
	Returns a pointer to first object involved in the interaction (normally a particle). More...

BaseInteractable *	getI ()
	Returns a pointer to the second object involved in the interaction (often a wall or a particle). More...

const BaseInteractable *	getP () const
	Returns a constant pointer to the first object involved in the interaction. More...

const BaseInteractable *	getI () const
	Returns a constant pointer to the second object involved in the interaction. More...

Mdouble	getTimeStamp () const
	Returns an Mdouble which is the time stamp of the interaction. More...

virtual void	integrate (Mdouble timeStep)
	integrates variables of the interaction which need to be integrate e.g. the tangential overlap. More...

virtual Mdouble	getTangentialOverlap () const
	get the length of the current tangential overlap More...

Mdouble	getDistance () const
	Returns an Mdouble which is the norm (length) of distance vector. More...

const Vec3D &	getRelativeVelocity () const
	Returns a constant reference to a vector of relative velocity. More...

Mdouble	getNormalRelativeVelocity () const
	Returns a double which is the norm (length) of the relative velocity vector. More...

Mdouble	getAbsoluteNormalForce () const
	Returns the absolute value of the norm (length) of the Normal force vector. More...

virtual BaseInteraction *	copy () const =0
	Makes a copy of the interaction and returns a pointer to the copy. More...

void	setFStatData (std::fstream &fstat, BaseParticle P, BaseWall I)

void	setFStatData (std::fstream &fstat, BaseParticle P, BaseParticle I)

unsigned int	getMultiContactIdentifier () const

void	setMultiContactIdentifier (unsigned int multiContactIdentifier_)

virtual void	rotateHistory (Matrix3D &rotationMatrix)
	When periodic particles are used, some interactions need certain history properties rotated (e.g. tangential springs). This is the function for that. More...

virtual void	actionsAfterTimeStep ()

virtual unsigned	getNumberOfFieldsVTK () const

virtual std::string	getTypeVTK (unsigned i) const

virtual std::string	getNameVTK (unsigned i) const

virtual std::vector< Mdouble >	getFieldVTK (unsigned i) const

void	addForce (Vec3D force)
	add an force increment to the total force. More...

void	addTorque (Vec3D torque)
	add a torque increment to the total torque. More...

void	setForce (Vec3D force)
	set total force (this is used by the normal force, tangential forces are added use addForce) More...

void	setTorque (Vec3D torque)
	set the total force (this is used by the normal force, tangential torques are added use addTorque) More...

const BaseSpecies *	getBaseSpecies () const
	Return a constant point to BaseSpecies of the interaction. More...

virtual void	createMPIType ()

virtual void *	createMPIInteractionDataArray (unsigned int numberOfInteractions) const

virtual void	deleteMPIInteractionDataArray (void *dataArray)

virtual void	getMPIInteraction (void *historyDataArray, unsigned int index) const
	copies the history interactions into the data array More...

virtual void	getInteractionDetails (void *interactionDataArray, unsigned int index, unsigned int &identificationP, unsigned int &identificationI, bool &isWallInteraction, unsigned &timeStamp)

virtual void	setMPIInteraction (void *interactionDataArray, unsigned int index, bool resetPointers)

void	setBasicMPIInteractionValues (int P, int I, unsigned timeStamp, Vec3D force, Vec3D torque, bool isWallInteraction, bool resetPointers)

void	setIdentificationP (unsigned int identification)

void	setIdentificationI (int identification)

void	setWallInteraction (bool flag)

unsigned int	getIdentificationP ()

int	getIdentificationI ()

bool	isWallInteraction ()

virtual bool	isBonded () const

Public Member Functions inherited from BaseObject
	BaseObject ()=default
	Default constructor. More...

	BaseObject (const BaseObject &p)=default
	Copy constructor, copies all the objects BaseObject contains. More...

virtual	~BaseObject ()=default
	virtual destructor More...

virtual void	moveInHandler (unsigned int index)
	Except that it is virtual, it does the same thing as setIndex() does. More...

void	setIndex (unsigned int index)
	Allows one to assign an index to an object in the handler/container. More...

void	setId (unsigned long id)
	Assigns a unique identifier to each object in the handler (container) which remains constant even after the object is deleted from the container/handler. More...

unsigned int	getIndex () const
	Returns the index of the object in the handler. More...

unsigned int	getId () const
	Returns the unique identifier of any particular object. More...

void	setGroupId (unsigned groupId)

unsigned	getGroupId () const

Protected Member Functions
virtual const Vec3D	getTangentialForce () const

Mdouble	getEffectiveRadius () const
	Returns a Mdouble to the effective radius of the interaction. (Not corrected for the overlap) More...

Mdouble	getEffectiveMass () const
	Returns a Mdouble to the effective radius of the interaction. (Not corrected for the overlap) More...

void	setRelativeVelocity (Vec3D relativeVelocity)
	set the relative velocity of the current of the interactions. More...

void	setNormalRelativeVelocity (Mdouble normalRelativeVelocit)
	set the normal component of the relative velocity. More...

void	setAbsoluteNormalForce (Mdouble absoluteNormalForce)
	the absolute values of the norm (length) of the normal force More...

virtual Mdouble	getElasticEnergyAtEquilibrium (Mdouble adhesiveForce) const

virtual void	reverseHistory ()
	When periodic particles some interaction need certain history properties reversing. This is the function for that. More...

void	writeInteraction (std::ostream &os, bool created) const
	Writes information about a interaction to the interaction file. More...

Detailed Description

Stores information about interactions between two interactable objects; often particles but could be walls etc. By info about interactions one means the overlaps, contact point, forces, torques, relative velocities etc.

This class is completely a MercuryDPM internal and should not be visible to users. It is also an abstract base class. All possible Mercury interactions are derived from this class. It is basically a policy class that defines what an interaction must have in Mercury. Advanced uses that need to add a new interaction must derive it from here and implement the black functions.

Constructor & Destructor Documentation

◆ BaseInteraction() [1/3]

BaseInteraction::BaseInteraction	(	BaseInteractable *	P,
		BaseInteractable *	I,
		unsigned	timeStamp
	)

A constructor takes the BaseInteractable objects which are interacting (come into contact) and time the interaction starts.

This is the constructor which creates a new interactions between two BaseInteractable objects. The timeStamp is time the interactions is created and is used to check if the interations is current or has ended. It adds

Parameters

[in]	P	BaseInteractable pointer which is the first object involved in the interaction normally a particle.
[in]	I	BaseInteractable pointer which is the second object involved in the interaction often a wall or particle.
[in]	timeStamp	Mdouble which is the time the interaction starts.

Bug:: Why is the species set to zero here and not the correct mixed type.

         : BaseObject()
 {
     P_ = P;
     I_ = I;
     normal_.setZero();
     contactPoint_.setNaN();
     overlap_ = 0;
     timeStamp_ = timeStamp;
     species_ = nullptr;
     force_.setZero();
     torque_.setZero();
     if (P->getSpecies()->getHandler()->getDPMBase()->getInteractionFile().getFileType() == FileType::ONE_FILE)
     {
         writeInteraction(P->getSpecies()->getHandler()->getDPMBase()->getInteractionFile().getFstream(), true);
     }
     lagrangeMultiplier_ = 0;
  
 #ifdef DEBUG_CONSTRUCTOR
     std::cout<<"BaseInteraction::BaseInteraction() finished"<<std::endl;
 #endif
 }

References contactPoint_, force_, I, I_, lagrangeMultiplier_, normal_, ONE_FILE, overlap_, Global_Physical_Variables::P, P_, Vec3D::setNaN(), Vec3D::setZero(), species_, timeStamp_, torque_, and writeInteraction().

◆ BaseInteraction() [2/3]

BaseInteraction::BaseInteraction ( )

Todo:: : empty baseInteraction, used in mpi code probably

         : BaseObject()
 {
     P_ = nullptr;
     I_ = nullptr;
     normal_.setZero();
     overlap_ = 0;
     timeStamp_ = 0;
     species_ = nullptr;
     force_.setZero();
     torque_.setZero();
     lagrangeMultiplier_ = 0;
     contactPoint_.setNaN();
 }

References contactPoint_, force_, I_, lagrangeMultiplier_, normal_, overlap_, P_, Vec3D::setNaN(), Vec3D::setZero(), species_, timeStamp_, and torque_.

◆ BaseInteraction() [3/3]

BaseInteraction::BaseInteraction ( const BaseInteraction & p )

Copy constructor.

This an copy constructor for a BaseInteraction.

Parameters

[in] p BaseInteraction

Todo:: why are not all of the member variables copied?

         : BaseObject(p)
 {
     P_ = p.P_;
     I_ = p.I_;
     normal_ = p.normal_;
     overlap_ = p.overlap_;
     force_ = p.force_;
     torque_ = p.torque_;
     species_ = p.species_;
     timeStamp_ = p.timeStamp_;
     lagrangeMultiplier_ = p.lagrangeMultiplier_;
     contactPoint_ = p.contactPoint_;
     
 //    InteractionHandler* handler_;
 //    BaseInteractable* P_;
 //    BaseInteractable* I_;
 //    unsigned int identificationP_;
 //    int identificationI_;
 //    bool isWallInteraction_;
 //    Vec3D contactPoint_;
 //    Vec3D relativeVelocity_;
 //    Mdouble normalRelativeVelocity_;
 //    Mdouble absoluteNormalForce_;
 //    Mdouble distance_;
 //    Vec3D force_;
 //    Vec3D torque_;
 //    unsigned timeStamp_;
 //    Vec3D normal_;
 //    Mdouble overlap_;
 //    const BaseSpecies* species_;
 //    Mdouble lagrangeMultiplier_;
 //    unsigned multiContactIdentifier_;
  
 }

References contactPoint_, force_, I_, lagrangeMultiplier_, normal_, overlap_, p, P_, species_, timeStamp_, and torque_.

◆ ~BaseInteraction()

BaseInteraction::~BaseInteraction ( )

override

The destructor. It removes this interactions from the objects that were interacting, and writes the time to a file when needed.

Destructor for BaseInteraction. Also removes the interaction from the list of interactions for both objects involved in the interaction.

 {
 #if MERCURYDPM_USE_MPI
     if (P_ == nullptr)
     {
         logger(DEBUG,"Destroying a fictitious interaction used in MPI transmissions");
     }
     else
     {
 #endif
     logger.assert_debug(P_ != nullptr, "Trying to destroy an interaction with P_ = nullptr");
     logger.assert_debug(I_ != nullptr, "Trying to destroy an interaction with I_ = nullptr");
     File& interactionFile = getHandler()->getDPMBase()->getInteractionFile();
     if (interactionFile.getFileType() == FileType::ONE_FILE)
     {
         writeInteraction(interactionFile.getFstream(), false);
     }
     
     P_->removeInteraction(this);
     I_->removeInteraction(this);
 #if MERCURYDPM_USE_MPI
     }
 #endif
 }

References DEBUG, BaseHandler< T >::getDPMBase(), File::getFileType(), File::getFstream(), getHandler(), DPMBase::getInteractionFile(), I_, logger, ONE_FILE, P_, BaseInteractable::removeInteraction(), and writeInteraction().

Member Function Documentation

◆ actionsAfterTimeStep()

void BaseInteraction::actionsAfterTimeStep ( )

virtual

Reimplemented in MeltableInteraction, LiquidMigrationWilletInteraction, LiquidMigrationLSInteraction, and Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

802 {

803 }

◆ actionsOnErase()

virtual void BaseInteraction::actionsOnErase ( )

inlinevirtual

If an interaction needs to do something before it gets erased, add it here. E.g. Liquid bridges rupture at the end of their lifetime, and the liquid bridge volume has to be redistributed. The reason this action is not done in the destructor is that this action should not be taken when erasing ghost interactions.

Reimplemented in LiquidMigrationWilletInteraction, and LiquidMigrationLSInteraction.

64 {};

Referenced by InteractionHandler::eraseOldInteractions().

◆ addForce()

void BaseInteraction::addForce ( Vec3D force )

add an force increment to the total force.

add an increment to total force in the interaction. This is used by tangential and non-contact forces (e.g. adhesive forces) as this are 'added' after the normal forces have been computed.

 {
     force_ += force;
 }

References force_.

◆ addTorque()

void BaseInteraction::addTorque ( Vec3D torque )

add a torque increment to the total torque.

add an increment to total torque in the interaction. This is used by tangential and non-contact forces (e.g. adhesive forces) as this are 'added' after the normal forces have been computed.

 {
     torque_ += torque;
 }

References torque_.

Referenced by FrictionInteraction::computeFrictionForce(), and MindlinRollingTorsionInteraction::computeFrictionForce().

◆ computeForce()

void BaseInteraction::computeForce ( )

virtual

Virtual function that contains the force law between the two objects interacting.

The children of this class will implement this function; however, it is blank. This function will do the actually force calculation for this interaction. Note, it is not virtual as it is not called from within this class.

Reimplemented in Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

676 {}

◆ copy()

virtual BaseInteraction* BaseInteraction::copy ( ) const

pure virtual

Makes a copy of the interaction and returns a pointer to the copy.

Implemented in Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

Referenced by copySwitchPointer().

◆ copySwitchPointer()

void BaseInteraction::copySwitchPointer	(	const BaseInteractable *	original,
		BaseInteractable *	ghost
	)		const

This copies the interactions of the original particle and replaces the original with the ghost copy.

This functions copies the interactions of a real original particle. It first works out which of P and I is not the original particle. Then it create a new interactions between the new ghost copy and which every object is not the original particle from the P and I of the interaction. Note, at the end the ghost will be I in the new interaction and original item being interacted with will be P.

Todo:: Can this be simpler if we replace the particle with the ghost.

Parameters

[in]	original	BaseInteractable* to the original particles who periodic image is being created from.
[in]	ghost	BaseInteractble* to the new ghost (periodic partcles) that has just been created.

 {
     //Copy the interaction of ghost
     BaseInteraction* C = copy();
     //Finds out which of P and I is that the particle from whom the ghost is begin created.
     //The object being interacted with is set to P
     if (C->getP() == original)
     {
         //Reverse some force history
         C->reverseHistory();
         //Set the P to the original particle
         C->P_ = C->getI();
     }
     //The new ghost particle is set to I in the interaction.
     C->I_ = ghost;
     
     //Add the the interaction to both original and the ghost
     handler_->addObject(C);
 }

References InteractionHandler::addObject(), copy(), and handler_.

Referenced by BaseInteractable::copyInteractionsForPeriodicParticles().

◆ createMPIInteractionDataArray()

void * BaseInteraction::createMPIInteractionDataArray ( unsigned int numberOfInteractions ) const

virtual

Reimplemented in Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

 {
     logger(ERROR, "BaseInteraction::createMPIInteractionDataArray should never be called");
     return nullptr;
 }

References ERROR, and logger.

Referenced by InteractionHandler::createMPIInteractionDataArray().

◆ createMPIType()

void BaseInteraction::createMPIType ( )

virtual

Reimplemented in Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

883 {

884 }

Referenced by MPIContainer::initialiseMercuryMPITypes().

◆ deleteMPIInteractionDataArray()

void BaseInteraction::deleteMPIInteractionDataArray ( void * dataArray )

virtual

Reimplemented in Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

 {
     logger(WARN, "Why on earth is this function called?");
 }

References logger, and WARN.

Referenced by InteractionHandler::deleteMPIInteractionDataArray().

◆ gatherContactStatistics()

void BaseInteraction::gatherContactStatistics ( )

Todo:: Thomas please document this; as this is the area you are currently rewriting.

Todo:: Thomas please document.

Todo:: TW centre is used just for backward compatibility; replace centre by contact law; we also have to correct it in StatisticsVector::gatherContactStatistics. There also seems to be an issue with the normal being defined differently for walls

 {
     auto* IParticle = dynamic_cast<BaseParticle*>(I_);
     auto* PParticle = static_cast<BaseParticle*>(P_);
     
     Vec3D tangentialForce = getTangentialForce();
     Mdouble tangentialOverlap = getTangentialOverlap();
     
     Mdouble scalarNormalForce = Vec3D::dot(force_, getNormal());
     Mdouble scalarTangentialForce = tangentialForce.getLength();
     Vec3D tangential;
     if (scalarTangentialForce != 0.0)
         tangential = tangentialForce / scalarTangentialForce;
     else
         tangential = Vec3D(0.0, 0.0, 0.0);
     
     Vec3D centre;
     if (IParticle != nullptr)
         centre = getP()->getPosition() - normal_ * (PParticle->getRadius() + IParticle->getRadius() - overlap_) / 2.0;
     else
         centre = getP()->getPosition() - normal_ * (PParticle->getRadius() - overlap_);
     
     if (!PParticle->isFixed())
     {
         getHandler()->getDPMBase()->gatherContactStatistics(
                 P_->getIndex(),
                 static_cast<int>((IParticle == nullptr ? (-I_->getIndex() - 1) : I_->getIndex())),
                 centre,
                 getOverlap(),
                 tangentialOverlap,
                 scalarNormalForce,
                 scalarTangentialForce,
                 (IParticle == nullptr ? -normal_ : normal_),
                 (IParticle == nullptr ? -tangential : tangential));
     }
     if (IParticle != nullptr && !IParticle->isFixed() && IParticle->getPeriodicFromParticle() == nullptr)
     {
         getHandler()->getDPMBase()->gatherContactStatistics(
                 I_->getIndex(),
                 static_cast<int>(P_->getIndex()),
                 centre,
                 getOverlap(),
                 tangentialOverlap,
                 scalarNormalForce,
                 scalarTangentialForce,
                 -normal_,
                 -tangential);
         
     }
 }

References Vec3D::dot(), force_, DPMBase::gatherContactStatistics(), BaseHandler< T >::getDPMBase(), getHandler(), BaseObject::getIndex(), Vec3D::getLength(), getNormal(), getOverlap(), getP(), BaseInteractable::getPosition(), getTangentialForce(), getTangentialOverlap(), I_, normal_, overlap_, and P_.

◆ getAbsoluteNormalForce()

Mdouble BaseInteraction::getAbsoluteNormalForce ( ) const

Returns the absolute value of the norm (length) of the Normal force vector.

Returns the absolute normal force. This is the magnitude of the normal force.

Todo:: Ant: Check this comment.

Returns: Mdouble that contains the absolute norm (length) of the normal force.

 {
     return absoluteNormalForce_;
 }

References absoluteNormalForce_.

Referenced by FrictionInteraction::computeFrictionForce(), MindlinInteraction::computeFrictionForce(), MindlinRollingTorsionInteraction::computeFrictionForce(), SlidingFrictionInteraction::computeFrictionForce(), and MindlinInteraction::updateK_t().

◆ getBaseSpecies()

const BaseSpecies * BaseInteraction::getBaseSpecies ( ) const

Return a constant point to BaseSpecies of the interaction.

Returns a BaseSpecies pointer to the current species. Note, this will be either a Species or a MixedSpecies done of which are derived from BaseSpecies.

Returns: A BaseSpecies pointer to the species associated with this interaction.

 {
     return species_;
 }

References species_.

◆ getContactPoint()

const Vec3D& BaseInteraction::getContactPoint ( ) const

inline

Gets constant reference to contact point (vector).

Returns a reference to a Vec3D which contains the current value of the contact point for the particles in interaction. Normally, does not change about the interaction is created.

Returns: A reference to a Vec3D containing the contact point.

214 { return contactPoint_; }

References contactPoint_.

Referenced by ContactDetectionNormalSpheresTest::actionsAfterTimeStep(), ContactDetectionRotatedSpheresTest::actionsAfterTimeStep(), HertzianBSHPViscoelasticInteraction::computeNormalForce(), HertzianViscoelasticInteraction::computeNormalForce(), LinearPlasticViscoelasticInteraction::computeNormalForce(), LinearViscoelasticInteraction::computeNormalForce(), MeltableInteraction::computeNormalForce(), SinterInteraction::computeNormalForce(), SinterLinInteraction::computeNormalForce(), SPHInteraction::computeNormalForce(), HertzianSinterInteraction::computeSinterForce(), getCP(), getEffectiveMass(), getEffectiveRadius(), getIC(), main(), ParticleInclusion::printTime(), and writeToFStat().

◆ getContactRadius()

Mdouble BaseInteraction::getContactRadius ( ) const

Returns a Mdouble with the current contact between the two interacting objects.

Returns a Mdouble to the current overlap for the objects involved in the interaction.

Returns: Mdouble which is the value of the overlap.

 {
     return getOverlap() < 0.0 ? 0.0 : sqrt(2.0 * getEffectiveRadius() * getOverlap());
 }

References getEffectiveRadius(), getOverlap(), and sqrt().

Referenced by SinterLinInteraction::computeNormalForce().

◆ getCP()

Vec3D BaseInteraction::getCP ( ) const

returns the vector from C to P. Note, this cannot simply computed as P-I because I is possibly a ghost particle and might be shifted.

 {
     //works even in periodic systems becuase contact point is defined on the P-side
     return getP()->getPosition() - getContactPoint();
 }

References getContactPoint(), getP(), and BaseInteractable::getPosition().

◆ getDistance()

Mdouble BaseInteraction::getDistance ( ) const

Returns an Mdouble which is the norm (length) of distance vector.

 {
     return distance_;
 }

References distance_.

Referenced by MeltableInteraction::computeNormalForce(), getIC(), getIP(), and main().

◆ getEffectiveMass()

Mdouble BaseInteraction::getEffectiveMass ( ) const

protected

Returns a Mdouble to the effective radius of the interaction. (Not corrected for the overlap)

Computes the effective mass of the particles in the interaction. This is used by many of the later interaction models. This functions assumes P is the particle and I is either a particle or a wall. Effective Radius = \(R_I*R_P/(R_I+R_P)\) See also BaseInteraction::getEffectiveCorrectedRadius()

Returns: A Mdouble which is the effective radius of the particles.

 {
     Mdouble invEffectiveMass = getP()->getInvMass() + getI()->getInvMass();
     logger.assert_debug(invEffectiveMass > 0,
                         "getEffectiveMass(): interaction % at % has infinite effective mass", getId(),
                         getContactPoint());
     return 1.0 / invEffectiveMass;
 }

References getContactPoint(), getI(), BaseObject::getId(), BaseInteractable::getInvMass(), getP(), and logger.

Referenced by FrictionInteraction::computeFrictionForce(), MindlinInteraction::computeFrictionForce(), SlidingFrictionInteraction::computeFrictionForce(), HertzianViscoelasticInteraction::computeNormalForce(), LinearPlasticViscoelasticInteraction::computeNormalForce(), LinearViscoelasticInteraction::computeNormalForce(), MeltableInteraction::computeNormalForce(), FrictionInteraction::getElasticEnergy(), SlidingFrictionInteraction::getElasticEnergy(), LinearPlasticViscoelasticInteraction::getElasticEnergy(), LinearViscoelasticInteraction::getElasticEnergy(), and SinterLinInteraction::getElasticEnergy().

◆ getEffectiveRadius()

Mdouble BaseInteraction::getEffectiveRadius ( ) const

protected

Returns a Mdouble to the effective radius of the interaction. (Not corrected for the overlap)

Computes the effective radius of the two particles in the interaction. This is used by many of the later interaction models. This functions assumes P is the particle and I is either a particle or a wall. Effective Radius = \(R_I*R_P/(R_I+R_P)\) See also BaseInteraction::getEffectiveCorrectedRadius()

Returns: A Mdouble which is the effective radius of the particles.

 {
     Mdouble invEffectiveRadius = getP()->getCurvature(contactPoint_) + getI()->getCurvature(contactPoint_);
     logger.assert_debug(invEffectiveRadius > 0,
                         "getEffectiveRadius(): interaction % at % has infinite effective radius", getId(),
                         getContactPoint());
     return 1.0 / invEffectiveRadius;
 }

References contactPoint_, getContactPoint(), BaseInteractable::getCurvature(), getI(), BaseObject::getId(), getP(), and logger.

◆ getElasticEnergy()

Mdouble BaseInteraction::getElasticEnergy ( ) const

virtual

Returns a Mdouble which is the current about of Elastic energy in the interaction.

The children of this class will implement this function; however, it is blank. This function will contain the calculation for th elastic energy. Note, it is not virtual as it is not called from within this class.

Reimplemented in SPHInteraction, SinterLinInteraction, SinterInteraction, MeltableInteraction, LinearViscoelasticInteraction, LinearPlasticViscoelasticInteraction, HertzianViscoelasticInteraction, HertzianSinterInteraction, SlidingFrictionInteraction, MindlinRollingTorsionInteraction, MindlinInteraction, FrictionInteraction, EmptyFrictionInteraction, SolidifyingLiquidMigrationWilletInteraction, ReversibleAdhesiveInteraction, RegimeSinterInteraction, ParhamiMcMeekingSinterInteraction, LiquidMigrationWilletInteraction, LiquidMigrationLSInteraction, LiquidBridgeWilletInteraction, LiquidBridgeClassicalWilletInteraction, LiquidBridgeBagheriInteraction, JKRAdhesiveInteraction, IrreversibleAdhesiveInteraction, EmptyAdhesiveInteraction, ChargedBondedInteraction, BondedInteraction, and Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

 {
     return 0.0;
 }

◆ getElasticEnergyAtEquilibrium()

virtual Mdouble BaseInteraction::getElasticEnergyAtEquilibrium ( Mdouble adhesiveForce ) const

inlineprotectedvirtual

Reimplemented in SPHInteraction, LinearViscoelasticInteraction, HertzianViscoelasticInteraction, and Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

414 { return 0; }

Referenced by ChargedBondedInteraction::getElasticEnergy().

◆ getFieldVTK()

std::vector< Mdouble > BaseInteraction::getFieldVTK ( unsigned i ) const

virtual

Reimplemented in SinterInteraction, SolidifyingLiquidMigrationWilletInteraction, LiquidMigrationWilletInteraction, and LiquidMigrationLSInteraction.

 {
     return std::vector<Mdouble>();
 }

◆ getForce()

const Vec3D& BaseInteraction::getForce ( ) const

inline

Gets the current force (vector) between the two interacting objects.

Return a reference to a Vec3D which contains the current value of the force associated with this interaction.

Returns: A reference to a Vec3D containing the total force.

190 { return force_; }

References force_.

Referenced by MercuryProblem::actionsAfterTimeStep(), BondedInteraction::bondInPlace(), SolidifyingLiquidMigrationWilletInteraction::bondInPlace(), MPIInteraction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >::copyFromInteraction(), and SingleParticle< SpeciesType >::writeEneTimeStep().

◆ getHandler()

InteractionHandler * BaseInteraction::getHandler ( ) const

Gets a point to the interaction handlers to which this interaction belongs.

 {
     return handler_;
 }

References handler_.

Referenced by MeltableInteraction::actionsAfterTimeStep(), FrictionInteraction::computeFrictionForce(), MindlinInteraction::computeFrictionForce(), MindlinRollingTorsionInteraction::computeFrictionForce(), SinterInteraction::computeNormalForce(), SinterLinInteraction::computeNormalForce(), HertzianSinterInteraction::computeSinterForce(), SlidingFrictionInteraction::computeSlidingSpring(), gatherContactStatistics(), and ~BaseInteraction().

◆ getI() [1/2]

BaseInteractable* BaseInteraction::getI ( )

inline

Returns a pointer to the second object involved in the interaction (often a wall or a particle).

Returns a pointer to the second object in the interaction; often a particle or a wall i.e. a general interactale hence I.

Returns: Pointer to BaseInteraction often a particle or a wall.

     {
         logger.assert_debug(I_ != nullptr, "Second particle in interaction % is nullptr", getId());
         return I_;
     }

References BaseObject::getId(), I_, and logger.

Referenced by MeltableInteraction::actionsAfterTimeStep(), ChargedBondedInteraction::computeAdhesionForce(), FrictionInteraction::computeFrictionForce(), MindlinRollingTorsionInteraction::computeFrictionForce(), HertzianBSHPViscoelasticInteraction::computeNormalForce(), HertzianViscoelasticInteraction::computeNormalForce(), LinearPlasticViscoelasticInteraction::computeNormalForce(), LinearViscoelasticInteraction::computeNormalForce(), MeltableInteraction::computeNormalForce(), SinterInteraction::computeNormalForce(), SinterLinInteraction::computeNormalForce(), SPHInteraction::computeNormalForce(), HertzianSinterInteraction::computeSinterForce(), MPIInteraction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >::copyFromInteraction(), LiquidMigrationLSInteraction::form(), LiquidMigrationWilletInteraction::form(), getEffectiveMass(), getEffectiveRadius(), ChargedBondedInteraction::getElasticEnergy(), MeltableInteraction::getOverlapGrowthRate(), getOverlapVolume(), InteractionHandler::removeObjectKeepingPeriodics(), LiquidMigrationLSInteraction::rupture(), and LiquidMigrationWilletInteraction::rupture().

◆ getI() [2/2]

const BaseInteractable* BaseInteraction::getI ( ) const

inline

Returns a constant pointer to the second object involved in the interaction.

Returns a constant pointer to the second object in the interaction; often a particle or a wall i.e. a general interactale hence I.

Returns: Constant pointer to BaseInteraction often a particle or a wall.

     {
         logger.assert_debug(I_ != nullptr, "Second particle in interaction % is nullptr", getId());
         return I_;
     }

References BaseObject::getId(), I_, and logger.

◆ getIC()

Vec3D BaseInteraction::getIC ( ) const

returns the vector from I to C. Note, this cannot simply computed as P-I because I is possibly a ghost particle and might be shifted.

Todo:: getDistance is not set in postprocessing

 {
     return getNormal() * getDistance() + getContactPoint() - getP()->getPosition();
 }

References getContactPoint(), getDistance(), getNormal(), getP(), and BaseInteractable::getPosition().

◆ getIdentificationI()

int BaseInteraction::getIdentificationI ( )

 {
     return identificationI_;
 }

References identificationI_.

◆ getIdentificationP()

unsigned int BaseInteraction::getIdentificationP ( )

 {
     return identificationP_;
 }

References identificationP_.

◆ getInteractionDetails()

void BaseInteraction::getInteractionDetails	(	void *	interactionDataArray,
		unsigned int	index,
		unsigned int &	identificationP,
		unsigned int &	identificationI,
		bool &	isWallInteraction,
		unsigned &	timeStamp
	)

virtual

Reimplemented in Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

 {
     logger(ERROR, "Something went wrong, this function should not be called");
 }

References ERROR, and logger.

Referenced by InteractionHandler::getInteractionDetails().

◆ getIP()

Vec3D BaseInteraction::getIP ( ) const

returns the vector from I to P. Note, this cannot simply computed as P-I because I is possibly a ghost particle and might be shifted.

 {
     //needs to be done by normal and distance or it fails in periodic systems
     //return getP()->getPosition() - getI()->getPosition();
     return getNormal() * getDistance();
 }

References getDistance(), and getNormal().

◆ getLagrangeMultiplier()

Mdouble BaseInteraction::getLagrangeMultiplier ( )

inline

     {
         return lagrangeMultiplier_;
     }

References lagrangeMultiplier_.

◆ getMPIInteraction()

void BaseInteraction::getMPIInteraction	(	void *	historyDataArray,
		unsigned int	index
	)		const

virtual

copies the history interactions into the data array

Reimplemented in Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

887 {

888 }

◆ getMultiContactIdentifier()

unsigned int BaseInteraction::getMultiContactIdentifier ( ) const

 {
     return multiContactIdentifier_;
 }

References multiContactIdentifier_.

◆ getName()

std::string BaseInteraction::getName ( ) const

overridevirtual

Virtual function which allows interactions to be named.

Functions which returns the name of the Interaction here is called BaseInteraction; but, it should be later overridden by the actual interaction classes.

Implements BaseObject.

Reimplemented in Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

 {
     return "BaseInteraction";
 }

Referenced by write().

◆ getNameVTK()

std::string BaseInteraction::getNameVTK ( unsigned i ) const

virtual

Reimplemented in SinterInteraction, SolidifyingLiquidMigrationWilletInteraction, LiquidMigrationWilletInteraction, and LiquidMigrationLSInteraction.

 {
     return "";
 }

Referenced by InteractionVTKWriter::writeVTKPointData().

◆ getNormal()

const Vec3D& BaseInteraction::getNormal ( ) const

inline

Gets the normal vector between the two interacting objects.

Returns a reference to a Vec3D which contains the current value of the normal associated with the interactions.

Returns: A reference to a Vec3D containing the current normal.

206 { return normal_; }

References normal_.

◆ getNormalRelativeVelocity()

Mdouble BaseInteraction::getNormalRelativeVelocity ( ) const

Returns a double which is the norm (length) of the relative velocity vector.

Returns the norm (length) of the relative normal velocity. Note, this can be negative or positive it is not a speed.

Todo:: Ant: Check this comment.

Returns: Mdouble that contains the norm (length) of the relative velocity.

 {
     return normalRelativeVelocity_;
 }

References normalRelativeVelocity_.

◆ getNumberOfFieldsVTK()

unsigned BaseInteraction::getNumberOfFieldsVTK ( ) const

virtual

Reimplemented in SinterInteraction, SolidifyingLiquidMigrationWilletInteraction, LiquidMigrationWilletInteraction, and LiquidMigrationLSInteraction.

 {
     return 0;
 }

◆ getOverlap()

Mdouble BaseInteraction::getOverlap ( ) const

inline

Returns a Mdouble with the current overlap between the two interacting objects.

220 { return overlap_; }

References overlap_.

◆ getOverlapVolume()

Mdouble BaseInteraction::getOverlapVolume ( ) const

Returns the overlap volume between two interacting objects.

Warning: Only works for spherical particles. Not implemented for walls. Returns nonsense when one particle is fully inside the other.

Converts the linear overlap in the correct volume overlap i.e. this is the spherical cap approximation Please see additional docs directory for the calculation of this and the mathematica file with the calculation in

Returns: The volume of the overlap between the two objects in the interaction

 {
     //logger(WARN,"This function is only tested for spheres and (may) give the wrong answer for other objects");
     //First get overlap and radii of each object
     Mdouble delta = getOverlap();
     Mdouble curvatureParticle = getP()->getCurvature(getP()->getPosition());
     Mdouble curvatureInteractable = getI()->getCurvature(getI()->getPosition());
     
     if (curvatureInteractable == 0)
     {
         logger(WARN, "This function is not implemented for walls yet and will return 0");
         return 0;
     }
     else
     {
         Mdouble r1 = 1.0 / curvatureInteractable;
         Mdouble r2 = 1.0 / curvatureParticle;
         
         if (delta > 2.0 * r1 || delta > 2.0 * r2)
             logger(WARN,
                    "Warning in BaseInteraction::getOverlapVolume: One of the particles is fully inside the other. The calculations are undefined for this case and will return nonsensical values.");
         
         //Eq (2.1) - see doc
 //        logger(WARN,"Radius of first object % and second object %",r1,r2);
         Mdouble t1 = (r2 - delta / 2.0) / (r1 + r2 - delta) * delta;
         //Eq (2.2) - see doc
         Mdouble t2 = (r1 - delta / 2.0) / (r1 + r2 - delta) * delta;
         
         //Eq (2.3) - see doc
         Mdouble V = constants::pi * (
                 std::pow(t1, 2.0) * r1
                 - std::pow(t1, 3.0) / 3.0
                 + std::pow(t2, 2.0) * r2
                 - std::pow(t2, 3.0) / 3.0
         );
         
         return V;
     }
     
     return 0;
 }

References MultiOpt::delta, BaseInteractable::getCurvature(), getI(), getOverlap(), getP(), logger, constants::pi, Eigen::bfloat16_impl::pow(), V, and WARN.

Referenced by ExtremeOverlapVolumeUnitTest::setupInitialConditions().

◆ getP() [1/2]

BaseInteractable* BaseInteraction::getP ( )

inline

Returns a pointer to first object involved in the interaction (normally a particle).

Returns a pointer to the first object in the interactions; normally the particle.

Returns: Pointer to BaseInteraction but normally will be a BaseParticle.

     {
         logger.assert_debug(P_ != nullptr, "First particle in interaction % is nullptr", getId());
         return P_;
     }

References BaseObject::getId(), logger, and P_.

Referenced by MeltableInteraction::actionsAfterTimeStep(), ChargedBondedInteraction::computeAdhesionForce(), FrictionInteraction::computeFrictionForce(), MindlinRollingTorsionInteraction::computeFrictionForce(), HertzianBSHPViscoelasticInteraction::computeNormalForce(), HertzianViscoelasticInteraction::computeNormalForce(), LinearPlasticViscoelasticInteraction::computeNormalForce(), LinearViscoelasticInteraction::computeNormalForce(), MeltableInteraction::computeNormalForce(), SinterInteraction::computeNormalForce(), SinterLinInteraction::computeNormalForce(), SPHInteraction::computeNormalForce(), HertzianSinterInteraction::computeSinterForce(), MPIInteraction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >::copyFromInteraction(), LiquidMigrationLSInteraction::form(), LiquidMigrationWilletInteraction::form(), gatherContactStatistics(), getCP(), getEffectiveMass(), getEffectiveRadius(), ChargedBondedInteraction::getElasticEnergy(), getIC(), MeltableInteraction::getOverlapGrowthRate(), getOverlapVolume(), InteractionHandler::removeObjectKeepingPeriodics(), LiquidMigrationLSInteraction::rupture(), and LiquidMigrationWilletInteraction::rupture().

◆ getP() [2/2]

const BaseInteractable* BaseInteraction::getP ( ) const

inline

Returns a constant pointer to the first object involved in the interaction.

Returns a constant pointer to the first object in the interactions; normally the particle. Why implement const and non-const setters and getters? See https://www.gamedev.net/forums/topic/550112-c-non-const-getter-in-terms-of-const-getter/

Returns: Constant pointer to BaseInteraction but normally will be a BaseParticle.

     {
         logger.assert_debug(P_ != nullptr, "First particle in interaction % is nullptr", getId());
         return P_;
     }

References BaseObject::getId(), logger, and P_.

◆ getRelativeVelocity()

const Vec3D & BaseInteraction::getRelativeVelocity ( ) const

Returns a constant reference to a vector of relative velocity.

Returns the relative velocity between the two interactable objects involved in the interaction.

Returns: A reference to Vec3D that contains the relative velocity.

 {
     return relativeVelocity_;
 }

References relativeVelocity_.

Referenced by LiquidMigrationLSInteraction::computeAdhesionForce(), LiquidMigrationWilletViscousInteraction::computeAdhesionForce(), ParhamiMcMeekingSinterInteraction::computeAdhesionForce(), MindlinInteraction::computeFrictionForce(), SlidingFrictionInteraction::computeFrictionForce(), HertzianBSHPViscoelasticInteraction::computeNormalForce(), HertzianViscoelasticInteraction::computeNormalForce(), LinearPlasticViscoelasticInteraction::computeNormalForce(), LinearViscoelasticInteraction::computeNormalForce(), MeltableInteraction::computeNormalForce(), SinterInteraction::computeNormalForce(), SinterLinInteraction::computeNormalForce(), SPHInteraction::computeNormalForce(), and HertzianSinterInteraction::computeSinterForce().

◆ getTangentialForce()

const Vec3D BaseInteraction::getTangentialForce ( ) const

protectedvirtual

Returns a constant vector to the Tangential Force

Returns the vector that is the tangential force Note, at this level there cannot be a tangential force therefore by default it return the zero vector. This function will be overridden by interactions that have tangential components.

Returns: Vec3D that contains the current tangential force of the interaction.

Reimplemented in SlidingFrictionInteraction, MindlinInteraction, and EmptyFrictionInteraction.

 {
     return Vec3D(0.0, 0.0, 0.0);
 }

Referenced by gatherContactStatistics(), and writeToFStat().

◆ getTangentialOverlap()

Mdouble BaseInteraction::getTangentialOverlap ( ) const

virtual

get the length of the current tangential overlap

Returns tangential overlap. Note, at this level there cannot be a tangential overlap hence by default it returns 0. This function will be overridden by interactions that have tangential components.

Returns: Positive Mdouble that is the tangential overlap.

Reimplemented in SlidingFrictionInteraction, MindlinInteraction, and EmptyFrictionInteraction.

 {
     return 0;
 }

Referenced by gatherContactStatistics(), and writeToFStat().

◆ getTimeStamp()

Mdouble BaseInteraction::getTimeStamp ( ) const

inline

Returns an Mdouble which is the time stamp of the interaction.

Returns the current time stamp of interaction. This should be the last time the interaction was active and used to find the end of the interaction.

Returns: Mdouble which is the last time the interaction was active.

299 { return timeStamp_; }

References timeStamp_.

Referenced by MPIInteraction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >::copyFromInteraction(), InteractionHandler::eraseOldInteractions(), and InteractionHandler::removeObjectKeepingPeriodics().

◆ getTorque()

const Vec3D& BaseInteraction::getTorque ( ) const

inline

Gets the current torque (vector) between the two interacting objects.

Return a reference to a Vec3D which contains the current value of the torque associated with the interaction.

Returns: A reference to a Vec3D containing the total torque.

198 { return torque_; }

References torque_.

Referenced by MPIInteraction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >::copyFromInteraction().

◆ getTypeVTK()

std::string BaseInteraction::getTypeVTK ( unsigned i ) const

virtual

Reimplemented in SinterInteraction, SolidifyingLiquidMigrationWilletInteraction, LiquidMigrationWilletInteraction, and LiquidMigrationLSInteraction.

 {
     return "";
 }

Referenced by InteractionVTKWriter::writeVTKPointData().

◆ importI()

void BaseInteraction::importI ( BaseInteractable * I )

Sets the second object involved in the interaction (often particle or wall).

Changes the second object involved in the interaction. This function differs from BaseInteraction::setI(BaseInteractable* I) because no interactable is removed: this is needed in DPMBase::importParticlesAs as in it there's no iteractable to remove and using BaseInteraction::setI(BaseInteractable* I) would led to an output printing overloaded with warnings.

Parameters

[in] I BaseInteractable* The particle involved in the interaction.

 {
     I_->removeInteraction(this);
     I_ = I;
     I_->addInteraction(this);
     identificationI_ = I_->getId();
 }

References BaseInteractable::addInteraction(), BaseObject::getId(), I, I_, identificationI_, and BaseInteractable::removeInteraction().

◆ importP()

void BaseInteraction::importP ( BaseInteractable * P )

Sets the first object involved in the interaction (normally a particle).

Set the first object involved in the interaction. This function differs from BaseInteraction::setP(BaseInteractable* P) because no interactable is removed: this is needed in DPMBase::importParticlesAs as in it there's no iteractable to remove and using BaseInteraction::setP(BaseInteractable* P) would led to an output printing overloaded with warnings.

Parameters

[in] P BaseInteractable* The particle involved in the interaction.

 {
     P_->removeInteraction(this);
     P_ = P;
     P_->addInteraction(this);
     identificationP_ = P_->getId();
 }

References BaseInteractable::addInteraction(), BaseObject::getId(), identificationP_, Global_Physical_Variables::P, P_, and BaseInteractable::removeInteraction().

◆ integrate()

void BaseInteraction::integrate ( Mdouble timeStep UNUSED )

virtual

integrates variables of the interaction which need to be integrate e.g. the tangential overlap.

Various variables in the force law need to be integrated. This is the place where this code goes. Note, it is empty at this point; it can be overriden in subclasses. For usage, see e.g. MindlinInteraction.cc.

Parameters

[in] timeStep The time-step dt.

Reimplemented in SlidingFrictionInteraction, MindlinRollingTorsionInteraction, MindlinInteraction, FrictionInteraction, EmptyFrictionInteraction, and Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

 {
  
 }

◆ isBonded()

virtual bool BaseInteraction::isBonded ( ) const

inlinevirtual

Reimplemented in ChargedBondedInteraction, and BondedInteraction.

472 {return false;}

Referenced by writeToFStat().

◆ isWallInteraction()

bool BaseInteraction::isWallInteraction ( )

 {
     return isWallInteraction_;
 }

References isWallInteraction_.

◆ read()

void BaseInteraction::read ( std::istream & is )

overridevirtual

Interaction read function, which accepts an std::istream as input.

BaseInteaction read functions. Reads in all the information about an interaction. Note, this can be from any istream but would normally be a file See also BaseInteaction::write

Parameters

[in] is std::istream to which the information is read from.

Implements BaseObject.

Reimplemented in SPHInteraction, SinterLinInteraction, SinterInteraction, MeltableInteraction, LinearViscoelasticInteraction, LinearPlasticViscoelasticInteraction, HertzianViscoelasticInteraction, HertzianSinterInteraction, HertzianBSHPViscoelasticInteraction, SlidingFrictionInteraction, MindlinRollingTorsionInteraction, MindlinInteraction, FrictionInteraction, EmptyFrictionInteraction, and Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

 {
     //the rest gets read by the interaction handler
     std::string dummy;
     helpers::readOptionalVariable(is, "contactPoint", contactPoint_);
     helpers::readOptionalVariable(is, "normal", normal_);
     helpers::readOptionalVariable(is, "distance", distance_);
     helpers::readOptionalVariable(is, "overlap", overlap_);
     is >> dummy >> force_;
     is >> dummy >> torque_;
 }

References contactPoint_, distance_, force_, normal_, overlap_, helpers::readOptionalVariable(), oomph::Global_string_for_annotation::string(), and torque_.

Referenced by HertzianSinterInteraction::read(), HertzianViscoelasticInteraction::read(), LinearPlasticViscoelasticInteraction::read(), LinearViscoelasticInteraction::read(), MeltableInteraction::read(), SinterInteraction::read(), SinterLinInteraction::read(), and SPHInteraction::read().

◆ removeFromHandler()

void BaseInteraction::removeFromHandler ( )

Removes this interaction from its interaction hander.

Removes the interaction from its InteractionHandler. Does no other cleaning up as it does not remove it from the particles.

 {
     handler_->removeObject(getIndex());
 }

References BaseObject::getIndex(), handler_, and BaseHandler< T >::removeObject().

◆ reverseHistory()

void BaseInteraction::reverseHistory ( )

protectedvirtual

When periodic particles some interaction need certain history properties reversing. This is the function for that.

The children of this class will implement this function; however, it is blank. This function will contain code that changes some history information if a copy changes the P <-> I order; as can happen in creating a periodic particle. See also PeriodicBoundary::createPeriodicParticles and BaseInteraction::copySwitchPointer Note, it is not virtual as it is not called from within this class.

Reimplemented in SlidingFrictionInteraction, MindlinRollingTorsionInteraction, MindlinInteraction, FrictionInteraction, and Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

700 {

701 }

◆ rotateHistory()

void BaseInteraction::rotateHistory ( Matrix3D & rotationMatrix )

virtual

When periodic particles are used, some interactions need certain history properties rotated (e.g. tangential springs). This is the function for that.

Todo:: some of these might be unneccesary

Reimplemented in SlidingFrictionInteraction, MindlinRollingTorsionInteraction, MindlinInteraction, FrictionInteraction, and Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

 {
     contactPoint_ = rotationMatrix * contactPoint_;
     relativeVelocity_ = rotationMatrix * relativeVelocity_;
     force_ = rotationMatrix * force_;
     torque_ = rotationMatrix * torque_;
     normal_ = rotationMatrix * normal_;
 }

References contactPoint_, force_, normal_, relativeVelocity_, and torque_.

◆ setAbsoluteNormalForce()

void BaseInteraction::setAbsoluteNormalForce ( Mdouble absoluteNormalForce )

protected

the absolute values of the norm (length) of the normal force

set absolute normal force.

Parameters

[in] absoluteNormalForce Mdouble contain the value of the absolute normal force.

 {
     absoluteNormalForce_ = absoluteNormalForce;
 }

References absoluteNormalForce_.

Referenced by HertzianBSHPViscoelasticInteraction::computeNormalForce(), HertzianViscoelasticInteraction::computeNormalForce(), LinearPlasticViscoelasticInteraction::computeNormalForce(), LinearViscoelasticInteraction::computeNormalForce(), MeltableInteraction::computeNormalForce(), SinterInteraction::computeNormalForce(), SinterLinInteraction::computeNormalForce(), SPHInteraction::computeNormalForce(), and HertzianSinterInteraction::computeSinterForce().

◆ setBasicMPIInteractionValues()

void BaseInteraction::setBasicMPIInteractionValues	(	int	P,
		int	I,
		unsigned	timeStamp,
		Vec3D	force,
		Vec3D	torque,
		bool	isWallInteraction,
		bool	resetPointers
	)

Todo:: TW should P, I be of type unsigned?

 {
     this->setIdentificationP(P);
     this->setIdentificationI(I);
     this->setTimeStamp(timeStamp);
     this->setForce(force);
     this->setTorque(torque);
     this->setWallInteraction(isWallInteraction);
     if (resetPointers)
     {
         this->I_ = nullptr;
         this->P_ = nullptr;
     }
 }

References I_, P_, setForce(), setIdentificationI(), setIdentificationP(), setTimeStamp(), setTorque(), and setWallInteraction().

Referenced by MPIInteraction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >::copyToInteraction().

◆ setContactPoint()

void BaseInteraction::setContactPoint ( Vec3D contactPoint )

Set the location of the contact point between the two interacting objects.

 {
     contactPoint_ = contactPoint;
 }

References contactPoint_.

Referenced by setFStatData().

◆ setDistance()

void BaseInteraction::setDistance ( Mdouble distance )

Sets the interaction distance between the two interacting objects.

set the distance of the interaction.

Parameters

[in] distance Mdouble which is the distance to set.

 {
     distance_ = distance;
 }

References distance_.

Referenced by setFStatData().

◆ setForce()

void BaseInteraction::setForce ( Vec3D force )

set total force (this is used by the normal force, tangential forces are added use addForce)

set the absolute values of the force. This is used by the normal forces as these are always called first and then the tangential and non-contact (e.g. adhesive forces) forces are added. See also BaseInteraction::addForce.

 {
     force_ = force;
 }

References force_.

◆ setFStatData() [1/2]

void BaseInteraction::setFStatData	(	std::fstream &	fstat,
		BaseParticle *	P,
		BaseParticle *	I
	)

 {
     Mdouble overlap, tangentialOverlap, scalarNormalForce, scalarTangentialForce;
     Vec3D centre, normal, tangential;
     fstat >> centre >> overlap >> tangentialOverlap >> scalarNormalForce >> scalarTangentialForce >> normal
           >> tangential;
     const Vec3D force = scalarNormalForce * normal + scalarTangentialForce * tangential;
     setForce(force);
     setNormal(normal);
     setOverlap(overlap);
     const Mdouble radius = P->getRadius();
     const Vec3D branch = (radius - 0.5 * getOverlap()) * getNormal();
     setContactPoint(P->getPosition() - branch);
     setDistance(radius + I->getRadius() - getOverlap());
 }

References getNormal(), getOverlap(), I, WallFunction::normal(), Global_Physical_Variables::P, UniformPSDSelfTest::radius, setContactPoint(), setDistance(), setForce(), setNormal(), and setOverlap().

◆ setFStatData() [2/2]

void BaseInteraction::setFStatData	(	std::fstream &	fstat,
		BaseParticle *	P,
		BaseWall *	I
	)

 {
     Mdouble overlap, tangentialOverlap, scalarNormalForce, scalarTangentialForce;
     Vec3D centre, normal, tangential;
     fstat >> centre >> overlap >> tangentialOverlap >> scalarNormalForce >> scalarTangentialForce >> normal
           >> tangential;
     const Vec3D force = scalarNormalForce * normal + scalarTangentialForce * tangential;
     //note walls are defined different than particles (with an extra minus)
     setForce(-force);
     setNormal(-normal);
     setOverlap(overlap);
     const Mdouble radius = P->getRadius();
     const Vec3D branch = (radius - 0.5 * getOverlap()) * getNormal();
     setContactPoint(P->getPosition() - branch);
     setDistance(radius - getOverlap());
 }

References getNormal(), getOverlap(), WallFunction::normal(), Global_Physical_Variables::P, UniformPSDSelfTest::radius, setContactPoint(), setDistance(), setForce(), setNormal(), and setOverlap().

◆ setHandler()

void BaseInteraction::setHandler ( InteractionHandler * handler )

Sets the pointer to the interaction hander which is storing this interaction.

set the handler which this interactions belongs to.

Parameters

[in] handler InteractionHandler* pointer to the interaction handler, this interaction will belong.

 {
     handler_ = handler;
 }

References handler_.

◆ setI()

void BaseInteraction::setI ( BaseInteractable * I )

Sets the second object involved in the interaction (often particle or wall).

Changes the second object involved in the interaction; often a general interactable not always a particle. Note, set is slightly misleading as it removed the interaction from old interactable and adds it to the new interactable.

Parameters

[in] I BaseInteractable* An interactable object that is involved in the interaction.

 {
     I_->removeInteraction(this);
     I_ = I;
     I_->addInteraction(this);
     identificationI_ = I_->getId();
 }

References BaseInteractable::addInteraction(), BaseObject::getId(), I, I_, identificationI_, and BaseInteractable::removeInteraction().

Referenced by InteractionHandler::removeObjectKeepingPeriodics().

◆ setIdentificationI()

void BaseInteraction::setIdentificationI ( int identification )

 {
     identificationI_ = identification;
 }

References identificationI_.

Referenced by setBasicMPIInteractionValues().

◆ setIdentificationP()

void BaseInteraction::setIdentificationP ( unsigned int identification )

 {
     identificationP_ = identification;
 }

References identificationP_.

Referenced by setBasicMPIInteractionValues().

◆ setLagrangeMultiplier()

void BaseInteraction::setLagrangeMultiplier ( Mdouble multiplier )

inline

     {
         lagrangeMultiplier_ = multiplier;
     }

References lagrangeMultiplier_, and Global_Physical_Variables::multiplier().

◆ setMPIInteraction()

void BaseInteraction::setMPIInteraction	(	void *	interactionDataArray,
		unsigned int	index,
		bool	resetPointers
	)

virtual

Reimplemented in Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

891 {

892 }

◆ setMultiContactIdentifier()

void BaseInteraction::setMultiContactIdentifier ( unsigned int multiContactIdentifier_ )

 {
     multiContactIdentifier_ = multiContactIdentifier;
 }

References multiContactIdentifier_.

◆ setNormal()

void BaseInteraction::setNormal ( Vec3D normal )

Sets the normal vector between the two interacting objects.

sets the normal of the interaction, in direction from I to P. Must be a unit normal vector. This is not checked by the class.

Parameters

[in] normal Vec3D which is the normal of the interaction.

 {
     normal_ = normal;
 }

References WallFunction::normal(), and normal_.

Referenced by setFStatData().

◆ setNormalRelativeVelocity()

void BaseInteraction::setNormalRelativeVelocity ( Mdouble normalRelativeVelocity )

protected

set the normal component of the relative velocity.

set the norm (length) of the normal relative velocity.

Parameters

[in] normalRelativeVelocity Mdouble containing the normal (length) of the normal velocity between the interactable objects.

 {
     normalRelativeVelocity_ = normalRelativeVelocity;
 }

References normalRelativeVelocity_.

Referenced by HertzianBSHPViscoelasticInteraction::computeNormalForce(), HertzianViscoelasticInteraction::computeNormalForce(), LinearPlasticViscoelasticInteraction::computeNormalForce(), LinearViscoelasticInteraction::computeNormalForce(), MeltableInteraction::computeNormalForce(), SinterInteraction::computeNormalForce(), SinterLinInteraction::computeNormalForce(), SPHInteraction::computeNormalForce(), and HertzianSinterInteraction::computeSinterForce().

◆ setOverlap()

void BaseInteraction::setOverlap ( Mdouble overlap )

Set the overlap between the two interacting object.

set the overlap between the two interactable object involved in the interactions.

Parameters

[in] overlap Mdouble which is the overlap to set.

 {
     overlap_ = overlap;
 }

References overlap_.

Referenced by setFStatData().

◆ setP()

void BaseInteraction::setP ( BaseInteractable * P )

Sets the first object involved in the interaction (normally a particle).

Changes the first object involved in the interaction; normally a particle. Note, set is slightly misleading as it removed the interaction from old particle and adds it to the new particle.

Parameters

[in] P BaseInteractable* An interactable object that is involved in the interaction.

 {
     P_->removeInteraction(this);
     P_ = P;
     P_->addInteraction(this);
     identificationP_ = P_->getId();
 }

References BaseInteractable::addInteraction(), BaseObject::getId(), identificationP_, Global_Physical_Variables::P, P_, and BaseInteractable::removeInteraction().

◆ setRelativeVelocity()

void BaseInteraction::setRelativeVelocity ( Vec3D relativeVelocity )

protected

set the relative velocity of the current of the interactions.

set the relative velocity between the two particles involved in the interaction.

Parameters

[in] relativeVelocity This is Vec3D that contains the relative velocity between the two interactable objects.

 {
     relativeVelocity_ = relativeVelocity;
 }

References relativeVelocity_.

Referenced by HertzianBSHPViscoelasticInteraction::computeNormalForce(), HertzianViscoelasticInteraction::computeNormalForce(), LinearPlasticViscoelasticInteraction::computeNormalForce(), LinearViscoelasticInteraction::computeNormalForce(), MeltableInteraction::computeNormalForce(), SinterInteraction::computeNormalForce(), SinterLinInteraction::computeNormalForce(), SPHInteraction::computeNormalForce(), and HertzianSinterInteraction::computeSinterForce().

◆ setSpecies()

void BaseInteraction::setSpecies ( const BaseSpecies * species )

Set the Species of the interaction; note this can either be a Species or MixedSpecies.

Sets the species for the interactions. Note, this can be either a normal Species or a MixedSpecies; depending on if this interaction is between interactables of the same or different types.

Parameters

[in] BaseSpecies* pointer to the actually species of the interaction.

 {
     species_ = species;
 }

References species_.

◆ setTimeStamp()

void BaseInteraction::setTimeStamp ( unsigned timeStamp )

Updates the time step of the interacting. Note, time steps used to find completed interactions.

Updated the time stamp of the interaction. The time stamp being old is how ended interactions are detected.

Parameters

[in] timeStamp The new timeStamp for the interactions should be the current time step.

 {
     timeStamp_ = timeStamp;
 }

References timeStamp_.

Referenced by setBasicMPIInteractionValues().

◆ setTorque()

void BaseInteraction::setTorque ( Vec3D torque )

set the total force (this is used by the normal force, tangential torques are added use addTorque)

set the absolute values of the torque. This is used by the normal forces as these are always called first and then the tangential and non-contact (e.g. adhesive forces) forces/torques are added. See also BaseInteraction::addTorque.

 {
     torque_ = torque;
 }

References torque_.

Referenced by HertzianBSHPViscoelasticInteraction::computeNormalForce(), HertzianViscoelasticInteraction::computeNormalForce(), LinearPlasticViscoelasticInteraction::computeNormalForce(), LinearViscoelasticInteraction::computeNormalForce(), MeltableInteraction::computeNormalForce(), SinterInteraction::computeNormalForce(), SinterLinInteraction::computeNormalForce(), SPHInteraction::computeNormalForce(), HertzianSinterInteraction::computeSinterForce(), and setBasicMPIInteractionValues().

◆ setWallInteraction()

void BaseInteraction::setWallInteraction ( bool flag )

 {
     isWallInteraction_ = flag;
 }

References isWallInteraction_.

Referenced by setBasicMPIInteractionValues().

◆ write()

void BaseInteraction::write ( std::ostream & os ) const

overridevirtual

Interaction print function, which accepts an std::ostream as input.

BaseInteaction write function. Writes out all the information required to recreate this interaction. To write this interaction to the screen call write(std::cout). See also BaseInteraction::read

Parameters

[in] os std::ostream to which the information is written. Note, is any ostram is can be file or screen.

Todo:: should we output id's here? os << " id " << getId() << " particleIds " << P_->getId() << " " << I_->getId();

Implements BaseObject.

Reimplemented in SPHInteraction, SinterLinInteraction, SinterInteraction, MeltableInteraction, LinearViscoelasticInteraction, LinearPlasticViscoelasticInteraction, HertzianViscoelasticInteraction, HertzianSinterInteraction, HertzianBSHPViscoelasticInteraction, SlidingFrictionInteraction, MindlinRollingTorsionInteraction, MindlinInteraction, FrictionInteraction, EmptyFrictionInteraction, and Interaction< NormalForceInteraction, FrictionForceInteraction, AdhesiveForceInteraction >.

 {
     os << getName();
     if (dynamic_cast<BaseParticle*>(I_) != nullptr)
     {
         os << " particleIds " << P_->getId() << " " << I_->getId();
     }
     else
     {
         os << " particleWallIds " << P_->getId() << " " << I_->getId();
     }
     os << " timeStamp " << timeStamp_;
     os << " contactPoint " << contactPoint_;
     os << " normal " << normal_;
     os << " distance " << distance_;
     os << " overlap " << overlap_;
     os << " force " << force_;
     os << " torque " << torque_;
 }

References contactPoint_, distance_, force_, BaseObject::getId(), getName(), I_, normal_, overlap_, P_, timeStamp_, and torque_.

Referenced by HertzianSinterInteraction::write(), HertzianViscoelasticInteraction::write(), LinearPlasticViscoelasticInteraction::write(), LinearViscoelasticInteraction::write(), MeltableInteraction::write(), SinterInteraction::write(), SinterLinInteraction::write(), and SPHInteraction::write().

◆ writeInteraction()

void BaseInteraction::writeInteraction	(	std::ostream &	os,
		bool	created
	)		const

protected

Writes information about a interaction to the interaction file.

Method to write the interaction data to a stream, usually an interaction file. It saves the IDs of the particles (in case there are two particles) or particle and wall. Furthermore, the time when the interaction starts and ends is written to the stream.

Parameters

	[in/out]	os The outputstream to which the interaction information should be written, usually a file
[in]	created	Whether or not this is the beginning of the interaction.

 {
     if (created)
     {
         os << "started ";
     }
     else
     {
         os << "ended   ";
     }
     
     if (dynamic_cast<BaseParticle*>(I_) != nullptr)
     {
         os << " particleIds     " << P_->getId() << " " << I_->getId() << " timeStamp ";
     }
     else
     {
         os << " particleWallIds " << P_->getId() << " " << I_->getId() << " timeStamp ";
     }
     
     if (created)
     {
         os << timeStamp_;
     }
     else
     {
         os << P_->getSpecies()->getHandler()->getDPMBase()->getTime();
     }
     
     os << std::endl;
     
 }

References BaseHandler< T >::getDPMBase(), BaseSpecies::getHandler(), BaseObject::getId(), BaseInteractable::getSpecies(), DPMBase::getTime(), I_, P_, and timeStamp_.

Referenced by BaseInteraction(), and ~BaseInteraction().

◆ writeToFStat()

void BaseInteraction::writeToFStat	(	std::ostream &	os,
		Mdouble	time
	)		const

Writes forces data to the FStat file.

Writes the FStat information that is required for the coarse- graining package MercuryCG if you want stress and force information. Note, it takes a general ostream but is normally a file i.e. ofstream

Parameters

[in] os This is the ostream that the FStat information will be written to. Normally, a file but could be a gerneral ostream.

Todo:: MX The documentation mentions that the first variable is the time - this is incorrect, is is the timeStamp the interaction started

Todo:: the flip in normal/tangential direction for walls should not be done; this is an old bug

 {
     auto* IParticle = dynamic_cast<BaseParticle*>(I_);
     auto* PParticle = dynamic_cast<BaseParticle*>(P_);
     
     // do not write fstat output if the force is an internal bond
     if (isBonded()) return;
     
     Vec3D tangentialForce = getTangentialForce();
     Mdouble tangentialOverlap = getTangentialOverlap();
     
     Mdouble scalarNormalForce = Vec3D::dot(force_, getNormal());
     Mdouble scalarTangentialForce = tangentialForce.getLength();
     Vec3D tangential;
     if (scalarTangentialForce != 0.0)
         tangential = tangentialForce / scalarTangentialForce;
     else
         tangential = Vec3D(0.0, 0.0, 0.0);
     
     if (PParticle != nullptr && !PParticle->isFixed())
     {
         os << time << " " << P_->getIndex()
            << " " << static_cast<int>((IParticle == nullptr ? (-I_->getIndex() - 1) : I_->getIndex()))
            << " " << getContactPoint()
            << " " << getOverlap()
            << " " << tangentialOverlap
            << " " << scalarNormalForce
            << " " << scalarTangentialForce
            << " " << (IParticle == nullptr ? -normal_ : normal_)
            << " " << (IParticle == nullptr ? -tangential : tangential) << std::endl;
     }
     if (IParticle != nullptr && !IParticle->isFixed() && IParticle->getPeriodicFromParticle() == nullptr)
     {
         os << time << " " << I_->getIndex()
            << " " << P_->getIndex()
            << " " << getContactPoint()
            << " " << getOverlap()
            << " " << tangentialOverlap
            << " " << scalarNormalForce
            << " " << scalarTangentialForce
            << " " << -normal_
            << " " << -tangential << std::endl;
     }
 }

References Vec3D::dot(), force_, getContactPoint(), BaseObject::getIndex(), Vec3D::getLength(), getNormal(), getOverlap(), getTangentialForce(), getTangentialOverlap(), I_, isBonded(), normal_, and P_.

Member Data Documentation

◆ absoluteNormalForce_

Mdouble BaseInteraction::absoluteNormalForce_

private

Variables calculated by NormalForceInteraction, used by FrictionForceInteraction and AdhesiveForceInteraction (but not changed by them)

Referenced by getAbsoluteNormalForce(), and setAbsoluteNormalForce().

◆ contactPoint_

Vec3D BaseInteraction::contactPoint_

private

This is Vec3D which stores the contact point of the interaction.

Referenced by BaseInteraction(), getContactPoint(), getEffectiveRadius(), read(), rotateHistory(), setContactPoint(), and write().

◆ distance_

Mdouble BaseInteraction::distance_

private

Variables calculated by NormalForceInteraction, used by FrictionForceInteraction and AdhesiveForceInteraction (but not changed by them)

Referenced by getDistance(), read(), setDistance(), and write().

◆ force_

Vec3D BaseInteraction::force_

private

First computed by NormalForceInteraction, but added to by FrictionForceInteraction and AdhesiveForceInteraction.

Referenced by addForce(), BaseInteraction(), gatherContactStatistics(), getForce(), read(), rotateHistory(), setForce(), write(), and writeToFStat().

◆ handler_

InteractionHandler* BaseInteraction::handler_

private

Pointer to the InteractionHander for this interaction.

Referenced by copySwitchPointer(), getHandler(), removeFromHandler(), and setHandler().

◆ I_

BaseInteractable* BaseInteraction::I_

private

This is the second of the two interactable object involved in the interaction; often a particle or a wall, hence I because it is general interactable.

Referenced by BaseInteraction(), gatherContactStatistics(), getI(), importI(), setBasicMPIInteractionValues(), setI(), write(), writeInteraction(), writeToFStat(), and ~BaseInteraction().

◆ identificationI_

int BaseInteraction::identificationI_

private

Referenced by getIdentificationI(), importI(), setI(), and setIdentificationI().

◆ identificationP_

unsigned int BaseInteraction::identificationP_

private

Referenced by getIdentificationP(), importP(), setIdentificationP(), and setP().

◆ isWallInteraction_

bool BaseInteraction::isWallInteraction_

private

Referenced by isWallInteraction(), and setWallInteraction().

◆ lagrangeMultiplier_

Mdouble BaseInteraction::lagrangeMultiplier_

private

Lagrange multiplier used by contact detection of superquadrics.

Referenced by BaseInteraction(), getLagrangeMultiplier(), and setLagrangeMultiplier().

◆ multiContactIdentifier_

unsigned BaseInteraction::multiContactIdentifier_

private

Identifies individual contact such that it can be distinguished. E.g. the face number of a triangulated wall.

Referenced by getMultiContactIdentifier(), and setMultiContactIdentifier().

◆ normal_

Vec3D BaseInteraction::normal_

private

Vec3D which stores the normal vector (unit vector from I to P) of the interaction.

Referenced by BaseInteraction(), gatherContactStatistics(), getNormal(), read(), rotateHistory(), setNormal(), write(), and writeToFStat().

◆ normalRelativeVelocity_

Mdouble BaseInteraction::normalRelativeVelocity_

private

Variables calculated by NormalForceInteraction, used in other force routines (but not changed by them)

Referenced by getNormalRelativeVelocity(), and setNormalRelativeVelocity().

◆ overlap_

Mdouble BaseInteraction::overlap_

private

Mdouble which stores the current overlap.

Referenced by BaseInteraction(), gatherContactStatistics(), getOverlap(), read(), setOverlap(), and write().

◆ P_

BaseInteractable* BaseInteraction::P_

private

This first of two interactable objects involved in the interaction; normally a particle hence P.

Referenced by BaseInteraction(), gatherContactStatistics(), getP(), importP(), setBasicMPIInteractionValues(), setP(), write(), writeInteraction(), writeToFStat(), and ~BaseInteraction().

◆ relativeVelocity_

Vec3D BaseInteraction::relativeVelocity_

private

Variables calculated by the normal force routines used in other force routines (but not changed by them).

Referenced by getRelativeVelocity(), rotateHistory(), and setRelativeVelocity().

◆ species_

const BaseSpecies* BaseInteraction::species_

private

Pointer to the species of the interaction could be a mixed species or a species.

Referenced by BaseInteraction(), getBaseSpecies(), and setSpecies().

◆ timeStamp_

unsigned BaseInteraction::timeStamp_

private

Mdouble which store the last timeStamp the interaction was active.

Todo:: TW it would be safer to use the integer time step here, instead of the double

Referenced by BaseInteraction(), getTimeStamp(), setTimeStamp(), write(), and writeInteraction().

◆ torque_

Vec3D BaseInteraction::torque_

private

First computed by NormalForceInteraction, but added to by FrictionForceInteraction and AdhesiveForceInteraction.

Referenced by addTorque(), BaseInteraction(), getTorque(), read(), rotateHistory(), setTorque(), and write().

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

Private Attributes
InteractionHandler *	handler_

BaseInteractable *	P_

BaseInteractable *	I_

unsigned int	identificationP_

int	identificationI_

bool	isWallInteraction_

Vec3D	contactPoint_

Vec3D	relativeVelocity_

Mdouble	normalRelativeVelocity_

Mdouble	absoluteNormalForce_

Mdouble	distance_

Vec3D	force_

Vec3D	torque_

unsigned	timeStamp_

Vec3D	normal_

Mdouble	overlap_

const BaseSpecies *	species_

Mdouble	lagrangeMultiplier_

unsigned	multiContactIdentifier_

Public Member Functions

Protected Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BaseInteraction() [1/3]

◆ BaseInteraction() [2/3]

◆ BaseInteraction() [3/3]

◆ ~BaseInteraction()

Member Function Documentation

◆ actionsAfterTimeStep()

◆ actionsOnErase()

◆ addForce()

◆ addTorque()

◆ computeForce()

◆ copy()

◆ copySwitchPointer()

◆ createMPIInteractionDataArray()

◆ createMPIType()

◆ deleteMPIInteractionDataArray()

◆ gatherContactStatistics()

◆ getAbsoluteNormalForce()

◆ getBaseSpecies()

◆ getContactPoint()

◆ getContactRadius()

◆ getCP()

◆ getDistance()

◆ getEffectiveMass()

◆ getEffectiveRadius()

◆ getElasticEnergy()

◆ getElasticEnergyAtEquilibrium()

◆ getFieldVTK()

◆ getForce()

◆ getHandler()

◆ getI() [1/2]

◆ getI() [2/2]

◆ getIC()

◆ getIdentificationI()

◆ getIdentificationP()

◆ getInteractionDetails()

◆ getIP()

◆ getLagrangeMultiplier()

◆ getMPIInteraction()

◆ getMultiContactIdentifier()

◆ getName()

◆ getNameVTK()

◆ getNormal()

◆ getNormalRelativeVelocity()

◆ getNumberOfFieldsVTK()

◆ getOverlap()

◆ getOverlapVolume()

◆ getP() [1/2]

◆ getP() [2/2]

◆ getRelativeVelocity()

◆ getTangentialForce()

◆ getTangentialOverlap()

◆ getTimeStamp()

◆ getTorque()

◆ getTypeVTK()

◆ importI()

◆ importP()

◆ integrate()

◆ isBonded()

◆ isWallInteraction()

◆ read()

◆ removeFromHandler()

◆ reverseHistory()

◆ rotateHistory()

◆ setAbsoluteNormalForce()

◆ setBasicMPIInteractionValues()

◆ setContactPoint()

◆ setDistance()

◆ setForce()

◆ setFStatData() [1/2]

◆ setFStatData() [2/2]

◆ setHandler()

◆ setI()

◆ setIdentificationI()

◆ setIdentificationP()

◆ setLagrangeMultiplier()