olb::particles::resolved Namespace Reference

Classes
struct	population_momentum_exchange
struct	population_momentum_exchange< T, 2, false >
struct	population_momentum_exchange< T, 2, true >
struct	population_momentum_exchange< T, 3, false >
struct	population_momentum_exchange< T, 3, true >

Functions
template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >
bool	momentumExchangeAtSurfaceLocation (T momentumExchange[], PhysR< T, DESCRIPTOR::d > &lever, const LatticeR< DESCRIPTOR::d > &latticeRinner, const BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, BlockLattice< T, DESCRIPTOR > &blockLattice, const UnitConverter< T, DESCRIPTOR > &converter, Particle< T, PARTICLETYPE > &particle, const int bulkMaterial=1)
template<typename T , typename S , typename PARTICLETYPE >
PhysR< S, PARTICLETYPE::d >	transformInput (Particle< T, PARTICLETYPE > &particle, const PhysR< S, PARTICLETYPE::d > &input)
template<typename T , typename S , typename PARTICLETYPE >
PhysR< S, PARTICLETYPE::d >	transformDirection (Particle< T, PARTICLETYPE > &particle, const PhysR< S, PARTICLETYPE::d > &direction)
template<typename T , typename S , typename PARTICLETYPE >
bool	isInsideCircumRadius (Particle< T, PARTICLETYPE > &particle, const PhysR< S, PARTICLETYPE::d > &input)
template<typename T , typename S , typename PARTICLETYPE >
bool	isInsideParticle (Particle< T, PARTICLETYPE > &particle, const PhysR< S, PARTICLETYPE::d > &input)
template<typename T , typename S , typename PARTICLETYPE >
const S	signedDistanceToParticle (Particle< T, PARTICLETYPE > &particle, const PhysR< S, PARTICLETYPE::d > &input)
template<typename T , typename S , typename PARTICLETYPE >
const S	distanceToParticle (Particle< T, PARTICLETYPE > &particle, const Vector< S, PARTICLETYPE::d > &origin, const Vector< S, PARTICLETYPE::d > &direction, S precision, S pitch)
template<typename T , typename S , typename PARTICLETYPE >
const S	distanceToParticle (Particle< T, PARTICLETYPE > &particle, const Vector< S, PARTICLETYPE::d > &origin, const Vector< S, PARTICLETYPE::d > &direction, S precision)
template<typename T , typename S , typename PARTICLETYPE >
Vector< S, PARTICLETYPE::d >	normalOnParticleSurface (Particle< T, PARTICLETYPE > &particle, const Vector< S, PARTICLETYPE::d > &pos, const T meshSize)
template<typename T , typename S , typename PARTICLETYPE >
bool	evalSolidVolumeFraction (T output[], const S input[], Particle< T, PARTICLETYPE > &particle)

Function Documentation

distanceToParticle() [1/2]

template<typename T , typename S , typename PARTICLETYPE >

const S olb::particles::resolved::distanceToParticle	(	Particle< T, PARTICLETYPE > &	particle,
		const Vector< S, PARTICLETYPE::d > &	origin,
		const Vector< S, PARTICLETYPE::d > &	direction,
		S	precision )

Definition at line 175 of file smoothIndicatorInteraction.h.

{
  using namespace descriptors;
  auto sIndicator = particle.template getField<SURFACE, SINDICATOR>();
  PhysR<S, PARTICLETYPE::d> input = transformInput(particle, origin);
  PhysR<S, PARTICLETYPE::d> dir   = transformDirection(particle, direction);
 
  T distance(T(0.));
  if (util::distance(
          distance, input, dir, precision,
          [&](const Vector<T, PARTICLETYPE::d>& input) {
            return sIndicator->signedDistance(input);
          },
          [&](const Vector<T, PARTICLETYPE::d>& pos) {
            // bigger bounding box is usually necessary
            return norm(pos) <= 1.5 * sIndicator->getCircumRadius();
          })) {
    return distance;
  }
  else {
#ifdef OLB_DEBUG
    OstreamManager clout(std::cout, "distanceCalculation");
    clout << "WARNING: Distance to particle in direction "
          << normalize(direction) << " couldn't be calculated." << std::endl;
#endif
    return T(0.);
  }
 
  __builtin_unreachable();
}

References olb::util::distance(), olb::norm(), olb::normalize(), transformDirection(), and transformInput().

Here is the call graph for this function:

distanceToParticle() [2/2]

template<typename T , typename S , typename PARTICLETYPE >

const S olb::particles::resolved::distanceToParticle	(	Particle< T, PARTICLETYPE > &	particle,
		const Vector< S, PARTICLETYPE::d > &	origin,
		const Vector< S, PARTICLETYPE::d > &	direction,
		S	precision,
		S	pitch )

Definition at line 138 of file smoothIndicatorInteraction.h.

{
  using namespace descriptors;
  auto sIndicator = particle.template getField<SURFACE, SINDICATOR>();
  PhysR<S, PARTICLETYPE::d> input = transformInput(particle, origin);
  PhysR<S, PARTICLETYPE::d> dir   = transformDirection(particle, direction);
 
  T distance(T(0.));
  if (util::distance(
          distance, input, dir, precision, pitch,
          [&](bool output[1], const T input[3]) {
            output[0] = sIndicator->signedDistance(
                            PhysR<T, PARTICLETYPE::d>(input)) <= 0;
            return output[0];
          },
          [&](const Vector<T, 3>& pos) {
            // bigger bounding box is usually necessary
            return norm(pos) <= 1.5 * sIndicator->getCircumRadius();
          })) {
    return distance;
  }
  else {
#ifdef OLB_DEBUG
    OstreamManager clout(std::cout, "distanceCalculation");
    clout << "WARNING: Distance to particle in direction "
          << normalize(direction) << " couldn't be calculated." << std::endl;
#endif
    return T(0.);
  }
 
  __builtin_unreachable();
}

References olb::util::distance(), olb::norm(), olb::normalize(), transformDirection(), and transformInput().

Here is the call graph for this function:

Here is the caller graph for this function:

evalSolidVolumeFraction()

template<typename T , typename S , typename PARTICLETYPE >

bool olb::particles::resolved::evalSolidVolumeFraction	(	T	output[],
		const S	input[],
		Particle< T, PARTICLETYPE > &	particle )

Definition at line 225 of file smoothIndicatorInteraction.h.

{
  using namespace descriptors;
  auto    sIndicator = particle.template getField<SURFACE, SINDICATOR>();
  T const signedDist =
      signedDistanceToParticle(particle, PhysR<S, PARTICLETYPE::d>(input));
  return sdf::evalSolidVolumeFraction(output, signedDist,
                                      sIndicator->getEpsilon());
}

References olb::sdf::evalSolidVolumeFraction(), and signedDistanceToParticle().

Here is the call graph for this function:

Here is the caller graph for this function:

isInsideCircumRadius()

template<typename T , typename S , typename PARTICLETYPE >

bool olb::particles::resolved::isInsideCircumRadius	(	Particle< T, PARTICLETYPE > &	particle,
		const PhysR< S, PARTICLETYPE::d > &	input )

Definition at line 86 of file smoothIndicatorInteraction.h.

{
  using namespace descriptors;
  auto sIndicator = access::getSmoothIndicatorPtr(particle);
  return norm(access::getPosition(particle) - input) <=
         sIndicator->getCircumRadius();
}

References olb::particles::access::getPosition(), olb::particles::access::getSmoothIndicatorPtr(), and olb::norm().

Here is the call graph for this function:

Here is the caller graph for this function:

isInsideParticle()

template<typename T , typename S , typename PARTICLETYPE >

bool olb::particles::resolved::isInsideParticle	(	Particle< T, PARTICLETYPE > &	particle,
		const PhysR< S, PARTICLETYPE::d > &	input )

Definition at line 96 of file smoothIndicatorInteraction.h.

{
  using namespace descriptors;
  auto sIndicator = access::getSmoothIndicatorPtr(particle);
 
  if (!isInsideCircumRadius(particle, input)) {
    return false;
  }
 
  PhysR<S, PARTICLETYPE::d> newInput = transformInput(particle, input);
  return sIndicator->signedDistance(newInput) <= 0;
}

References olb::particles::access::getSmoothIndicatorPtr(), isInsideCircumRadius(), and transformInput().

Here is the call graph for this function:

Here is the caller graph for this function:

momentumExchangeAtSurfaceLocation()

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

bool olb::particles::resolved::momentumExchangeAtSurfaceLocation	(	T	momentumExchange[],
		PhysR< T, DESCRIPTOR::d > &	lever,
		const LatticeR< DESCRIPTOR::d > &	latticeRinner,
		const BlockGeometry< T, DESCRIPTOR::d > &	blockGeometry,
		BlockLattice< T, DESCRIPTOR > &	blockLattice,
		const UnitConverter< T, DESCRIPTOR > &	converter,
		Particle< T, PARTICLETYPE > &	particle,
		const int	bulkMaterial = 1 )

Definition at line 76 of file momentumExchangeForce.h.

{
 
  using namespace descriptors;
  constexpr unsigned D = DESCRIPTOR::d;
  auto position = particles::access::getPosition(particle);
 
  //Retrieve grid spacing
  const T deltaR = blockGeometry.getDeltaR();
  //Get inner phys position
  T physRinner[D] = { };
  Vector<T,D> physRV;
  blockGeometry.getPhysR(physRV, latticeRinner);
  for (unsigned iD = 0; iD < D; ++iD) {
    physRinner[iD] = physRV[iD];
  }
  //Retrieve inner porosity
  T porosityInner[1] = { };
  particles::resolved::evalSolidVolumeFraction(porosityInner, physRinner, particle);
  //Check whether particle and bulk is existent at location
  if ( !util::nearZero(porosityInner[0]) && blockGeometry.get(latticeRinner)==bulkMaterial ) {
    //Loop over distribution functions
    for (int iPop = 1; iPop < DESCRIPTOR::q ; ++iPop) {
      //Calculate outer lattice position (get next cell located in current direction)
      const Vector<int,D> c = descriptors::c<DESCRIPTOR>(iPop);
      const LatticeR<D> latticeRouter = latticeRinner + c;
      //Retrieve outer phys position
      T physRouter[D] = {0.};
      Vector<T,D> physRouterV;
      blockGeometry.getPhysR(physRouterV, latticeRouter);
      for (unsigned iD = 0; iD < D; ++iD) {
        physRouter[iD] = physRouterV[iD];
      }
      //Retrieve outer porosity
      T porosityOuter[1] = {0.};
      particles::resolved::evalSolidVolumeFraction(porosityOuter, physRouter, particle);
      //if not both cells are in the full solid domain calculate force
      if ( !(porosityInner[0]==1 && porosityOuter[0]==1) ) {
        //Momentum Exchange Wen
        const T f1 = blockLattice.get( latticeRouter )[iPop];
        const T f2 = blockLattice.get( latticeRinner )[descriptors::opposite<DESCRIPTOR>(iPop)];
        T pVel[D] = {0.};
        for (unsigned iDim=0; iDim<D; ++iDim) {
          pVel[iDim] = converter.getLatticeVelocity(particles::dynamics::calculateLocalVelocity(particle, PhysR<T,D>(physRinner))[iDim]);
          momentumExchange[iDim] -= converter.getPhysForce(
                                      population_momentum_exchange<T,D>::calculate( f1, f2, c[iDim], pVel[iDim], deltaR ) );
        }
 
        // Optional correction of the lubrication force
        if constexpr (particles::access::providesIsInContact<PARTICLETYPE>()) {
          auto contact = particle.template getField<NUMERICPROPERTIES,IS_IN_CONTACT>();
 
          if (contact == 1) {
            T vn = 0.0;
            for (unsigned iDim=0; iDim<D; ++iDim) {
                //std::cout << momentumExchange[iDim];
                vn = vn + util::pow(momentumExchange[iDim],2);
            }
 
            vn = util::sqrt(vn);
 
            auto cell = blockLattice.get(latticeRinner);
            Vector<T,DESCRIPTOR::d> localLatticeFluidVelocity;
            Vector<T,DESCRIPTOR::d> localPhysicalFluidVelocity;
            cell.computeU(localLatticeFluidVelocity.data());
 
            for(unsigned iD=0; iD<D; ++iD) {
                localPhysicalFluidVelocity[iD] = converter.getPhysVelocity(localLatticeFluidVelocity[iD]);
            }
 
            T U = 0.0;
            for (unsigned iDim=0; iDim<D; ++iDim) {
                U = U + util::pow(pVel[iDim]-localLatticeFluidVelocity[iDim],2.0);
            }
            U = util::sqrt(U);
 
 
            T deltaT = converter.getPhysDeltaT();
            T deltaTLattice = converter.getLatticeTime(deltaT);
            T rho_fluid = converter.getPhysDensity();
 
            T factor = 1.0;
 
            T maxForce = converter.getPhysForce(U * converter.getLatticeDensity(rho_fluid)/deltaTLattice)*factor;
 
            if (util::fabs(vn) == 0){
                vn = 0.5 * maxForce;
            }
            if (util::fabs(vn) > util::fabs(maxForce)) {
                T mp = maxForce/vn;
                for (unsigned iDim=0; iDim<D; ++iDim) {
                    //Set the force to the maximal force
                    momentumExchange[iDim] *= mp;
                }
            }
          }
        }
      }
 
    }
    //Calculate lever (necessary for torque calculation)
    lever = PhysR<T,D>(physRinner)-position;
    return true;
  }
  else {
    return false;
  }
}

References olb::descriptors::c(), olb::particles::dynamics::calculateLocalVelocity(), olb::Vector< T, Size >::data(), evalSolidVolumeFraction(), olb::util::fabs(), olb::BlockGeometry< T, D >::get(), olb::BlockGeometry< T, D >::getDeltaR(), olb::UnitConverter< T, DESCRIPTOR >::getLatticeDensity(), olb::UnitConverter< T, DESCRIPTOR >::getLatticeTime(), olb::UnitConverter< T, DESCRIPTOR >::getLatticeVelocity(), olb::UnitConverter< T, DESCRIPTOR >::getPhysDeltaT(), olb::UnitConverter< T, DESCRIPTOR >::getPhysDensity(), olb::UnitConverter< T, DESCRIPTOR >::getPhysForce(), olb::BlockGeometry< T, D >::getPhysR(), olb::UnitConverter< T, DESCRIPTOR >::getPhysVelocity(), olb::particles::access::getPosition(), olb::util::nearZero(), olb::descriptors::opposite(), olb::util::pow(), olb::particles::access::providesIsInContact(), and olb::util::sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

normalOnParticleSurface()

template<typename T , typename S , typename PARTICLETYPE >

Vector< S, PARTICLETYPE::d > olb::particles::resolved::normalOnParticleSurface	(	Particle< T, PARTICLETYPE > &	particle,
		const Vector< S, PARTICLETYPE::d > &	pos,
		const T	meshSize )

Definition at line 211 of file smoothIndicatorInteraction.h.

{
  using namespace descriptors;
  constexpr unsigned D = PARTICLETYPE::d;
  auto sIndicator      = particle.template getField<SURFACE, SINDICATOR>();
 
  // the following gives us the option to overload the calculation of the surface normal for different indicators
  return sIndicator->surfaceNormal(pos, meshSize, [&](const Vector<S, D>& pos) {
    return transformInput(particle, pos);
  });
}

References transformInput().

Here is the call graph for this function:

Here is the caller graph for this function:

signedDistanceToParticle()

template<typename T , typename S , typename PARTICLETYPE >

const S olb::particles::resolved::signedDistanceToParticle	(	Particle< T, PARTICLETYPE > &	particle,
		const PhysR< S, PARTICLETYPE::d > &	input )

Definition at line 111 of file smoothIndicatorInteraction.h.

{
  using namespace descriptors;
  auto sIndicator = particle.template getField<SURFACE, SINDICATOR>();
  PhysR<S, PARTICLETYPE::d> newInput = transformInput(particle, input);
 
  //Check whether elongation provided
  if constexpr (access::providesElongation<PARTICLETYPE>()) {
    const unsigned D = PARTICLETYPE::d;
    //Retrieve original sdf
    std::function<S(const Vector<S, D>&)> sdf =
        [&sIndicator](const Vector<S, D>& input) {
          return sIndicator->signedDistance(input);
        };
    //Retrieve elongation
    auto elongation = access::getElongation(particle);
    //Return elongated whapper
    constexpr bool symmetryCheck = false; //User responsibility here.
    return sdf::elongation<T, symmetryCheck>(sdf, newInput, elongation);
  }
  else {
    return sIndicator->signedDistance(newInput);
  }
}

References olb::sdf::elongation(), olb::particles::access::getElongation(), olb::particles::access::providesElongation(), and transformInput().

Here is the call graph for this function:

Here is the caller graph for this function:

transformDirection()

template<typename T , typename S , typename PARTICLETYPE >

PhysR< S, PARTICLETYPE::d > olb::particles::resolved::transformDirection	(	Particle< T, PARTICLETYPE > &	particle,
		const PhysR< S, PARTICLETYPE::d > &	direction )

Definition at line 66 of file smoothIndicatorInteraction.h.

{
  constexpr unsigned D = PARTICLETYPE::d;
  using namespace descriptors;
 
  if constexpr (PARTICLETYPE::template providesNested<SURFACE, ROT_MATRIX>()) {
    const Vector<T, utilities::dimensions::convert<D>::matrix> rotationMatrix =
        util::invertRotationMatrix<T, D>(
            particle.template getField<SURFACE, ROT_MATRIX>());
    return util::executeRotation<T, D>(direction, rotationMatrix);
  }
  else {
    return direction;
  }
 
  __builtin_unreachable();
}

References olb::util::executeRotation(), and olb::util::invertRotationMatrix().

Here is the call graph for this function:

Here is the caller graph for this function:

transformInput()

template<typename T , typename S , typename PARTICLETYPE >

PhysR< S, PARTICLETYPE::d > olb::particles::resolved::transformInput	(	Particle< T, PARTICLETYPE > &	particle,
		const PhysR< S, PARTICLETYPE::d > &	input )

Definition at line 44 of file smoothIndicatorInteraction.h.

{
  using namespace descriptors;
  constexpr unsigned D = PARTICLETYPE::d;
 
  const PhysR<T, D> position = particle.template getField<GENERAL, POSITION>();
  if constexpr (PARTICLETYPE::template providesNested<SURFACE, ROT_MATRIX>()) {
    const Vector<T, utilities::dimensions::convert<D>::matrix> rotationMatrix =
        util::invertRotationMatrix<T, D>(
            particle.template getField<SURFACE, ROT_MATRIX>());
    return util::executeRotation<T, D, true>(input, rotationMatrix, position);
  }
  else {
    return input - position;
  }
 
  __builtin_unreachable();
}

References olb::util::executeRotation(), and olb::util::invertRotationMatrix().

Here is the call graph for this function:

Here is the caller graph for this function: