olb::particles::contact::particle_wall< T, PARTICLETYPE, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, BBCORRECTIONMETHOD, CONVEX, useSDF > Struct Template Reference

#include <particleContactForceFunctions.h>

Collaboration diagram for olb::particles::contact::particle_wall< T, PARTICLETYPE, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, BBCORRECTIONMETHOD, CONVEX, useSDF >:

Static Public Member Functions
static void	resetContainer (ContactContainer< T, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > > &contactContainer)
static void	processCell (WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > &contact, Particle< T, PARTICLETYPE > &particle, SolidBoundary< T, PARTICLETYPE::d > &solidBoundary, Vector< T, PARTICLETYPE::d > &contactNormal, Vector< T, PARTICLETYPE::d > &center, unsigned &volumeCellCount, T &surfaceCellCount, const Vector< T, PARTICLETYPE::d > &pos, const Vector< T, PARTICLETYPE::d > &contactPhysDeltaX)
template<typename CONTACTPROPERTIES , typename F = decltype(defaults::processContactForce<T, PARTICLETYPE::d>)>
static void	apply (std::multimap< int, std::unique_ptr< std::uint8_t[]> > &dataMap, XParticleSystem< T, PARTICLETYPE > &particleSystem, std::vector< SolidBoundary< T, PARTICLETYPE::d > > &solidBoundaries, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > &contact, const CONTACTPROPERTIES &contactProperties, const T physDeltaX, const unsigned contactBoxResolutionPerDirection, const T k, F processContactForce=defaults::processContactForce< T, PARTICLETYPE::d >)
static void	correctBoundingBoxNewContact (XParticleSystem< T, PARTICLETYPE > &particleSystem, std::vector< SolidBoundary< T, PARTICLETYPE::d > > &solidBoundaries, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > &contact, const T physDeltaX, const unsigned contactBoxResolutionPerDirection)
static void	correctBoundingBox (XParticleSystem< T, PARTICLETYPE > &particleSystem, std::vector< SolidBoundary< T, PARTICLETYPE::d > > &solidBoundaries, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > &contact, const T physDeltaX, const unsigned contactBoxResolutionPerDirection)
static void	correctBoundingBoxExistingContact (XParticleSystem< T, PARTICLETYPE > &particleSystem, std::vector< SolidBoundary< T, PARTICLETYPE::d > > &solidBoundaries, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > &contact, const T physDeltaX, const unsigned contactBoxResolutionPerDirection)
template<typename CONTACTPROPERTIES , typename F1 = decltype(defaults::periodicity<PARTICLETYPE::d>), typename F2 = decltype(defaults::processContactForce<T, PARTICLETYPE::d>)>
static void	apply (XParticleSystem< T, PARTICLETYPE > &particleSystem, std::vector< SolidBoundary< T, PARTICLETYPE::d > > &solidBoundaries, ContactContainer< T, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > > &contactContainer, const CONTACTPROPERTIES &contactProperties, const SuperGeometry< T, PARTICLETYPE::d > &sGeometry, std::multimap< int, std::unique_ptr< std::uint8_t[]> > &dataMap, const unsigned contactBoxResolutionPerDirection=8, const T k=T {4./(3 *util::sqrt(M_PI))}, F1 getSetupPeriodicity=defaults::periodicity< PARTICLETYPE::d >, F2 processContactForce=defaults::processContactForce< T, PARTICLETYPE::d >)

Detailed Description

template<typename T, typename PARTICLETYPE, typename PARTICLECONTACTTYPE, unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>
struct olb::particles::contact::particle_wall< T, PARTICLETYPE, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, BBCORRECTIONMETHOD, CONVEX, useSDF >

Definition at line 1228 of file particleContactForceFunctions.h.

Member Function Documentation

apply() [1/2]

template<typename T , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>

template<typename CONTACTPROPERTIES , typename F = decltype(defaults::processContactForce<T, PARTICLETYPE::d>)>

static void olb::particles::contact::particle_wall< T, PARTICLETYPE, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, BBCORRECTIONMETHOD, CONVEX, useSDF >::apply ( std::multimap< int, std::unique_ptr< std::uint8_t[]> > & dataMap, XParticleSystem< T, PARTICLETYPE > & particleSystem, std::vector< SolidBoundary< T, PARTICLETYPE::d > > & solidBoundaries, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > & contact, const CONTACTPROPERTIES & contactProperties, const T physDeltaX, const unsigned contactBoxResolutionPerDirection, const T k, F processContactForce = defaults::processContactForce<T, PARTICLETYPE::d> )

inlinestatic

Definition at line 1319 of file particleContactForceFunctions.h.

  {
    using namespace descriptors;
    constexpr unsigned D = PARTICLETYPE::d;
 
    // indentation depth
    T indentationDepth = T(0.);
 
    if (!contact.isEmpty()) {
      // particle and wall in contact
      auto particle = particleSystem.get(contact.getParticleID());
      SolidBoundary<T, D>& solidBoundary = solidBoundaries[contact.getWallID()];
 
      // function to reset min & max of bounding box
      const std::function<void()> resetMinMax = [&contact]() {
        contact.resetMinMax();
      };
      // wrapper for cell processing to calculate contact point and normal
      const std::function<void(Vector<T, D>&, Vector<T, D>&, unsigned&, T&,
                               const Vector<T, D>&, const Vector<T, D>&)>
          processCellWrapped =
              [&](Vector<T, D>& contactNormal, Vector<T, D>& center,
                  unsigned& volumeCellCount, T& surfaceCellCount,
                  const Vector<T, D>& physPos,
                  const Vector<T, D>& contactPhysDeltaX) {
                processCell(contact, particle, solidBoundary, contactNormal,
                            center, volumeCellCount, surfaceCellCount, physPos,
                            contactPhysDeltaX);
              };
      // function to calculate indendation depth
      const std::function<T(const Vector<T, D>&, const Vector<T, D>&, const T)>
          calculateIndentation = [&](const Vector<T, D>& center,
                                     const Vector<T, D>& contactNormal,
                                     const T             distancePrecision) {
            T indentation =
                particles::resolved::signedDistanceToParticle(particle,
                                                              center) +
                particles::access::getEnlargementForContact(particle);
            if (!util::nearZero(indentation)) {
              const PhysR<T, D> origin =
                  center -
                  contactNormal *
                      particles::access::getEnlargementForContact(particle);
              indentation = particles::resolved::distanceToParticle(
                  particle, origin, contactNormal, distancePrecision);
            }
            T distToWall;
            if (solidBoundary.getIndicator()->distance(distToWall, center,
                                                       distancePrecision,
                                                       -1 * contactNormal)) {
              indentation +=
                  distToWall + solidBoundary.getEnlargementForContact();
            }
#ifdef OLB_DEBUG
            else if (!util::nearZero(
                         solidBoundary.getIndicator()->signedDistance(
                             center))) {
              OstreamManager clout(std::cout, "forceApplication");
              clout << "WARNING: No distance to wall determined." << std::endl;
            }
#endif
            return indentation;
          };
      // function to apply force on particles
      const std::function<void(const Vector<T, D>&, const Vector<T, D>&, T, T)>
          applyForce = [&](const Vector<T, D>& center,
                           const Vector<T, D>& contactNormal, T indentation,
                           T overlapVolume) {
            const unsigned particleMaterial =
                particle.template getField<MECHPROPERTIES, MATERIAL>();
            const unsigned wallMaterial = solidBoundary.getContactMaterial();
 
            indentationDepth          = indentation;
            const Vector<T, D> relVel = evalRelativeVelocity(particle, center);
            const T            dampingFactor = evalCurrentDampingFactor(
                contact,
                contactProperties.getCoefficientOfRestitution(particleMaterial,
                                                                         wallMaterial),
                evalRelativeNormalVelocity(contactNormal, relVel));
 
            applyForceFromOverlapVolume(
                dataMap, particle, particleSystem, solidBoundary, center,
                contactNormal, indentation, overlapVolume, relVel,
                dampingFactor, contactProperties, k, contact.getParticleID(),
                contact.getWallID(), processContactForce);
          };
 
      processContactViaVolume(contact.getMin(), contact.getMax(), physDeltaX,
                              contactBoxResolutionPerDirection, resetMinMax,
                              processCellWrapped, calculateIndentation,
                              applyForce);
    }
  }

References olb::particles::contact::applyForceFromOverlapVolume(), olb::particles::resolved::distanceToParticle(), olb::particles::contact::evalCurrentDampingFactor(), olb::particles::contact::evalRelativeNormalVelocity(), olb::particles::contact::evalRelativeVelocity(), olb::SolidBoundary< T, D >::getContactMaterial(), olb::SolidBoundary< T, D >::getEnlargementForContact(), olb::particles::access::getEnlargementForContact(), olb::SolidBoundary< T, D >::getIndicator(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMax(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMin(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getParticleID(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getWallID(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::isEmpty(), olb::util::nearZero(), olb::particles::contact::processCell(), olb::particles::contact::processContactViaVolume(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::resetMinMax(), and olb::particles::resolved::signedDistanceToParticle().

Here is the call graph for this function:

apply() [2/2]

template<typename T , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>

template<typename CONTACTPROPERTIES , typename F1 = decltype(defaults::periodicity<PARTICLETYPE::d>), typename F2 = decltype(defaults::processContactForce<T, PARTICLETYPE::d>)>

static void olb::particles::contact::particle_wall< T, PARTICLETYPE, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, BBCORRECTIONMETHOD, CONVEX, useSDF >::apply ( XParticleSystem< T, PARTICLETYPE > & particleSystem, std::vector< SolidBoundary< T, PARTICLETYPE::d > > & solidBoundaries, ContactContainer< T, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > > & contactContainer, const CONTACTPROPERTIES & contactProperties, const SuperGeometry< T, PARTICLETYPE::d > & sGeometry, std::multimap< int, std::unique_ptr< std::uint8_t[]> > & dataMap, const unsigned contactBoxResolutionPerDirection = 8, const T k = T {4. / (3 * util::sqrt(M_PI))}, F1 getSetupPeriodicity = defaults::periodicity<PARTICLETYPE::d>, F2 processContactForce = defaults::processContactForce<T, PARTICLETYPE::d> )

inlinestatic

Definition at line 1512 of file particleContactForceFunctions.h.

                                   {4. / (3 * util::sqrt(M_PI))},
        F1 getSetupPeriodicity = defaults::periodicity<PARTICLETYPE::d>,
        F2 processContactForce =
            defaults::processContactForce<T, PARTICLETYPE::d>)
  {
    using namespace descriptors;
    const T physDeltaX =
        sGeometry.getCuboidGeometry().getMotherCuboid().getDeltaR();
 
    for (auto& wallContact : contactContainer.wallContacts) {
      if (!wallContact.isEmpty()) {
        bool isResponsible = true;
 
        if constexpr (access::providesParallelization<PARTICLETYPE>()) {
          isResponsible =
              singleton::mpi().getRank() == wallContact.getResponsibleRank();
        }
 
        if (isResponsible) {
          // Check if contact should be computed
          bool computeContact = true;
          if constexpr (access::providesComputeContact<PARTICLETYPE>()) {
            auto particle  = particleSystem.get(wallContact.getParticleID());
            computeContact = access::isContactComputationEnabled(particle);
          }
 
          if (computeContact) {
            PhysR<T, PARTICLETYPE::d> originalPos;
            if constexpr (isPeriodic(getSetupPeriodicity())) {
              auto particle = particleSystem.get(wallContact.getParticleID());
              originalPos   = particle.template getField<GENERAL, POSITION>();
              particle.template setField<GENERAL, POSITION>(
                  wallContact.getParticlePosition());
            }
 
            if (wallContact.isNew()) {
              correctBoundingBoxNewContact(particleSystem, solidBoundaries,
                                           wallContact, physDeltaX,
                                           contactBoxResolutionPerDirection);
              wallContact.isNew(wallContact.isEmpty());
            }
            else {
              if constexpr (BBCORRECTIONMETHOD == 1) {
                correctBoundingBoxExistingContact(
                    particleSystem, solidBoundaries, wallContact, physDeltaX,
                    contactBoxResolutionPerDirection);
              }
              else {
                correctBoundingBox(particleSystem, solidBoundaries, wallContact,
                                   physDeltaX,
                                   contactBoxResolutionPerDirection);
              }
            }
            apply(dataMap, particleSystem, solidBoundaries, wallContact,
                  contactProperties, physDeltaX,
                  contactBoxResolutionPerDirection, k, processContactForce);
 
            if constexpr (isPeriodic(getSetupPeriodicity())) {
              particleSystem.get(wallContact.getParticleID())
                  .template setField<GENERAL, POSITION>(originalPos);
              // TODO: Set that unfied position is not set anymore
            }
            wallContact.setParticlePositionUpdated(false);
          }
          else {
            // if contact should be ignored, reset min and max so that it counts
            // as empty and can be deleted during the next cleanContact() call.
            wallContact.resetMinMax();
          }
        }
      }
    }
  }

References M_PI, and olb::util::sqrt().

Here is the call graph for this function:

correctBoundingBox()

template<typename T , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>

static void olb::particles::contact::particle_wall< T, PARTICLETYPE, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, BBCORRECTIONMETHOD, CONVEX, useSDF >::correctBoundingBox ( XParticleSystem< T, PARTICLETYPE > & particleSystem, std::vector< SolidBoundary< T, PARTICLETYPE::d > > & solidBoundaries, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > & contact, const T physDeltaX, const unsigned contactBoxResolutionPerDirection )

inlinestatic

Definition at line 1455 of file particleContactForceFunctions.h.

  {
    using namespace descriptors;
    constexpr unsigned D = PARTICLETYPE::d;
 
    Vector<T, D> contactPhysDeltaX =
        evalContactDeltaX(contact.getMin(), contact.getMax(), physDeltaX,
                          contactBoxResolutionPerDirection);
    contact.increaseMinMax(T {0.5} * util::sqrt(D) * contactPhysDeltaX);
    correctBoundingBoxNewContact(particleSystem, solidBoundaries, contact,
                                 physDeltaX, contactBoxResolutionPerDirection);
  }

References olb::particles::contact::correctBoundingBoxNewContact(), olb::particles::contact::evalContactDeltaX(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMax(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMin(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::increaseMinMax(), and olb::util::sqrt().

Here is the call graph for this function:

correctBoundingBoxExistingContact()

template<typename T , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>

static void olb::particles::contact::particle_wall< T, PARTICLETYPE, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, BBCORRECTIONMETHOD, CONVEX, useSDF >::correctBoundingBoxExistingContact ( XParticleSystem< T, PARTICLETYPE > & particleSystem, std::vector< SolidBoundary< T, PARTICLETYPE::d > > & solidBoundaries, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > & contact, const T physDeltaX, const unsigned contactBoxResolutionPerDirection )

inlinestatic

Definition at line 1473 of file particleContactForceFunctions.h.

  {
    using namespace descriptors;
    constexpr unsigned D = PARTICLETYPE::d;
 
    auto                 particle = particleSystem.get(contact.getParticleID());
    SolidBoundary<T, D>& solidBoundary = solidBoundaries[contact.getWallID()];
 
    const std::function<bool(const PhysR<T, D>&)> isInsideContact =
        [&](const Vector<T, D>& pos) {
          bool                          isInsideWall;
          solidBoundary.getIndicator()->operator()(&isInsideWall, pos.data());
          return particles::resolved::isInsideParticle(particle, pos) &&
                 isInsideWall;
        };
    const std::function<void()> resetMinMax = [&contact]() {
      contact.resetMinMax();
    };
    const std::function<void(const PhysR<T, D>&)> updateMinMax =
        [&contact](const PhysR<T, D>& pos) {
          contact.updateMinMax(pos);
        };
 
    particles::contact::correctBoundingBox(
        contact.getMin(), contact.getMax(), physDeltaX,
        contactBoxResolutionPerDirection, isInsideContact, resetMinMax,
        updateMinMax);
  }

References olb::particles::contact::correctBoundingBox(), olb::SolidBoundary< T, D >::getIndicator(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMax(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMin(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getParticleID(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getWallID(), olb::particles::resolved::isInsideParticle(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::resetMinMax(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::updateMinMax(), and olb::particles::contact::updateMinMax().

Here is the call graph for this function:

correctBoundingBoxNewContact()

template<typename T , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>

static void olb::particles::contact::particle_wall< T, PARTICLETYPE, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, BBCORRECTIONMETHOD, CONVEX, useSDF >::correctBoundingBoxNewContact ( XParticleSystem< T, PARTICLETYPE > & particleSystem, std::vector< SolidBoundary< T, PARTICLETYPE::d > > & solidBoundaries, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > & contact, const T physDeltaX, const unsigned contactBoxResolutionPerDirection )

inlinestatic

Definition at line 1421 of file particleContactForceFunctions.h.

  {
    using namespace descriptors;
    constexpr unsigned D = PARTICLETYPE::d;
 
    Particle<T, PARTICLETYPE> particle =
        particleSystem.get(contact.getParticleID());
    SolidBoundary<T, D>& solidBoundary = solidBoundaries[contact.getWallID()];
 
    // TODO: Is there a better way to increase the particle size than sdf::rounding?
    particles::contact::correctBoundingBoxNewContact(
        contact.getMin(), contact.getMax(), physDeltaX,
        contactBoxResolutionPerDirection,
        [&](const PhysR<T, D>& pos) {
          return sdf::intersection(
              sdf::rounding(
                  particles::resolved::signedDistanceToParticle(particle, pos),
                  particles::access::getEnlargementForContact(particle)),
              sdf::rounding(solidBoundary.getIndicator()->signedDistance(pos),
                            solidBoundary.getEnlargementForContact()));
        },
        [&contact]() {
          contact.resetMinMax();
        },
        [&contact](const PhysR<T, D>& pos) {
          contact.updateMinMax(pos);
        });
  }

References olb::particles::contact::correctBoundingBoxNewContact(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMax(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMin(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getParticleID(), and olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::getWallID().

Here is the call graph for this function:

processCell()

template<typename T , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>

static void olb::particles::contact::particle_wall< T, PARTICLETYPE, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, BBCORRECTIONMETHOD, CONVEX, useSDF >::processCell ( WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > & contact, Particle< T, PARTICLETYPE > & particle, SolidBoundary< T, PARTICLETYPE::d > & solidBoundary, Vector< T, PARTICLETYPE::d > & contactNormal, Vector< T, PARTICLETYPE::d > & center, unsigned & volumeCellCount, T & surfaceCellCount, const Vector< T, PARTICLETYPE::d > & pos, const Vector< T, PARTICLETYPE::d > & contactPhysDeltaX )

inlinestatic

Definition at line 1244 of file particleContactForceFunctions.h.

  {
    /* OstreamManager     clout(std::cout, "cellProcessingForContactForce"); */
    constexpr unsigned D = PARTICLETYPE::d;
 
    // Check if pos is inside contact
    const std::function<bool(const PhysR<T, D>&)> isInside =
        [&](const PhysR<T, D>& pos) {
          bool const isInsideIndicator =
              solidBoundary.getIndicator()->signedDistance(pos.data()) <=
              solidBoundary.getEnlargementForContact();
          bool const isInsideParticle =
              particles::resolved::signedDistanceToParticle(particle, pos) <=
              particles::access::getEnlargementForContact(particle);
          return isInsideParticle && isInsideIndicator;
        };
 
    // Check if pos is on surface
    const std::function<bool(const PhysR<T, D>&, const PhysR<T, D>&, bool&,
                             bool&, const Vector<T, D>&, const Vector<T, D>&)>
        isOnSurface = [&](const PhysR<T, D>& pos,
                          const PhysR<T, D>& contactPhysDeltaX,
                          bool& onSurfaceA, bool& onSurfaceB,
                          const Vector<T, D>& normalA,
                          const Vector<T, D>& normalB) {
          Vector<T, D> neighbor;
          for (unsigned iD = 0; iD < D; ++iD) {
            neighbor[iD] = -normalA[iD] * contactPhysDeltaX[iD];
          }
          onSurfaceA = particles::resolved::signedDistanceToParticle(
                           particle, pos + neighbor) <=
                       particles::access::getEnlargementForContact(particle);
          for (unsigned iD = 0; iD < D; ++iD) {
            neighbor[iD] = -normalB[iD] * contactPhysDeltaX[iD];
          }
          onSurfaceB = solidBoundary.getIndicator()->signedDistance(
                           (pos + neighbor).data()) <=
                       solidBoundary.getEnlargementForContact();
          return onSurfaceA || onSurfaceB;
        };
 
    // Calculate normal to particle surface
    const std::function<Vector<T, D>(const PhysR<T, D>&, const T)> calcNormalA =
        [&](const PhysR<T, D>& pos, const T meshSize) {
          // also with an enlarged particle, the normal should still point the same way, since we apply an equal layer to the whole surface
          return particles::resolved::normalOnParticleSurface(particle, pos,
                                                              meshSize);
        };
    // Calculate normal to indicator surface
    const std::function<Vector<T, D>(const PhysR<T, D>&, const T)> calcNormalB =
        [&](const PhysR<T, D>& pos, const T meshSize) {
          return solidBoundary.getIndicator()->surfaceNormal(pos, meshSize);
        };
    // Wrapper for update of min and max
    const std::function<void(const PhysR<T, D>&)> updateMinMax =
        [&contact](const PhysR<T, D>& pos) {
          contact.updateMinMax(pos);
        };
 
    particles::contact::processCell(pos, contactPhysDeltaX, center,
                                    contactNormal, volumeCellCount,
                                    surfaceCellCount, isInside, isOnSurface,
                                    calcNormalA, calcNormalB, updateMinMax);
  }

References olb::Vector< T, D >::data(), olb::SolidBoundary< T, D >::getEnlargementForContact(), olb::particles::access::getEnlargementForContact(), olb::SolidBoundary< T, D >::getIndicator(), olb::particles::resolved::normalOnParticleSurface(), olb::particles::contact::processCell(), olb::particles::resolved::signedDistanceToParticle(), olb::particles::contact::WallContactArbitraryFromOverlapVolume< T, D, CONVEX >::updateMinMax(), and olb::particles::contact::updateMinMax().

Here is the call graph for this function:

resetContainer()

template<typename T , typename PARTICLETYPE , typename PARTICLECONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>

static void olb::particles::contact::particle_wall< T, PARTICLETYPE, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, BBCORRECTIONMETHOD, CONVEX, useSDF >::resetContainer ( ContactContainer< T, PARTICLECONTACTTYPE, WallContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > > & contactContainer )

inlinestatic

Definition at line 1232 of file particleContactForceFunctions.h.

  {
    for (auto& contact : contactContainer.wallContacts) {
      contact.resetMinMax();
    }
  }

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

Here is the call graph for this function:

---

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

• src/particles/functions/particleContactForceFunctions.h