olb::AdsorptionFullCouplingPostProcessor3D< T, NSDESCRIPTOR, ADEDESCRIPTOR > Class Template Reference

#include <adsorptionCoupling3D.h>

Inheritance diagram for olb::AdsorptionFullCouplingPostProcessor3D< T, NSDESCRIPTOR, ADEDESCRIPTOR >:

Collaboration diagram for olb::AdsorptionFullCouplingPostProcessor3D< T, NSDESCRIPTOR, ADEDESCRIPTOR >:

Public Member Functions
	AdsorptionFullCouplingPostProcessor3D (int x0_, int x1_, int y0_, int y1_, int z0_, int z1_, int iC, std::vector< BlockStructureD< 3 > * > partners_, AdsorptionReaction< T, ADEDESCRIPTOR > *adsorptionReaction_, std::vector< std::reference_wrapper< AdvectionDiffusionForce3D< T, NSDESCRIPTOR, ADEDESCRIPTOR > > > forces_)
	All in one adsorption coupling.
int	extent () const override
	Extent of application area (0 for purely local operations)
int	extent (int whichDirection) const override
	Extent of application area along a direction (0 or 1)
void	process (BlockLattice< T, NSDESCRIPTOR > &blockLattice) override
void	processSubDomain (BlockLattice< T, NSDESCRIPTOR > &blockLattice, int x0_, int x1_, int y0_, int y1_, int z0_, int z1_)
Public Member Functions inherited from olb::PostProcessor3D< T, DESCRIPTOR >
	PostProcessor3D ()
virtual	~PostProcessor3D ()
virtual void	process (BlockLattice< T, DESCRIPTOR > &blockLattice)=0
	Execute post-processing step.
virtual void	processSubDomain (BlockLattice< T, DESCRIPTOR > &blockLattice, int x0_, int x1_, int y0_, int y1_, int z0_, int z1_)=0
	Execute post-processing step on a sublattice.
std::string &	getName ()
	read and write access to name
std::string const &	getName () const
	read only access to name
int	getPriority () const
	read only access to priority

Protected Attributes
std::vector< std::reference_wrapper< AdvectionDiffusionForce3D< T, NSDESCRIPTOR, ADEDESCRIPTOR > > >	forces
Protected Attributes inherited from olb::PostProcessor3D< T, DESCRIPTOR >
int	_priority

Detailed Description

template<typename T, typename NSDESCRIPTOR, typename ADEDESCRIPTOR>
class olb::AdsorptionFullCouplingPostProcessor3D< T, NSDESCRIPTOR, ADEDESCRIPTOR >

Definition at line 159 of file adsorptionCoupling3D.h.

Constructor & Destructor Documentation

AdsorptionFullCouplingPostProcessor3D()

template<typename T , typename NSDESCRIPTOR , typename ADEDESCRIPTOR >

olb::AdsorptionFullCouplingPostProcessor3D< T, NSDESCRIPTOR, ADEDESCRIPTOR >::AdsorptionFullCouplingPostProcessor3D	(	int	x0_,
		int	x1_,
		int	y0_,
		int	y1_,
		int	z0_,
		int	z1_,
		int	iC,
		std::vector< BlockStructureD< 3 > * >	partners_,
		AdsorptionReaction< T, ADEDESCRIPTOR > *	adsorptionReaction_,
		std::vector< std::reference_wrapper< AdvectionDiffusionForce3D< T, NSDESCRIPTOR, ADEDESCRIPTOR > > >	forces_ )

All in one adsorption coupling.

Definition at line 35 of file adsorptionCoupling3D.hh.

      : x0(x0_), x1(x1_), y0(y0_), y1(y1_), z0(z0_), z1(z1_), iC(iC_),
        particleLattice(static_cast<BlockLattice<T, ADEDESCRIPTOR> *>(partners_[0])),
        soluteLattice(static_cast<BlockLattice<T, ADEDESCRIPTOR> *>(partners_[1])),
        loadingLattice(static_cast<BlockLattice<T, ADEDESCRIPTOR> *>(partners_[2])),
        adsorptionReaction(adsorptionReaction_),
        forces(forces_) {
    this->getName() = "AdsorptionFullCouplingPostProcessor3D";
  }

References olb::PostProcessor3D< T, DESCRIPTOR >::getName().

Here is the call graph for this function:

Member Function Documentation

extent() [1/2]

template<typename T , typename NSDESCRIPTOR , typename ADEDESCRIPTOR >

int olb::AdsorptionFullCouplingPostProcessor3D< T, NSDESCRIPTOR, ADEDESCRIPTOR >::extent ( ) const

inlineoverridevirtual

Extent of application area (0 for purely local operations)

Implements olb::PostProcessor3D< T, DESCRIPTOR >.

Definition at line 167 of file adsorptionCoupling3D.h.

                                  {
        return 0;
      }

extent() [2/2]

template<typename T , typename NSDESCRIPTOR , typename ADEDESCRIPTOR >

int olb::AdsorptionFullCouplingPostProcessor3D< T, NSDESCRIPTOR, ADEDESCRIPTOR >::extent ( int direction ) const

inlineoverridevirtual

Extent of application area along a direction (0 or 1)

Implements olb::PostProcessor3D< T, DESCRIPTOR >.

Definition at line 171 of file adsorptionCoupling3D.h.

                                                    {
        return 0;
      }

process()

template<typename T , typename NSDESCRIPTOR , typename ADEDESCRIPTOR >

void olb::AdsorptionFullCouplingPostProcessor3D< T, NSDESCRIPTOR, ADEDESCRIPTOR >::process ( BlockLattice< T, NSDESCRIPTOR > & blockLattice )

override

Definition at line 50 of file adsorptionCoupling3D.hh.

                                                                                                                               {
    processSubDomain(blockLattice, x0, x1, y0, y1, z0, z1);
  }

processSubDomain()

template<typename T , typename NSDESCRIPTOR , typename ADEDESCRIPTOR >

void olb::AdsorptionFullCouplingPostProcessor3D< T, NSDESCRIPTOR, ADEDESCRIPTOR >::processSubDomain	(	BlockLattice< T, NSDESCRIPTOR > &	blockLattice,
		int	x0_,
		int	x1_,
		int	y0_,
		int	y1_,
		int	z0_,
		int	z1_ )

Definition at line 55 of file adsorptionCoupling3D.hh.

                                                                              {
 
  int newX0, newX1, newY0, newY1, newZ0, newZ1;
  if (util::intersect(
      x0, x1, y0, y1, z0, z1,
      x0_, x1_, y0_, y1_, z0_, z1_,
      newX0, newX1, newY0, newY1, newZ0, newZ1)) {
    for (int iX = newX0; iX <= newX1; ++iX) {
      for (int iY = newY0; iY <= newY1; ++iY) {
        for (int iZ = newZ0; iZ <= newZ1; ++iZ) {
          //computation of particle velocity for particle and load lattices
          auto vel = blockLattice.get(iX, iY, iZ).template getField<descriptors::VELOCITY>();
          T forceValue[3] = {0.,0.,0.};
          if (forces.begin() != forces.end()) {
            auto velXp = blockLattice.get(iX+1, iY, iZ).template getField<descriptors::VELOCITY>();
            auto velXn = blockLattice.get(iX-1, iY, iZ).template getField<descriptors::VELOCITY>();
            auto velYp = blockLattice.get(iX, iY+1, iZ).template getField<descriptors::VELOCITY>();
            auto velYn = blockLattice.get(iX, iY-1, iZ).template getField<descriptors::VELOCITY>();
            auto velZp = blockLattice.get(iX, iY, iZ+1).template getField<descriptors::VELOCITY>();
            auto velZn = blockLattice.get(iX, iY, iZ-1).template getField<descriptors::VELOCITY>();
            T velGrad[3] = {0., 0., 0.};
            velGrad[0] = 0.5*(vel[0]*(velXp[0] - velXn[0]) + vel[1]*(velYp[0] - velYn[0]) + vel[2]*(velZp[0] - velZn[0]));
            velGrad[1] = 0.5*(vel[0]*(velXp[1] - velXn[1]) + vel[1]*(velYp[1] - velYn[1]) + vel[2]*(velZp[1] - velZn[1]));
            velGrad[2] = 0.5*(vel[0]*(velXp[2] - velXn[2]) + vel[1]*(velYp[2] - velYn[2]) + vel[2]*(velZp[2] - velZn[2]));
 
            int latticeR[4] = {iC, iX, iY, iZ};
            auto nsCell = blockLattice.get(iX, iY, iZ);
            auto adCell = particleLattice->get(iX, iY, iZ);
            for (AdvectionDiffusionForce3D<T, NSDESCRIPTOR, ADEDESCRIPTOR>& f : forces) {
              f.applyForce(forceValue, &nsCell, &adCell, vel.data(), latticeR);
              }
 
            // compute new particle velocity under action of forces
            Vector<T,ADEDESCRIPTOR::d> newVel;
            for (int i=0; i < ADEDESCRIPTOR::d; i++) {
              newVel[i] = vel[i] + forceValue[i] - velGrad[i];
              }
            particleLattice->get(iX, iY, iZ).template setField<descriptors::VELOCITY>(newVel);
            loadingLattice->get(iX, iY, iZ).template setField<descriptors::VELOCITY>(newVel);
          }
          else {   // set particle velocity to the carrier fluid velocity
            particleLattice->get(iX, iY, iZ).template setField<descriptors::VELOCITY>(vel);
            loadingLattice->get(iX, iY, iZ).template setField<descriptors::VELOCITY>(vel);
            }
 
          //setting of the solute velocity to the carrier fluid velocity
          soluteLattice->get(iX, iY, iZ).template setField<descriptors::VELOCITY>(vel);
 
          //computation of the adsorption source terms for solute and load lattices
          T soluteConcentration = soluteLattice->get(iX, iY, iZ).computeRho();
          T particleConcentration = particleLattice->get(iX, iY, iZ).computeRho();
          T particleLoading = loadingLattice->get(iX, iY, iZ).computeRho();
          Vector<T, 2> reactionRates = adsorptionReaction->getReactionRate(soluteConcentration, particleLoading, particleConcentration);
          loadingLattice->get(iX, iY, iZ).template setField<descriptors::SOURCE>(reactionRates[1]);
          soluteLattice->get(iX, iY, iZ).template setField<descriptors::SOURCE>(-reactionRates[0]);
        }
      }
    }
  }
}

References olb::BlockLattice< T, DESCRIPTOR >::get(), and olb::util::intersect().

Here is the call graph for this function:

Member Data Documentation

forces

template<typename T , typename NSDESCRIPTOR , typename ADEDESCRIPTOR >

std::vector<std::reference_wrapper<AdvectionDiffusionForce3D<T, NSDESCRIPTOR, ADEDESCRIPTOR> > > olb::AdsorptionFullCouplingPostProcessor3D< T, NSDESCRIPTOR, ADEDESCRIPTOR >::forces

protected

Definition at line 178 of file adsorptionCoupling3D.h.

---

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

• src/reaction/adsorptionCoupling3D.h
• src/reaction/adsorptionCoupling3D.hh