olb::VortexMethodTurbulentVelocityBoundary< T, DESCRIPTOR > Class Template Reference

#include <vortexMethod.h>

Collaboration diagram for olb::VortexMethodTurbulentVelocityBoundary< T, DESCRIPTOR >:

Public Member Functions
	VortexMethodTurbulentVelocityBoundary (FunctorPtr< SuperIndicatorF3D< T > > &&inletLatticeI, FunctorPtr< IndicatorF3D< T > > &&inletPhysI, UnitConverter< T, DESCRIPTOR > &converter, SuperLattice< T, DESCRIPTOR > &sLattice, int nSeeds, int nTime, T sigma, T intensity, Vector< T, 3 > axisDirection)
void	setProfile (std::shared_ptr< AnalyticalF3D< T, T > > profileF)
void	apply (std::size_t iT)

Detailed Description

template<typename T, typename DESCRIPTOR>
class olb::VortexMethodTurbulentVelocityBoundary< T, DESCRIPTOR >

Definition at line 54 of file vortexMethod.h.

Constructor & Destructor Documentation

VortexMethodTurbulentVelocityBoundary()

template<typename T , typename DESCRIPTOR >

olb::VortexMethodTurbulentVelocityBoundary< T, DESCRIPTOR >::VortexMethodTurbulentVelocityBoundary	(	FunctorPtr< SuperIndicatorF3D< T > > &&	inletLatticeI,
		FunctorPtr< IndicatorF3D< T > > &&	inletPhysI,
		UnitConverter< T, DESCRIPTOR > &	converter,
		SuperLattice< T, DESCRIPTOR > &	sLattice,
		int	nSeeds,
		int	nTime,
		T	sigma,
		T	intensity,
		Vector< T, 3 >	axisDirection )

Definition at line 99 of file vortexMethod.h.

  : _inletLatticeI(std::move(inletLatticeI)),
    _inletPhysI(std::move(inletPhysI)),
    _converter(converter),
    _sLattice(sLattice),
    _nSeeds(nSeeds),
    _nTime(nTime),
    _sigma(sigma),
    _intensity(intensity),
    _axisDirection(axisDirection),
    _AiC(_sLattice.getLoadBalancer().size()),
    _NiC(_sLattice.getLoadBalancer().size()),
    _seeds(sLattice.getCuboidGeometry(),
           sLattice.getLoadBalancer()),
    _seedsVorticity(sLattice.getCuboidGeometry(),
                    sLattice.getLoadBalancer())
{
  OstreamManager clout(std::cout, "VortexMethod");
 
  sLattice.template addPostProcessor<stage::VortexMethod>(*_inletLatticeI,
                                                          meta::id<VortexMethodPreProcessor>{});
  SuperIndicatorLayer3D<T> extendedLatticeInletI(*_inletLatticeI);
  sLattice.template addPostProcessor<stage::VortexMethod>(extendedLatticeInletI,
                                                          meta::id<VortexMethodPostProcessor>{});
 
  if (_sigma < _converter.getPhysDeltaX()) {
    _sigma = _converter.getPhysDeltaX();
  }
 
  _inletArea = 0.;
 
  auto& cGeometry = sLattice.getCuboidGeometry();
  Cuboid3D<T> indicatorCuboid(*inletPhysI, _converter.getPhysDeltaX());
 
  auto& load = _sLattice.getLoadBalancer();
  for (int iC=0; iC < load.size(); ++iC) {
    _AiC[iC] = 0.;
    auto& cuboid = cGeometry.get(load.glob(iC));
    if (cuboid.checkInters(indicatorCuboid)) {
      auto& block = _sLattice.getBlock(iC);
      for (int iX=0; iX < block.getNx(); ++iX) {
        for (int iY=0; iY < block.getNy(); ++iY) {
          for (int iZ=0; iZ < block.getNz(); ++iZ) {
            int latticeR[3] {iX, iY, iZ};
            T physR[3] { };
            cuboid.getPhysR(physR, latticeR);
            block.get(iX,iY,iZ).template setField<descriptors::LOCATION>(physR);
            bool inInlet{};
            _inletPhysI(&inInlet, physR);
            if (inInlet) {
              _AiC[iC] += util::pow(_converter.getPhysDeltaX(), 2.);
            }
          }
        }
      }
    }
    _inletArea += _AiC[iC];
  }
 
  #ifdef PARALLEL_MODE_MPI
  singleton::mpi().reduceAndBcast(_inletArea, MPI_SUM);
  #endif
 
  clout << "inletArea=" << _inletArea << std::endl;
 
  // initial seeding of random vortex points of number N
  for (int iC=0; iC < load.size(); ++iC) {
    _NiC[iC] = int(_nSeeds*_AiC[iC] / _inletArea);
    _seeds.getBlock(iC).resize(_NiC[iC]);
    _seedsVorticity.getBlock(iC).resize(_NiC[iC]);
  }
 
  for (int iC=0; iC < load.size(); ++iC) {
    if (_NiC[iC] > 0) {
      auto& block = _sLattice.getBlock(iC);
      block.template setParameter<SEEDS_COUNT>(_NiC[iC]);
      block.template setParameter<SEEDS>(_seeds.getBlock(iC));
      block.template setParameter<SEEDS_VORTICITY>(_seedsVorticity.getBlock(iC));
      block.template getField<VELOCITY_OLD>();
      block.template getField<U_PROFILE>();
    }
  }
 
  _sLattice.template setParameter<CONVERSION_FACTOR_LENGTH>(_converter.getConversionFactorLength());
  _sLattice.template setParameter<CONVERSION_FACTOR_VELOCITY>(_converter.getConversionFactorVelocity());
  _sLattice.template setParameter<SIGMA>(_sigma);
  _sLattice.template setParameter<AXIS_DIRECTION>(axisDirection);
 
  _sLattice.setProcessingContext(ProcessingContext::Simulation);
}

References olb::SuperStructure< T, D >::getCuboidGeometry(), olb::singleton::mpi(), olb::util::pow(), olb::singleton::MpiManager::reduceAndBcast(), and olb::Simulation.

Here is the call graph for this function:

Member Function Documentation

apply()

template<typename T , typename DESCRIPTOR >

void olb::VortexMethodTurbulentVelocityBoundary< T, DESCRIPTOR >::apply

(

std::size_t

iT

)

Definition at line 274 of file vortexMethod.h.

{
  generateSeeds();
  updateSeedsVorticity(iT);
 
  {
    auto& load = _sLattice.getLoadBalancer();
    for (int iC=0; iC < load.size(); ++iC) {
      if (_NiC[iC] > 0) {
        auto& block = _sLattice.getBlock(iC);
        block.template setParameter<SEEDS_COUNT>(_NiC[iC]);
        block.template setParameter<SEEDS>(_seeds.getBlock(iC));
        block.template setParameter<SEEDS_VORTICITY>(_seedsVorticity.getBlock(iC));
      }
    }
    _sLattice.template setParameter<SIGMA>(_sigma);
    _sLattice.template setParameter<AXIS_DIRECTION>(_axisDirection);
  }
  _sLattice.executePostProcessors(stage::VortexMethod{});
}

setProfile()

template<typename T , typename DESCRIPTOR >

void olb::VortexMethodTurbulentVelocityBoundary< T, DESCRIPTOR >::setProfile

(

std::shared_ptr< AnalyticalF3D< T, T > >

profileF

)

Definition at line 266 of file vortexMethod.h.

{
  _profileF = profileF;
  _sLattice.template defineField<U_PROFILE>(*_inletLatticeI, *_profileF);
  //_sLattice.template setProcessingContext<Array<U_PROFILE>>(ProcessingContext::Simulation);
}

---

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

• src/boundary/vortexMethod.h