olb::NonLocalBaseForwardCouplingModel< T, Lattice, Particle > Class Template Reference

Abstact class for all the non-local forward-coupling models, viz., momentum coupling from fluid to particle. More...

#include <forwardCouplingModels3D.h>

Inheritance diagram for olb::NonLocalBaseForwardCouplingModel< T, Lattice, Particle >:

Collaboration diagram for olb::NonLocalBaseForwardCouplingModel< T, Lattice, Particle >:

Public Member Functions
virtual bool	operator() (Particle< T > *p, int globic) override
	Class operator to apply the coupling, for overload.

Protected Member Functions
	NonLocalBaseForwardCouplingModel (UnitConverter< T, Lattice > &converter, SuperLattice< T, Lattice > &sLattice, SuperGeometry< T, 3 > &sGeometry, std::shared_ptr< DragModel< T, Particle > > dragModel, std::shared_ptr< SmoothingFunctional< T, Lattice > > smoothingFunctional)
	Constructor.
Protected Member Functions inherited from olb::BaseForwardCouplingModel< T, Lattice, Particle >
	BaseForwardCouplingModel (UnitConverter< T, Lattice > &converter, SuperLattice< T, Lattice > &sLattice, SuperGeometry< T, 3 > &sGeometry, std::shared_ptr< DragModel< T, Particle > > dragModel)
	Constructor.
Protected Member Functions inherited from olb::ForwardCouplingModel< T, Particle >
	ForwardCouplingModel (SuperGeometry< T, 3 > &sGeometry, std::shared_ptr< DragModel< T, Particle > > dragModel)
	Constructor.

Protected Attributes
std::shared_ptr< SmoothingFunctional< T, Lattice > >	_smoothingFunctional
Protected Attributes inherited from olb::BaseForwardCouplingModel< T, Lattice, Particle >
UnitConverter< T, Lattice > &	_converter
SuperLattice< T, Lattice > &	_sLattice
std::shared_ptr< SuperLatticeInterpDensity3Degree3D< T, Lattice > >	_interpLatticeDensity
std::shared_ptr< SuperLatticeInterpPhysVelocity3D< T, Lattice > >	_interpLatticeVelocity
std::shared_ptr< TwoWayHelperFunctional< T, Lattice > >	_momentumExchange
Protected Attributes inherited from olb::ForwardCouplingModel< T, Particle >
SuperGeometry< T, 3 > &	_sGeometry
std::shared_ptr< DragModel< T, Particle > >	_dragModel

Detailed Description

template<typename T, typename Lattice, template< typename V > class Particle>
class olb::NonLocalBaseForwardCouplingModel< T, Lattice, Particle >

Abstact class for all the non-local forward-coupling models, viz., momentum coupling from fluid to particle.

Input parameters in attice units.

Definition at line 122 of file forwardCouplingModels3D.h.

Constructor & Destructor Documentation

NonLocalBaseForwardCouplingModel()

template<typename T , typename Lattice , template< typename V > class Particle>

olb::NonLocalBaseForwardCouplingModel< T, Lattice, Particle >::NonLocalBaseForwardCouplingModel ( UnitConverter< T, Lattice > & converter, SuperLattice< T, Lattice > & sLattice, SuperGeometry< T, 3 > & sGeometry, std::shared_ptr< DragModel< T, Particle > > dragModel, std::shared_ptr< SmoothingFunctional< T, Lattice > > smoothingFunctional )

protected

Constructor.

Definition at line 196 of file forwardCouplingModels3D.hh.

  : BaseForwardCouplingModel<T,Lattice,Particle>(converter, sLattice, sGeometry, dragModel),
    _smoothingFunctional(smoothingFunctional)
{}

Member Function Documentation

operator()()

template<typename T , typename Lattice , template< typename V > class Particle>

bool olb::NonLocalBaseForwardCouplingModel< T, Lattice, Particle >::operator() ( Particle< T > * p, int globic )

overridevirtual

Class operator to apply the coupling, for overload.

Getting the particle and its containing cell's position

Computing dimensionless drag force through smoothed average within the kernel smoothing length

Computing drag force in dimensionless units

Computing physical drag force

Updating the particle

Implements olb::ForwardCouplingModel< T, Particle >.

Definition at line 207 of file forwardCouplingModels3D.hh.

{
  T physPosP[3] = { p->getPos()[0],
                    p->getPos()[1],
                    p->getPos()[2]
                  }; // particle's physical position
  // particle's dimensionless position, rounded at neighbouring voxel
  int latticeRoundedPosP[3] = {0, 0, 0};
  this->_sLattice.getCuboidGeometry().get(globic).getLatticeR (
    latticeRoundedPosP, physPosP );
  // { globic, latticeRoundedP[0, ..., 2] }
  int globicFull[4] = { globic,
                        latticeRoundedPosP[0],
                        latticeRoundedPosP[1],
                        latticeRoundedPosP[2]
                      };
 
  // Particle's velocity
  T physVelP[3] = { p->getVel()[0],
                    p->getVel()[1],
                    p->getVel()[2]
                  }; // Physical
  // Lattice
  T latticeVelP[3] = { this->_converter.getLatticeVelocity(physVelP[0]),
                       this->_converter.getLatticeVelocity(physVelP[1]),
                       this->_converter.getLatticeVelocity(physVelP[2])
                     }; // particle's dimensionless velocity
 
  // Update the smoothing functional
  if ( ! this->_smoothingFunctional->update(physPosP, globic)) {
    std::cout << "ERROR: no lattice point enclosed in particle's kernel length!" << std::endl;
    return false;
  }
 
  T latticeForceP[3] = {T(), T(), T()}; // dimensionless force acting on the particle
  for (auto&& i : this->_smoothingFunctional->getData()) {
 
    // Position of the iterated voxel
    int iLatticePosF[3] = {i.latticePos[0], i.latticePos[1], i.latticePos[2]};
    // Physical
    T iPhysPosF[3] = {T(), T(), T()};
    this->_sLattice.getCuboidGeometry().get(globic).getPhysR (
      iPhysPosF, iLatticePosF );
 
    // Fluid velocity at the iterated voxel
    T iPhysVelF[3] = {T(), T(), T()}; // Physical
    this->_interpLatticeVelocity->operator() (iPhysVelF, iPhysPosF, globic);
    // Lattice
    T iLatticeVelF[3] = { this->_converter.getLatticeVelocity(iPhysVelF[0]),
                          this->_converter.getLatticeVelocity(iPhysVelF[1]),
                          this->_converter.getLatticeVelocity(iPhysVelF[2])
                        }; // Lattice's dimensionless velocity at particle's location
 
    // Computing fluid-particle momentum transfer
    T gF[3] = {T(), T(), T()}; // force density gF
    this->_momentumExchange->operator() ( gF, iLatticeVelF, latticeVelP, physPosP, iLatticePosF, globic);
 
    // Computing drag coefficient
    T Cd = this->_dragModel->operator()(p, iLatticeVelF, latticeVelP, globicFull);
 
    T latticePRad = p->getRad() / this->_converter.getConversionFactorLength();
    latticeForceP[0] += .5 * Cd * M_PI*util::pow(latticePRad,2) * gF[0] * (iLatticeVelF[0] - latticeVelP[0]) * i.weight;
    latticeForceP[1] += .5 * Cd * M_PI*util::pow(latticePRad,2) * gF[1] * (iLatticeVelF[1] - latticeVelP[1]) * i.weight;
    latticeForceP[2] += .5 * Cd * M_PI*util::pow(latticePRad,2) * gF[2] * (iLatticeVelF[2] - latticeVelP[2]) * i.weight;
  }
 
  std::vector<T> physForceP(3, T()); // physical force acting on the particle
  physForceP[0] = latticeForceP[0] * this->_converter.getConversionFactorForce();
  physForceP[1] = latticeForceP[1] * this->_converter.getConversionFactorForce();
  physForceP[2] = latticeForceP[2] * this->_converter.getConversionFactorForce();
 
  p->setStoreForce(physForceP);
  return true;
}

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

Here is the call graph for this function:

Member Data Documentation

_smoothingFunctional

template<typename T , typename Lattice , template< typename V > class Particle>

std::shared_ptr<SmoothingFunctional<T, Lattice> > olb::NonLocalBaseForwardCouplingModel< T, Lattice, Particle >::_smoothingFunctional

protected

Definition at line 134 of file forwardCouplingModels3D.h.

---

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

• src/particles/subgrid3DLegacyFramework/twoWayCouplings/forwardCouplingModels3D.h
• src/particles/subgrid3DLegacyFramework/twoWayCouplings/forwardCouplingModels3D.hh