OpenLB 1.7
Loading...
Searching...
No Matches
Static Public Member Functions | List of all members
olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF > Struct Template Reference

#include <particleContactForceFunctions.h>

+ Collaboration diagram for olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF >:

Static Public Member Functions

static void resetContainer (ContactContainer< T, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE > &contactContainer)
 
static void processCell (ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > &contact, Particle< T, PARTICLETYPE > &particleA, Particle< T, PARTICLETYPE > &particleB, 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, ParticleContactArbitraryFromOverlapVolume< 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, ParticleContactArbitraryFromOverlapVolume< 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, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > &contact, T physDeltaX, 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, ContactContainer< T, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE > &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 WALLCONTACTTYPE, unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>
struct olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF >

Definition at line 863 of file particleContactForceFunctions.h.

Member Function Documentation

◆ apply() [1/2]

template<typename T , typename PARTICLETYPE , typename WALLCONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>
template<typename CONTACTPROPERTIES , typename F = decltype(defaults::processContactForce<T, PARTICLETYPE::d>)>
static void olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF >::apply ( std::multimap< int, std::unique_ptr< std::uint8_t[]> > & dataMap,
XParticleSystem< T, PARTICLETYPE > & particleSystem,
ParticleContactArbitraryFromOverlapVolume< 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 955 of file particleContactForceFunctions.h.

963 {
964 using namespace descriptors;
965 constexpr unsigned D = PARTICLETYPE::d;
966
967 // indentation depth
968 T indentationDepth = T(0.);
969
970 if (!contact.isEmpty()) {
971 OstreamManager clout(std::cout, "forceApplication");
972 // particles in contact
973 auto particleA = particleSystem.get(contact.getIDs()[0]);
974 auto particleB = particleSystem.get(contact.getIDs()[1]);
975
976 // function to reset min & max of bounding box
977 const std::function<void()> resetMinMax = [&contact]() {
978 contact.resetMinMax();
979 };
980 // wrapper for cell processing to calculate contact point and normal
981 const std::function<void(Vector<T, D>&, Vector<T, D>&, unsigned&, T&,
982 const Vector<T, D>&, const Vector<T, D>&)>
983 processCellWrapped =
984 [&](Vector<T, D>& contactNormal, Vector<T, D>& center,
985 unsigned& volumeCellCount, T& surfaceCellCount,
986 const Vector<T, D>& physPos,
987 const Vector<T, D>& contactPhysDeltaX) {
988 processCell(contact, particleA, particleB, contactNormal,
989 center, volumeCellCount, surfaceCellCount, physPos,
990 contactPhysDeltaX);
991 };
992 // function to calculate indendation depth
993 const std::function<T(const Vector<T, D>&, const Vector<T, D>&, const T)>
994 calculateIndentation = [&](const Vector<T, D>& center,
995 const Vector<T, D>& contactNormal,
996 const T distancePrecision) {
997 const PhysR<T, D> originA =
998 center -
999 contactNormal *
1000 particles::access::getEnlargementForContact(particleA);
1001 const PhysR<T, D> originB =
1002 center +
1003 contactNormal *
1004 particles::access::getEnlargementForContact(particleB);
1005 T indentation =
1006 particles::resolved::distanceToParticle(
1007 particleA, originA, contactNormal, distancePrecision) +
1008 particles::resolved::distanceToParticle(
1009 particleB, originB, -1 * contactNormal, distancePrecision);
1010 return indentation;
1011 };
1012 // function to apply force on particles
1013 const std::function<void(const Vector<T, D>&, const Vector<T, D>&, T, T)>
1014 applyForce = [&](const Vector<T, D>& center,
1015 const Vector<T, D>& contactNormal, T indentation,
1016 T overlapVolume) {
1017 const unsigned materialA =
1018 particleA.template getField<MECHPROPERTIES, MATERIAL>();
1019 const unsigned materialB =
1020 particleB.template getField<MECHPROPERTIES, MATERIAL>();
1021
1022 indentationDepth = indentation;
1023 const Vector<T, D> relVel =
1024 evalRelativeVelocity(particleA, particleB, center);
1025 const T dampingFactor = evalCurrentDampingFactor(
1026 contact,
1027 contactProperties.getCoefficientOfRestitution(materialA,
1028 materialB),
1029 evalRelativeNormalVelocity(contactNormal, relVel));
1030
1031 applyForceFromOverlapVolume(
1032 dataMap, particleA, particleB, particleSystem, center,
1033 contactNormal, indentation, overlapVolume, relVel,
1034 dampingFactor, contactProperties, k, contact.getIDs()[0],
1035 contact.getIDs()[1], processContactForce);
1036 };
1037
1038 processContactViaVolume(contact.getMin(), contact.getMax(), physDeltaX,
1039 contactBoxResolutionPerDirection, resetMinMax,
1040 processCellWrapped, calculateIndentation,
1041 applyForce);
1042 }
1043 }
olb::particles::access::getEnlargementForContact
T getEnlargementForContact(Particle< T, PARTICLETYPE > particle)
Definition dataAccessWrappers.h:881
olb::particles::contact::evalCurrentDampingFactor
constexpr T evalCurrentDampingFactor(CONTACTTYPE &contact, const T coefficientOfRestitution, const Vector< T, D > &initialRelativeNormalVelocity)
Definition particleContactForceFunctions.h:52
olb::particles::contact::evalRelativeVelocity
constexpr Vector< T, PARTICLETYPE::d > evalRelativeVelocity(Particle< T, PARTICLETYPE > &particleA, Particle< T, PARTICLETYPE > &particleB, const Vector< T, PARTICLETYPE::d > &position)
Returns the relative velocity of two particles at a defined position.
Definition particleContactForceFunctions.h:65
olb::particles::contact::applyForceFromOverlapVolume
void applyForceFromOverlapVolume(std::multimap< int, std::unique_ptr< std::uint8_t[]> > &dataMap, Particle< T, PARTICLETYPE > &particleA, Particle< T, PARTICLETYPE > &particleB, XParticleSystem< T, PARTICLETYPE > &particleSystem, const PhysR< T, PARTICLETYPE::d > &contactPoint, const Vector< T, PARTICLETYPE::d > &contactNormal, const T indentation, const T overlapVolume, const Vector< T, PARTICLETYPE::d > &relVel, const T dampingFactor, const CONTACTPROPERTIES &contactProperties, T k, const std::size_t &particleAID, const std::size_t &particleBID, F processContactForce=defaults::processContactForce< T, PARTICLETYPE::d >)
Definition particleContactForceFunctions.h:403
olb::particles::contact::evalRelativeNormalVelocity
constexpr Vector< T, D > evalRelativeNormalVelocity(const Vector< T, D > &contactNormal, const Vector< T, D > &relVel)
Definition particleContactForceFunctions.h:83
olb::particles::contact::processContactViaVolume
void processContactViaVolume(const Vector< T, D > &min, const Vector< T, D > &max, T physDeltaX, unsigned contactBoxResolutionPerDirection, F1 resetContactBox, F2 processCellWrapped, F3 calculateIndentation, F4 applyForce)
Definition particleContactForceFunctions.h:588
olb::particles::resolved::distanceToParticle
const S distanceToParticle(Particle< T, PARTICLETYPE > &particle, const Vector< S, PARTICLETYPE::d > &origin, const Vector< S, PARTICLETYPE::d > &direction, S precision, S pitch)
Definition smoothIndicatorInteraction.h:138
olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF >::processCell
static void processCell(ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > &contact, Particle< T, PARTICLETYPE > &particleA, Particle< T, PARTICLETYPE > &particleB, 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)
Definition particleContactForceFunctions.h:879

References olb::particles::contact::applyForceFromOverlapVolume(), olb::particles::resolved::distanceToParticle(), olb::particles::contact::evalCurrentDampingFactor(), olb::particles::contact::evalRelativeNormalVelocity(), olb::particles::contact::evalRelativeVelocity(), olb::particles::access::getEnlargementForContact(), 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 >::isEmpty(), olb::particles::contact::processCell(), olb::particles::contact::processContactViaVolume(), and olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::resetMinMax().

+ Here is the call graph for this function:

◆ apply() [2/2]

template<typename T , typename PARTICLETYPE , typename WALLCONTACTTYPE , 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_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF >::apply ( XParticleSystem< T, PARTICLETYPE > & particleSystem,
ContactContainer< T, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE > & 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 1130 of file particleContactForceFunctions.h.

1140 {4. / (3 * util::sqrt(M_PI))},
1141 F1 getSetupPeriodicity = defaults::periodicity<PARTICLETYPE::d>,
1142 F2 processContactForce =
1143 defaults::processContactForce<T, PARTICLETYPE::d>)
1144 {
1145 using namespace descriptors;
1146 const T physDeltaX =
1147 sGeometry.getCuboidGeometry().getMotherCuboid().getDeltaR();
1148
1149 for (auto& particleContact : contactContainer.particleContacts) {
1150 if (!particleContact.isEmpty()) {
1151 bool isResponsible = true;
1152
1153 if constexpr (access::providesParallelization<PARTICLETYPE>()) {
1154 isResponsible = singleton::mpi().getRank() ==
1155 particleContact.getResponsibleRank();
1156 }
1157
1158 if (isResponsible) {
1159 // Check if contact should be computed
1160 bool computeContact = true;
1161 if constexpr (access::providesComputeContact<PARTICLETYPE>()) {
1162 auto particleA = particleSystem.get(particleContact.getIDs()[0]);
1163 auto particleB = particleSystem.get(particleContact.getIDs()[1]);
1164 computeContact =
1165 access::isContactComputationEnabled(particleA, particleB);
1166 }
1167
1168 if (computeContact) {
1169 std::array<PhysR<T, PARTICLETYPE::d>, 2> originalPos;
1170 if constexpr (isPeriodic(getSetupPeriodicity())) {
1171 for (unsigned i = 0; i < 2; ++i) {
1172 auto particle = particleSystem.get(particleContact.getIDs()[i]);
1173 originalPos[i] =
1174 particle.template getField<GENERAL, POSITION>();
1175 particle.template setField<GENERAL, POSITION>(
1176 particleContact.getParticlePositions()[i]);
1177 }
1178 }
1179
1180 if (particleContact.isNew()) {
1181 correctBoundingBoxNewContact(particleSystem, particleContact,
1182 physDeltaX,
1183 contactBoxResolutionPerDirection);
1184 particleContact.isNew(particleContact.isEmpty());
1185 }
1186 else {
1187 if constexpr (BBCORRECTIONMETHOD == 1) {
1188 correctBoundingBoxExistingContact(
1189 particleSystem, particleContact, physDeltaX,
1190 contactBoxResolutionPerDirection);
1191 }
1192 else {
1193 correctBoundingBoxNewContact(particleSystem, particleContact,
1194 physDeltaX,
1195 contactBoxResolutionPerDirection);
1196 }
1197 }
1198 apply(dataMap, particleSystem, particleContact, contactProperties,
1199 physDeltaX, contactBoxResolutionPerDirection, k,
1200 processContactForce);
1201
1202 if constexpr (isPeriodic(getSetupPeriodicity())) {
1203 for (unsigned i = 0; i < 2; ++i) {
1204 auto particle = particleSystem.get(particleContact.getIDs()[i]);
1205 particle.template setField<GENERAL, POSITION>(originalPos[i]);
1206 }
1207 }
1208 particleContact.setParticlePositionUpdated(false);
1209 }
1210 else {
1211 // if contact should be ignored, reset min and max so that it counts
1212 // as empty and can be deleted during the next cleanContact() call.
1213 particleContact.resetMinMax();
1214 }
1215 }
1216 }
1217 }
1218 }
M_PI
#define M_PI
Definition analyticalF.hh:43
olb::singleton::MpiManager::getRank
int getRank() const
Returns the process ID.
Definition mpiManager.cpp:70
olb::particles::access::isContactComputationEnabled
bool isContactComputationEnabled(Particle< T, PARTICLETYPE > &particle)
Check if contact should be regarded (specification for a single particle)
Definition dataAccessWrappers.h:1159
olb::particles::isPeriodic
constexpr bool isPeriodic(const Vector< bool, D > &periodic)
Definition particleDynamicsFunctions.h:42
olb::singleton::mpi
MpiManager & mpi()
Definition mpiManager.cpp:29
olb::util::sqrt
cpu::simd::Pack< T > sqrt(cpu::simd::Pack< T > value)
Definition pack.h:100
olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF >::correctBoundingBoxExistingContact
static void correctBoundingBoxExistingContact(XParticleSystem< T, PARTICLETYPE > &particleSystem, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > &contact, T physDeltaX, unsigned contactBoxResolutionPerDirection)
Definition particleContactForceFunctions.h:1095
olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF >::correctBoundingBoxNewContact
static void correctBoundingBoxNewContact(XParticleSystem< T, PARTICLETYPE > &particleSystem, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > &contact, const T physDeltaX, const unsigned contactBoxResolutionPerDirection)
Definition particleContactForceFunctions.h:1045
olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF >::apply
static void apply(std::multimap< int, std::unique_ptr< std::uint8_t[]> > &dataMap, XParticleSystem< T, PARTICLETYPE > &particleSystem, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > &contact, const CONTACTPROPERTIES &contactProperties, const T physDeltaX, const unsigned contactBoxResolutionPerDirection, const T k, F processContactForce=defaults::processContactForce< T, PARTICLETYPE::d >)
Definition particleContactForceFunctions.h:955

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

+ Here is the call graph for this function:

◆ correctBoundingBox()

template<typename T , typename PARTICLETYPE , typename WALLCONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>
static void olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, 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 1077 of file particleContactForceFunctions.h.

1083 {
1084 using namespace descriptors;
1085 constexpr unsigned D = PARTICLETYPE::d;
1086
1087 Vector<T, D> contactPhysDeltaX =
1088 evalContactDeltaX(contact.getMin(), contact.getMax(), physDeltaX,
1089 contactBoxResolutionPerDirection);
1090 contact.increaseMinMax(T {0.5} * util::sqrt(D) * contactPhysDeltaX);
1091 correctBoundingBoxNewContact(particleSystem, contact, physDeltaX,
1092 contactBoxResolutionPerDirection);
1093 }
olb::particles::contact::evalContactDeltaX
constexpr Vector< T, D > evalContactDeltaX(const Vector< T, D > &min, const Vector< T, D > &max, const T physDeltaX, const unsigned contactBoxResolutionPerDirection)
Definition particleContactForceFunctions.h:148

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 WALLCONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>
static void olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF >::correctBoundingBoxExistingContact ( XParticleSystem< T, PARTICLETYPE > & particleSystem,
ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > & contact,
T physDeltaX,
unsigned contactBoxResolutionPerDirection )
inlinestatic

Definition at line 1095 of file particleContactForceFunctions.h.

1100 {
1101 using namespace descriptors;
1102 constexpr unsigned D = PARTICLETYPE::d;
1103
1104 auto particleA = particleSystem.get(contact.getIDs()[0]);
1105 auto particleB = particleSystem.get(contact.getIDs()[1]);
1106
1107 const std::function<bool(const PhysR<T, D>&)> isInsideContact =
1108 [&](const Vector<T, D>& pos) {
1109 return particles::resolved::isInsideParticle(particleA, pos) &&
1110 particles::resolved::isInsideParticle(particleB, pos);
1111 };
1112 const std::function<void()> resetMinMax = [&contact]() {
1113 contact.resetMinMax();
1114 };
1115 const std::function<void(const PhysR<T, D>&)> updateMinMax =
1116 [&contact](const PhysR<T, D>& pos) {
1117 contact.updateMinMax(pos);
1118 };
1119
1120 particles::contact::correctBoundingBox(
1121 contact.getMin(), contact.getMax(), physDeltaX,
1122 contactBoxResolutionPerDirection, isInsideContact, resetMinMax,
1123 updateMinMax);
1124 }
olb::particles::contact::correctBoundingBox
void correctBoundingBox(const PhysR< T, D > &min, const PhysR< T, D > &max, const T physDeltaX, const unsigned contactBoxResolutionPerDirection, F1 isInsideContact, F2 resetContactBox, F3 updateMinMax)
Definition particleContactForceFunctions.h:731
olb::particles::contact::updateMinMax
void updateMinMax(PhysR< T, D > &min, PhysR< T, D > &max, const PhysR< T, D > &pos)
Definition contactHelpers.h:34
olb::particles::resolved::isInsideParticle
bool isInsideParticle(Particle< T, PARTICLETYPE > &particle, const PhysR< S, PARTICLETYPE::d > &input)
Definition smoothIndicatorInteraction.h:96

References olb::particles::contact::correctBoundingBox(), 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::resolved::isInsideParticle(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::resetMinMax(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::updateMinMax(), and olb::particles::contact::updateMinMax().

+ Here is the call graph for this function:

◆ correctBoundingBoxNewContact()

template<typename T , typename PARTICLETYPE , typename WALLCONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>
static void olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF >::correctBoundingBoxNewContact ( XParticleSystem< T, PARTICLETYPE > & particleSystem,
ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > & contact,
const T physDeltaX,
const unsigned contactBoxResolutionPerDirection )
inlinestatic

Definition at line 1045 of file particleContactForceFunctions.h.

1050 {
1051 using namespace descriptors;
1052 constexpr unsigned D = PARTICLETYPE::d;
1053
1054 auto particleA = particleSystem.get(contact.getIDs()[0]);
1055 auto particleB = particleSystem.get(contact.getIDs()[1]);
1056
1057 particles::contact::correctBoundingBoxNewContact(
1058 contact.getMin(), contact.getMax(), physDeltaX,
1059 contactBoxResolutionPerDirection,
1060 [&](const Vector<T, D>& pos) {
1061 return sdf::intersection(
1062 sdf::rounding(
1063 particles::resolved::signedDistanceToParticle(particleA, pos),
1064 particles::access::getEnlargementForContact(particleA)),
1065 sdf::rounding(
1066 particles::resolved::signedDistanceToParticle(particleB, pos),
1067 particles::access::getEnlargementForContact(particleB)));
1068 },
1069 [&contact]() {
1070 contact.resetMinMax();
1071 },
1072 [&contact](const PhysR<T, D>& pos) {
1073 contact.updateMinMax(pos);
1074 });
1075 }
olb::particles::contact::correctBoundingBoxNewContact
void correctBoundingBoxNewContact(PhysR< T, D > min, PhysR< T, D > max, T physDeltaX, unsigned contactBoxResolutionPerDirection, F1 signedDistanceToIntersection, F2 resetContactBox, F3 updateMinMax)
Definition particleContactForceFunctions.h:766

References olb::particles::contact::correctBoundingBoxNewContact(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getIDs(), olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMax(), and olb::particles::contact::ParticleContactArbitraryFromOverlapVolume< T, D, CONVEX >::getMin().

+ Here is the call graph for this function:

◆ processCell()

template<typename T , typename PARTICLETYPE , typename WALLCONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>
static void olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF >::processCell ( ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX > & contact,
Particle< T, PARTICLETYPE > & particleA,
Particle< T, PARTICLETYPE > & particleB,
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 879 of file particleContactForceFunctions.h.

887 {
888 constexpr unsigned D = PARTICLETYPE::d;
889
890 // Check if pos is inside contact
891 const std::function<bool(const PhysR<T, D>&)> isInside =
892 [&](const PhysR<T, D>& pos) {
893 bool const isInsideParticleA =
894 particles::resolved::signedDistanceToParticle(particleA, pos) <=
895 particles::access::getEnlargementForContact(particleA);
896 bool const isInsideParticleB =
897 particles::resolved::signedDistanceToParticle(particleB, pos) <=
898 particles::access::getEnlargementForContact(particleB);
899 return isInsideParticleA && isInsideParticleB;
900 };
901
902 // Check if pos is on surface
903 const std::function<bool(const PhysR<T, D>&, const PhysR<T, D>&, bool&,
904 bool&, const Vector<T, D>&, const Vector<T, D>&)>
905 isOnSurface = [&](const PhysR<T, D>& pos,
906 const PhysR<T, D>& contactPhysDeltaX,
907 bool& onSurfaceA, bool& onSurfaceB,
908 const Vector<T, D>& normalA,
909 const Vector<T, D>& normalB) {
910 Vector<T, D> neighbor;
911 for (unsigned iD = 0; iD < D; ++iD) {
912 neighbor[iD] = -normalA[iD] * contactPhysDeltaX[iD];
913 }
914 onSurfaceA = particles::resolved::signedDistanceToParticle(
915 particleA, pos + neighbor) <=
916 particles::access::getEnlargementForContact(particleA);
917 for (unsigned iD = 0; iD < D; ++iD) {
918 neighbor[iD] = -normalB[iD] * contactPhysDeltaX[iD];
919 }
920 onSurfaceB = particles::resolved::signedDistanceToParticle(
921 particleB, pos + neighbor) <=
922 particles::access::getEnlargementForContact(particleB);
923 return onSurfaceA || onSurfaceB;
924 };
925
926 // Calculate normal to particle surface
927 const std::function<Vector<T, D>(const PhysR<T, D>&, const T)> calcNormalA =
928 [&](const PhysR<T, D>& pos, const T meshSize) {
929 // also with an enlarged particle, the normal should still point the same way, since we apply an equal layer to the whole surface
930 return particles::resolved::normalOnParticleSurface(particleA, pos,
931 meshSize);
932 };
933 // Calculate normal to indicator surface
934 const std::function<Vector<T, D>(const PhysR<T, D>&, const T)> calcNormalB =
935 [&](const PhysR<T, D>& pos, const T meshSize) {
936 // also with an enlarged particle, the normal should still point the same way, since we apply an equal layer to the whole surface
937 return particles::resolved::normalOnParticleSurface(particleB, pos,
938 meshSize);
939 };
940 // Wrapper for update min and max
941 const std::function<void(const PhysR<T, D>&)> updateMinMax =
942 [&contact](const PhysR<T, D>& pos) {
943 contact.updateMinMax(pos);
944 };
945
946 particles::contact::processCell(pos, contactPhysDeltaX, center,
947 contactNormal, volumeCellCount,
948 surfaceCellCount, isInside, isOnSurface,
949 calcNormalA, calcNormalB, updateMinMax);
950 }
olb::particles::contact::processCell
void processCell(const PhysR< T, D > &pos, const PhysR< T, D > &contactPhysDeltaX, PhysR< T, D > &center, Vector< T, D > &contactNormal, unsigned &volumeCellCount, T &surfaceCellCount, F1 isInside, F2 isOnSurface, F3 calcNormalA, F4 calcNormalB, F5 updateMinMax)
Definition particleContactForceFunctions.h:537
olb::particles::resolved::normalOnParticleSurface
Vector< S, PARTICLETYPE::d > normalOnParticleSurface(Particle< T, PARTICLETYPE > &particle, const Vector< S, PARTICLETYPE::d > &pos, const T meshSize)
Definition smoothIndicatorInteraction.h:211
olb::particles::resolved::signedDistanceToParticle
const S signedDistanceToParticle(Particle< T, PARTICLETYPE > &particle, const PhysR< S, PARTICLETYPE::d > &input)
Definition smoothIndicatorInteraction.h:111

References olb::particles::access::getEnlargementForContact(), olb::particles::resolved::normalOnParticleSurface(), olb::particles::contact::processCell(), olb::particles::resolved::signedDistanceToParticle(), and olb::particles::contact::updateMinMax().

+ Here is the call graph for this function:

◆ resetContainer()

template<typename T , typename PARTICLETYPE , typename WALLCONTACTTYPE , unsigned BBCORRECTIONMETHOD, bool CONVEX, bool useSDF>
static void olb::particles::contact::particle_particle< T, PARTICLETYPE, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE, BBCORRECTIONMETHOD, CONVEX, useSDF >::resetContainer ( ContactContainer< T, ParticleContactArbitraryFromOverlapVolume< T, PARTICLETYPE::d, CONVEX >, WALLCONTACTTYPE > & contactContainer)
inlinestatic

Definition at line 867 of file particleContactForceFunctions.h.

872 {
873 for (auto& contact : contactContainer.particleContacts) {
874 contact.resetMinMax();
875 }
876 }
The documentation for this struct was generated from the following file:
Generated on Tue Mar 5 2024 09:58:10 for OpenLB by doxygen 1.10.0