olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > Struct Template Reference

An object holding data for a contact which is described analog to Nassauer and Kuna (2013) More...

#include <particleContact.h>

Inheritance diagram for olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >:

Collaboration diagram for olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >:

Public Member Functions
	ParticleContactArbitraryFromOverlapVolume ()
	Constructor.
	ParticleContactArbitraryFromOverlapVolume (const std::array< std::size_t, 2 > &particleIDs)
	Constructor.
	ParticleContactArbitraryFromOverlapVolume (const ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > &pc)
	Copy Constructor.
	ParticleContactArbitraryFromOverlapVolume (ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > &&pc)
	Move Constructor.
constexpr const std::array< PhysR< T, D >, 2 > &	getParticlePositions () const
	Read access to particle positions.
constexpr const PhysR< T, D > &	getParticlePosition (const std::size_t &id) const
	Return particle position.
constexpr const PhysR< T, D > &	getMin () const
	Read access to min.
constexpr const PhysR< T, D > &	getMax () const
	Read access to max.
constexpr const std::array< std::size_t, 2 > &	getIDs () const
	Read access to particle IDs.
constexpr const T	getDampingFactor () const
	Read access to damping factor.
constexpr const int &	getResponsibleRank () const
	Read access to the responsible rank.
constexpr void	setParticlePositions (const std::array< PhysR< T, D >, 2 > &positions)
	Set particle positions.
constexpr void	setParticlePosition (const PhysR< T, D > &position, const std::size_t &id)
	Set position of specific particle.
constexpr void	setDampingFactor (const T dampingFactor)
	Set damping factor for contact.
constexpr void	setDampingFactorFromInitialVelocity (const T coefficientOfRestitution, const T initialRelativeVelocityMagnitude)
	Set damping factor from the magnitude of the initial relative impact velocity in direction of contact normal and the wanted coefficient of restitution.
constexpr void	setResponsibleRank (const int &rank)
	Set processor that is responsible for contact treatment.
constexpr void	resetMinMax ()
	Reset min and max to default values.
constexpr void	updateMinMax (const PhysR< T, D > &positionInsideTheContact)
	Update min and max with given position inside the contact.
constexpr void	increaseMinMax (const Vector< T, D > &increaseBy)
	Increase bounding box size.
constexpr void	combineWith (ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > &pc)
	Combining two contacts, if the particle ids are the same.
constexpr bool	isEmpty () const
	Returns if contact holds data.
constexpr bool	isNew () const
	Returns if the contact is a new contact.
constexpr void	isNew (const bool newContact)
	Sets 'isNew'.
constexpr bool	isParticlePositionUpdated () const
	Returns if the particle position is up-to-date.
constexpr void	setParticlePositionUpdated (bool updated)
ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > &	operator= (const ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > &pc)
	Copy assignment.
ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > &	operator= (ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > &&pc)
	Move assignment.
std::size_t	serialize (std::uint8_t *buffer)
	Serialize contact data.
std::size_t	deserialize (std::uint8_t *buffer)
	Deserialize contact data and save in object.
void	print ()
	Print relevant quantities.
Public Member Functions inherited from olb::particles::contact::ParticleContact< D >
const std::vector< unsigned int >	indicesDim ({0, 1})
const std::vector< unsigned int >	indicesDim ({0, 1, 2})

Static Public Member Functions
static constexpr std::size_t	getSerialSize ()
	Get serial size.

Additional Inherited Members
Static Public Attributes inherited from olb::particles::contact::ParticleContact< D >
static const std::vector< unsigned int >	indicesDim
static const std::vector< unsigned int >	indicesPart
static const std::vector< unsigned int >	indicesSingle

Detailed Description

template<typename T, unsigned D, bool CONVEX = true>
struct olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >

An object holding data for a contact which is described analog to Nassauer and Kuna (2013)

Definition at line 61 of file particleContact.h.

Constructor & Destructor Documentation

ParticleContactArbitraryFromOverlapVolume() [1/4]

template<typename T , unsigned D, bool CONVEX>

olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::ParticleContactArbitraryFromOverlapVolume

(

)

Constructor.

Definition at line 36 of file particleContact.hh.

    : ParticleContactArbitraryFromOverlapVolume<T, D, CONVEX>(
          std::array<std::size_t, 2>())
{}

ParticleContactArbitraryFromOverlapVolume() [2/4]

template<typename T , unsigned D, bool CONVEX>

olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::ParticleContactArbitraryFromOverlapVolume

(

const std::array< std::size_t, 2 > &

particleIDs

)

Constructor.

Definition at line 42 of file particleContact.hh.

    : ids(sortParticleIDs(particleIDs))
{
  resetMinMax();
}

References olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::resetMinMax().

Here is the call graph for this function:

ParticleContactArbitraryFromOverlapVolume() [3/4]

template<typename T , unsigned D, bool CONVEX>

olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::ParticleContactArbitraryFromOverlapVolume

(

const ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > &

pc

)

Copy Constructor.

Definition at line 51 of file particleContact.hh.

{
  min                        = pc.getMin();
  max                        = pc.getMax();
  ids                        = pc.getIDs();
  particlePositions          = pc.getParticlePositions();
  particlePositionUpdated[0] = pc.isParticlePositionUpdated();
  dampingFactor[0]           = pc.getDampingFactor();
  newContact[0]              = pc.isNew();
  responsibleRank[0]         = pc.getResponsibleRank();
}

References olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getDampingFactor(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getIDs(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMax(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMin(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getParticlePositions(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getResponsibleRank(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::isNew(), and olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::isParticlePositionUpdated().

Here is the call graph for this function:

ParticleContactArbitraryFromOverlapVolume() [4/4]

template<typename T , unsigned D, bool CONVEX>

olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::ParticleContactArbitraryFromOverlapVolume

(

ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > &&

pc

)

Move Constructor.

Definition at line 66 of file particleContact.hh.

{
  min                     = std::move(pc.min);
  max                     = std::move(pc.max);
  ids                     = std::move(pc.ids);
  particlePositions       = std::move(pc.particlePositions);
  particlePositionUpdated = std::move(pc.particlePositionUpdated);
  dampingFactor           = std::move(pc.dampingFactor);
  newContact              = std::move(pc.newContact);
  responsibleRank         = std::move(pc.responsibleRank);
}

Member Function Documentation

combineWith()

template<typename T , unsigned D, bool CONVEX>

void olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::combineWith ( ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > & pc )

constexpr

Combining two contacts, if the particle ids are the same.

Definition at line 211 of file particleContact.hh.

{
  if (particleContactConsistsOfIDs<
          ParticleContactArbitraryFromOverlapVolume<T, D, CONVEX>, true>(pc,
                                                                         ids)) {
    if(newContact[0] == pc.isNew()) {
      newContact[0] = newContact[0] && pc.isNew();
 
      // Determine bounding box of combined overlap area
      for (unsigned iD = 0; iD < D; ++iD) {
        min[iD] = util::min(min[iD], pc.getMin()[iD]);
        max[iD] = util::max(max[iD], pc.getMax()[iD]);
      }
      // The damping factors should be either the same or one is -1 and the other has the correct value which is > 0
      dampingFactor[0]   = util::max(dampingFactor[0], pc.getDampingFactor());
      responsibleRank[0] = util::min(responsibleRank[0], pc.getResponsibleRank());
      particlePositionUpdated[0] =
          particlePositionUpdated[0] || pc.isParticlePositionUpdated();
      if (!particlePositionUpdated[0] && pc.isParticlePositionUpdated()) {
        particlePositions = pc.getParticlePositions();
      }
    }
    else {
      if(!pc.isNew()) {
        min = pc.getMin();
        max = pc.getMax();
        dampingFactor[0] = pc.getDampingFactor();
        particlePositionUpdated[0] = pc.isParticlePositionUpdated();
        particlePositions = pc.getParticlePositions();
      }
      responsibleRank[0] = util::min(responsibleRank[0], pc.getResponsibleRank());
      newContact[0] = newContact[0] && pc.isNew();
    }
 
    // Ignore second contact by resetting it
    pc.resetMinMax();
  }
}

References olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getDampingFactor(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMax(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMin(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getParticlePositions(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getResponsibleRank(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::isNew(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::isParticlePositionUpdated(), olb::util::max(), olb::util::min(), olb::particles::contact::particleContactConsistsOfIDs(), and olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::resetMinMax().

Here is the call graph for this function:

deserialize()

template<typename T , unsigned D, bool CONVEX>

std::size_t olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::deserialize

(

std::uint8_t *

buffer

)

Deserialize contact data and save in object.

Definition at line 380 of file particleContact.hh.

{
  return processWithCommunicatables(
      [&](auto& communicatablePositions, auto& communicatableMin,
          auto& communicatableMax, auto& communicatableIDs,
          auto& communicatableDamping,
          auto& communicatableParticlePositionUpdated,
          auto& communicatableIsNew, auto& communicatableRank) {
        std::size_t serialIdx =
            communicatablePositions.deserialize(this->indicesPart, buffer);
        serialIdx +=
            communicatableMin.deserialize(this->indicesDim, &buffer[serialIdx]);
        serialIdx +=
            communicatableMax.deserialize(this->indicesDim, &buffer[serialIdx]);
        serialIdx += communicatableIDs.deserialize(this->indicesPart,
                                                   &buffer[serialIdx]);
        serialIdx += communicatableDamping.deserialize(this->indicesSingle,
                                                       &buffer[serialIdx]);
        serialIdx += communicatableParticlePositionUpdated.deserialize(
            this->indicesSingle, &buffer[serialIdx]);
        serialIdx += communicatableIsNew.deserialize(this->indicesSingle,
                                                     &buffer[serialIdx]);
        serialIdx += communicatableRank.deserialize(this->indicesSingle,
                                                    &buffer[serialIdx]);
 
        return serialIdx;
      });
}

getDampingFactor()

template<typename T , unsigned D, bool CONVEX>

const T olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getDampingFactor ( ) const

constexpr

Read access to damping factor.

Definition at line 156 of file particleContact.hh.

{
  return dampingFactor[0];
}

Here is the caller graph for this function:

getIDs()

template<typename T , unsigned D, bool CONVEX>

const std::array< std::size_t, 2 > & olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getIDs ( ) const

constexpr

Read access to particle IDs.

Definition at line 82 of file particleContact.hh.

{
  return this->ids;
}

Here is the caller graph for this function:

getMax()

template<typename T , unsigned D, bool CONVEX>

const PhysR< T, D > & olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMax ( ) const

constexpr

Read access to max.

Definition at line 149 of file particleContact.hh.

{
  return this->max;
}

References olb::max().

Here is the call graph for this function:

Here is the caller graph for this function:

getMin()

template<typename T , unsigned D, bool CONVEX>

const PhysR< T, D > & olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMin ( ) const

constexpr

Read access to min.

Definition at line 142 of file particleContact.hh.

{
  return this->min;
}

Here is the caller graph for this function:

getParticlePosition()

template<typename T , unsigned D, bool CONVEX>

const PhysR< T, D > & olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getParticlePosition ( const std::size_t & id ) const

constexpr

Return particle position.

Definition at line 106 of file particleContact.hh.

{
  if (id == ids[0]) {
    return particlePositions[0];
  }
  return particlePositions[1];
}

getParticlePositions()

template<typename T , unsigned D, bool CONVEX>

const std::array< PhysR< T, D >, 2 > & olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getParticlePositions ( ) const

constexpr

Read access to particle positions.

Definition at line 89 of file particleContact.hh.

{
  return particlePositions;
}

Here is the caller graph for this function:

getResponsibleRank()

template<typename T , unsigned D, bool CONVEX>

const int & olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getResponsibleRank ( ) const

constexpr

Read access to the responsible rank.

Definition at line 134 of file particleContact.hh.

{
  return responsibleRank[0];
}

Here is the caller graph for this function:

getSerialSize()

template<typename T , unsigned D, bool CONVEX = true>

static constexpr std::size_t olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getSerialSize ( )

inlinestaticconstexpr

Get serial size.

Definition at line 165 of file particleContact.h.

{ return serialSize; };

increaseMinMax()

template<typename T , unsigned D, bool CONVEX>

void olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::increaseMinMax ( const Vector< T, D > & increaseBy )

constexpr

Increase bounding box size.

Definition at line 202 of file particleContact.hh.

{
  this->max += increaseBy;
  this->min -= increaseBy;
}

isEmpty()

template<typename T , unsigned D, bool CONVEX>

bool olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::isEmpty ( ) const

constexpr

Returns if contact holds data.

Definition at line 253 of file particleContact.hh.

{
  for (unsigned iD = 0; iD < D; ++iD) {
    if (min[iD] > max[iD]) {
      return true;
    }
  }
  return false;
}

Here is the caller graph for this function:

isNew() [1/2]

template<typename T , unsigned D, bool CONVEX>

bool olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::isNew ( ) const

constexpr

Returns if the contact is a new contact.

Definition at line 265 of file particleContact.hh.

{
  return newContact[0];
}

Here is the caller graph for this function:

isNew() [2/2]

template<typename T , unsigned D, bool CONVEX>

void olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::isNew ( const bool newContact )

constexpr

Sets 'isNew'.

Definition at line 271 of file particleContact.hh.

{
  this->newContact[0] = newContact;
}

isParticlePositionUpdated()

template<typename T , unsigned D, bool CONVEX>

bool olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::isParticlePositionUpdated ( ) const

constexpr

Returns if the particle position is up-to-date.

Definition at line 279 of file particleContact.hh.

{
  return particlePositionUpdated[0];
}

Here is the caller graph for this function:

operator=() [1/2]

template<typename T , unsigned D, bool CONVEX>

ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > & olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::operator=

(

const ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > &

pc

)

Copy assignment.

Definition at line 293 of file particleContact.hh.

{
  min                        = pc.getMin();
  max                        = pc.getMax();
  ids                        = pc.getIDs();
  particlePositions          = pc.getParticlePositions();
  particlePositionUpdated[0] = pc.isParticlePositionUpdated();
  dampingFactor[0]           = pc.getDampingFactor();
  newContact[0]              = pc.isNew();
  responsibleRank[0]         = pc.getResponsibleRank();
 
  return *this;
}

References olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getDampingFactor(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getIDs(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMax(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMin(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getParticlePositions(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getResponsibleRank(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::isNew(), and olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::isParticlePositionUpdated().

Here is the call graph for this function:

operator=() [2/2]

template<typename T , unsigned D, bool CONVEX>

ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > & olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::operator=

(

ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX > &&

pc

)

Move assignment.

Definition at line 310 of file particleContact.hh.

{
  min                     = std::move(pc.min);
  max                     = std::move(pc.max);
  ids                     = std::move(pc.ids);
  particlePositions       = std::move(pc.particlePositions);
  particlePositionUpdated = std::move(pc.particlePositionUpdated);
  dampingFactor           = std::move(pc.dampingFactor);
  newContact              = std::move(pc.newContact);
  responsibleRank         = std::move(pc.responsibleRank);
 
  return *this;
}

print()

template<typename T , unsigned D, bool CONVEX>

void olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::print

(

)

Print relevant quantities.

Definition at line 411 of file particleContact.hh.

{
  OstreamManager clout(std::cout, "ParticleContact");
  clout.setMultiOutput(true);
  int rank = singleton::mpi().getRank();
  if (rank == responsibleRank[0]) {
    clout << "Min=" << this->min << ", Max=" << this->max << std::endl;
    clout << "IDs=" << this->ids << ", DampingFactor=" << dampingFactor[0]
          << std::endl;
    clout << "Positions=" << particlePositions << std::endl;
  }
  clout.setMultiOutput(false);
}

References olb::singleton::MpiManager::getRank(), olb::singleton::mpi(), and olb::OstreamManager::setMultiOutput().

Here is the call graph for this function:

resetMinMax()

template<typename T , unsigned D, bool CONVEX>

void olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::resetMinMax ( )

constexpr

Reset min and max to default values.

Definition at line 182 of file particleContact.hh.

{
  for (unsigned iD = 0; iD < D; ++iD) {
    min[iD] = std::numeric_limits<olb::BaseType<T>>::max();
    max[iD] = -std::numeric_limits<olb::BaseType<T>>::max();
  }
  particlePositionUpdated[0] = false;
}

References olb::max().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize()

template<typename T , unsigned D, bool CONVEX>

std::size_t olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::serialize

(

std::uint8_t *

buffer

)

Serialize contact data.

Definition at line 348 of file particleContact.hh.

{
  return processWithCommunicatables(
      [&](auto& communicatablePositions, auto& communicatableMin,
          auto& communicatableMax, auto& communicatableIDs,
          auto& communicatableDamping,
          auto& communicatableParticlePositionUpdated,
          auto& communicatableIsNew, auto& communicatableRank) {
        std::size_t serialIdx =
            communicatablePositions.serialize(this->indicesPart, buffer);
        serialIdx +=
            communicatableMin.serialize(this->indicesDim, &buffer[serialIdx]);
        serialIdx +=
            communicatableMax.serialize(this->indicesDim, &buffer[serialIdx]);
        serialIdx +=
            communicatableIDs.serialize(this->indicesPart, &buffer[serialIdx]);
        serialIdx += communicatableDamping.serialize(this->indicesSingle,
                                                     &buffer[serialIdx]);
        serialIdx += communicatableParticlePositionUpdated.serialize(
            this->indicesSingle, &buffer[serialIdx]);
        serialIdx += communicatableIsNew.serialize(this->indicesSingle,
                                                   &buffer[serialIdx]);
        serialIdx += communicatableRank.serialize(this->indicesSingle,
                                                  &buffer[serialIdx]);
 
        return serialIdx;
      });
}

setDampingFactor()

template<typename T , unsigned D, bool CONVEX>

void olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::setDampingFactor ( const T dampingFactor )

constexpr

Set damping factor for contact.

Definition at line 164 of file particleContact.hh.

{
  dampingFactor[0] = newDampingFactor;
}

setDampingFactorFromInitialVelocity()

template<typename T , unsigned D, bool CONVEX>

void olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::setDampingFactorFromInitialVelocity ( const T coefficientOfRestitution, const T initialRelativeVelocityMagnitude )

constexpr

Set damping factor from the magnitude of the initial relative impact velocity in direction of contact normal and the wanted coefficient of restitution.

Definition at line 171 of file particleContact.hh.

{
  setDampingFactor(particles::contact::evalDampingFactor(
      coefficientOfRestitution, initialRelativeVelocityMagnitude));
}

References olb::particles::contact::evalDampingFactor().

Here is the call graph for this function:

setParticlePosition()

template<typename T , unsigned D, bool CONVEX>

void olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::setParticlePosition ( const PhysR< T, D > & position, const std::size_t & id )

constexpr

Set position of specific particle.

Definition at line 117 of file particleContact.hh.

{
  particlePositions[id]      = position;
  particlePositionUpdated[0] = true;
}

setParticlePositions()

template<typename T , unsigned D, bool CONVEX>

void olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::setParticlePositions ( const std::array< PhysR< T, D >, 2 > & positions )

constexpr

Set particle positions.

Definition at line 97 of file particleContact.hh.

{
  particlePositions          = positions;
  particlePositionUpdated[0] = true;
}

setParticlePositionUpdated()

template<typename T , unsigned D, bool CONVEX>

void olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::setParticlePositionUpdated ( bool updated )

constexpr

Definition at line 286 of file particleContact.hh.

{
  particlePositionUpdated[0] = updated;
}

setResponsibleRank()

template<typename T , unsigned D, bool CONVEX>

void olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::setResponsibleRank ( const int & rank )

constexpr

Set processor that is responsible for contact treatment.

Definition at line 126 of file particleContact.hh.

{
  responsibleRank[0] = rank;
}

Here is the caller graph for this function:

updateMinMax()

template<typename T , unsigned D, bool CONVEX>

void olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::updateMinMax ( const PhysR< T, D > & positionInsideTheContact )

constexpr

Update min and max with given position inside the contact.

Definition at line 193 of file particleContact.hh.

{
  particles::contact::updateMinMax(this->min, this->max,
                                   positionInsideTheContact);
}

References olb::particles::contact::updateMinMax().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• src/particles/contact/particleContact.h
• src/particles/contact/particleContact.hh