olb::VortexMethodPreProcessor Struct Reference

#include <vortexMethod.h>

Collaboration diagram for olb::VortexMethodPreProcessor:

Public Types
using	parameters

Public Member Functions
int	getPriority () const
template<typename CELL , typename PARAMETERS , typename V = typename CELL::value_t>
Vector< V, 3 >	computeVelocityGradient (CELL &cell, PARAMETERS &parameters) any_platform
template<typename CELL , typename PARAMETERS >
void	apply (CELL &cell, PARAMETERS &parameters) any_platform

Static Public Attributes
static constexpr OperatorScope	scope = OperatorScope::PerCellWithParameters

Detailed Description

Definition at line 296 of file vortexMethod.h.

Member Typedef Documentation

parameters

using olb::VortexMethodPreProcessor::parameters

Initial value:

 meta::list<
    SEEDS_COUNT,
    SEEDS,
    SEEDS_VORTICITY,
    CONVERSION_FACTOR_LENGTH,
    CONVERSION_FACTOR_VELOCITY,
    AXIS_DIRECTION,
    SIGMA
  >

Definition at line 297 of file vortexMethod.h.

Member Function Documentation

apply()

template<typename CELL , typename PARAMETERS >

void olb::VortexMethodPreProcessor::apply ( CELL & cell, PARAMETERS & parameters )

inline

Definition at line 336 of file vortexMethod.h.

                                                              {
    using V = typename CELL::value_t;
    using DESCRIPTOR = typename CELL::descriptor_t;
 
    const auto seeds = parameters.template get<SEEDS>();
    const auto seedsVorticity = parameters.template get<SEEDS_VORTICITY>();
    const auto axisDirection = parameters.template get<AXIS_DIRECTION>();
    const auto sigma = parameters.template get<SIGMA>();
 
    Vector<V,DESCRIPTOR::d> x = cell.template getField<descriptors::LOCATION>();
    Vector<V,DESCRIPTOR::d> output = cell.template getField<U_PROFILE>();
    const V conversionFactorVelocity = parameters.template get<CONVERSION_FACTOR_VELOCITY>();
    output /= conversionFactorVelocity;
 
    // calculation of velocities from the placed vortexes
    Vector<V,3> uVortex {0, 0, 0};
    for (std::size_t j=0; j < parameters.template get<SEEDS_COUNT>(); ++j) {
      Vector<V,DESCRIPTOR::d> diffX = {0,0,0};
      for (int iD = 0; iD < DESCRIPTOR::d; ++iD) {
        diffX[iD] = seeds[iD][j] - x[iD];
      }
      Vector<V,3> crossP = crossProduct3D(diffX, axisDirection);
      V norm2 = diffX[0]*diffX[0] + diffX[1]*diffX[1] + diffX[2]*diffX[2];
      V expTerm = util::exp(V{-0.5}*norm2/(sigma*sigma));
      uVortex += (V{0.5}/M_PI * seedsVorticity[j] * crossP / norm2 * (V{1} - expTerm)*expTerm) / conversionFactorVelocity;
    }
 
    // calculation of the fluctuation streamwise with Langevin equation
    auto grad = computeVelocityGradient(cell, parameters);
    V normGrad = olb::norm(grad);
    if (normGrad == V{0}) {
      normGrad = 1;
    }
    V streamFluct = -(uVortex*grad);
    streamFluct /= normGrad;
 
    output += uVortex + streamFluct * axisDirection;
 
    cell.defineU(output.data());
  }

References computeVelocityGradient(), olb::crossProduct3D(), olb::Vector< T, D >::data(), olb::util::exp(), M_PI, and olb::norm().

Here is the call graph for this function:

computeVelocityGradient()

template<typename CELL , typename PARAMETERS , typename V = typename CELL::value_t>

Vector< V, 3 > olb::VortexMethodPreProcessor::computeVelocityGradient ( CELL & cell, PARAMETERS & parameters )

inline

Definition at line 314 of file vortexMethod.h.

  {
    const V dx = parameters.template get<CONVERSION_FACTOR_LENGTH>();
    Vector<V,3> actVel = cell.template getField<VELOCITY_OLD>();
    V aXPlus = util::max(actVel[0], 0); V aXMinus = util::min(actVel[0], 0);
    V aYPlus = util::max(actVel[1], 0); V aYMinus = util::min(actVel[1], 0);
    V aZPlus = util::max(actVel[2], 0); V aZMinus = util::min(actVel[2], 0);
    Vector<V,3> uXPlus  = cell.neighbor({ 1,  0,  0}).template getField<VELOCITY_OLD>();
    Vector<V,3> uXMinus = cell.neighbor({-1,  0,  0}).template getField<VELOCITY_OLD>();
    Vector<V,3> uYPlus  = cell.neighbor({ 0,  1,  0}).template getField<VELOCITY_OLD>();
    Vector<V,3> uYMinus = cell.neighbor({ 0, -1,  0}).template getField<VELOCITY_OLD>();
    Vector<V,3> uZPlus  = cell.neighbor({ 0,  0,  1}).template getField<VELOCITY_OLD>();
    Vector<V,3> uZMinus = cell.neighbor({ 0,  0, -1}).template getField<VELOCITY_OLD>();
    Vector<V,3> grad;
    const V actVelNorm = olb::norm(actVel);
    grad[0] = -aXPlus*(actVelNorm - olb::norm(uXMinus))/dx - aXMinus*(olb::norm(uXPlus) - actVelNorm)/dx;
    grad[1] = -aYPlus*(actVelNorm - olb::norm(uYMinus))/dx - aYMinus*(olb::norm(uYPlus) - actVelNorm)/dx;
    grad[2] = -aZPlus*(actVelNorm - olb::norm(uZMinus))/dx - aZMinus*(olb::norm(uZPlus) - actVelNorm)/dx;
    return grad;
  }

References olb::util::max(), olb::util::min(), and olb::norm().

Here is the call graph for this function:

Here is the caller graph for this function:

getPriority()

int olb::VortexMethodPreProcessor::getPriority ( ) const

inline

Definition at line 309 of file vortexMethod.h.

                          {
    return 0;
  }

Member Data Documentation

scope

constexpr OperatorScope olb::VortexMethodPreProcessor::scope = OperatorScope::PerCellWithParameters

staticconstexpr

Definition at line 307 of file vortexMethod.h.

---

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

• src/boundary/vortexMethod.h