#include <latticeInterpPhysVelocity3D.h>

Inheritance diagram for olb::BlockLatticeInterpPhysVelocity3D< T, DESCRIPTOR >:

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

Public Member Functions
	BlockLatticeInterpPhysVelocity3D (BlockLattice< T, DESCRIPTOR > &blockLattice, const UnitConverter< T, DESCRIPTOR > &conv, const Cuboid3D< T > &c)

	BlockLatticeInterpPhysVelocity3D (const BlockLatticeInterpPhysVelocity3D< T, DESCRIPTOR > &rhs)

bool	operator() (T output[3], const int input[3]) override

void	operator() (T output[3], const T input[3])

Public Member Functions inherited from olb::BlockLatticeF3D< T, DESCRIPTOR >
BlockLattice< T, DESCRIPTOR > &	getBlock ()
	Copy Constructor.

Public Member Functions inherited from olb::BlockF3D< T >
	~BlockF3D () override
	virtual destructor for defined behaviour

virtual BlockStructureD< 3 > &	getBlockStructure () const

BlockF3D< T > &	operator- (BlockF3D< T > &rhs)

BlockF3D< T > &	operator+ (BlockF3D< T > &rhs)

BlockF3D< T > &	operator* (BlockF3D< T > &rhs)

BlockF3D< T > &	operator/ (BlockF3D< T > &rhs)

Public Member Functions inherited from olb::GenericF< T, int >
virtual	~GenericF ()=default

int	getSourceDim () const
	read only access to member variable _m

int	getTargetDim () const
	read only access to member variable _n

std::string &	getName ()
	read and write access to name

std::string const &	getName () const
	read only access to name

virtual bool	operator() (T output[], const int input[])=0
	has to be implemented for 'every' derived class

bool	operator() (T output[])
	wrapper that call the pure virtual operator() (T output[], const S input[]) from above

bool	operator() (T output[], int input0)

bool	operator() (T output[], int input0, int input1)

bool	operator() (T output[], int input0, int input1, int input2)

bool	operator() (T output[], int input0, int input1, int input2, int input3)

Protected Attributes
const Cuboid3D< T > &	_cuboid

Protected Attributes inherited from olb::BlockLatticePhysF3D< T, DESCRIPTOR >
const UnitConverter< T, DESCRIPTOR > &	_converter

Protected Attributes inherited from olb::BlockLatticeF3D< T, DESCRIPTOR >
BlockLattice< T, DESCRIPTOR > &	_blockLattice

Protected Attributes inherited from olb::BlockF3D< T >
BlockStructureD< 3 > &	_blockStructure

Additional Inherited Members
Public Types inherited from olb::GenericF< T, int >
using	targetType

using	sourceType

Public Attributes inherited from olb::GenericF< T, int >
std::shared_ptr< GenericF< T, int > >	_ptrCalcC
	memory management, frees resouces (calcClass)

Protected Member Functions inherited from olb::BlockLatticePhysF3D< T, DESCRIPTOR >
	BlockLatticePhysF3D (BlockLattice< T, DESCRIPTOR > &blockLattice, const UnitConverter< T, DESCRIPTOR > &converter, int targetDim)

Protected Member Functions inherited from olb::BlockLatticeF3D< T, DESCRIPTOR >
	BlockLatticeF3D (BlockLattice< T, DESCRIPTOR > &blockLattice, int targetDim)

Protected Member Functions inherited from olb::BlockF3D< T >
	BlockF3D (BlockStructureD< 3 > &blockStructure, int targetDim)

Protected Member Functions inherited from olb::GenericF< T, int >
	GenericF (int targetDim, int sourceDim)

Detailed Description

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

Definition at line 58 of file latticeInterpPhysVelocity3D.h.

Constructor & Destructor Documentation

◆ BlockLatticeInterpPhysVelocity3D() [1/2]

template<typename T , typename DESCRIPTOR >

olb::BlockLatticeInterpPhysVelocity3D< T, DESCRIPTOR >::BlockLatticeInterpPhysVelocity3D	(	BlockLattice< T, DESCRIPTOR > &	blockLattice,
		const UnitConverter< T, DESCRIPTOR > &	conv,
		const Cuboid3D< T > &	c )

Definition at line 82 of file latticeInterpPhysVelocity3D.hh.

  : BlockLatticePhysF3D<T, DESCRIPTOR>(blockLattice, converter, 3),
    _cuboid(c)
{
  this->getName() = "BlockLatticeInterpVelocity3D";
}

References olb::GenericF< T, int >::getName().

Here is the call graph for this function:

◆ BlockLatticeInterpPhysVelocity3D() [2/2]

template<typename T , typename DESCRIPTOR >

olb::BlockLatticeInterpPhysVelocity3D< T, DESCRIPTOR >::BlockLatticeInterpPhysVelocity3D ( const BlockLatticeInterpPhysVelocity3D< T, DESCRIPTOR > & rhs )

Definition at line 91 of file latticeInterpPhysVelocity3D.hh.

                                                              :
  BlockLatticePhysF3D<T, DESCRIPTOR>(rhs._blockLattice, rhs._converter, 3),
  _cuboid(rhs._cuboid)
{
}

Member Function Documentation

◆ operator()() [1/2]

template<typename T , typename DESCRIPTOR >

bool olb::BlockLatticeInterpPhysVelocity3D< T, DESCRIPTOR >::operator()	(	T	output[3],
		const int	input[3] )

inlineoverride

Definition at line 65 of file latticeInterpPhysVelocity3D.h.

  {
    return false;
  }

◆ operator()() [2/2]

template<typename T , typename DESCRIPTOR >

void olb::BlockLatticeInterpPhysVelocity3D< T, DESCRIPTOR >::operator()	(	T	output[3],
		const T	input[3] )

Definition at line 99 of file latticeInterpPhysVelocity3D.hh.

{
  T u[3], rho, volume;
  T d[3], e[3];
  int latIntPos[3] = {0};
  T latPhysPos[3] = {T()};
  _cuboid.getFloorLatticeR(latIntPos, &input[0]);
  _cuboid.getPhysR(latPhysPos, latIntPos);
 
  T deltaRinv = 1. / _cuboid.getDeltaR();
  d[0] = (input[0] - latPhysPos[0]) * deltaRinv;
  d[1] = (input[1] - latPhysPos[1]) * deltaRinv;
  d[2] = (input[2] - latPhysPos[2]) * deltaRinv;
 
  e[0] = 1. - d[0];
  e[1] = 1. - d[1];
  e[2] = 1. - d[2];
 
  this->_blockLattice.get(latIntPos[0], latIntPos[1],
                          latIntPos[2]).computeRhoU(rho, u);
  volume = e[0] * e[1] * e[2];
  output[0] = u[0] * volume;
  output[1] = u[1] * volume;
  output[2] = u[2] * volume;
 
  this->_blockLattice.get(latIntPos[0], latIntPos[1] + 1,
                          latIntPos[2]).computeRhoU(rho, u);
  volume = e[0] * d[1] * e[2];
  output[0] += u[0] * volume;
  output[1] += u[1] * volume;
  output[2] += u[2] * volume;
 
  this->_blockLattice.get(latIntPos[0] + 1, latIntPos[1],
                          latIntPos[2]).computeRhoU(rho, u);
  volume = d[0] * e[1] * e[2];
  output[0] += u[0] * volume;
  output[1] += u[1] * volume;
  output[2] += u[2] * volume;
 
  this->_blockLattice.get(latIntPos[0] + 1, latIntPos[1] + 1,
                          latIntPos[2]).computeRhoU(rho, u);
  volume = d[0] * d[1] * e[2];
  output[0] += u[0] * volume;
  output[1] += u[1] * volume;
  output[2] += u[2] * volume;
 
  this->_blockLattice.get(latIntPos[0], latIntPos[1],
                          latIntPos[2] + 1).computeRhoU(rho,
                              u);
  volume = e[0] * e[1] * d[2];
  output[0] += u[0] * volume;
  output[1] += u[1] * volume;
  output[2] += u[2] * volume;
 
  this->_blockLattice.get(latIntPos[0], latIntPos[1] + 1,
                          latIntPos[2] + 1).computeRhoU(rho,
                              u);
  volume = e[0] * d[1] * d[2];
  output[0] += u[0] * volume;
  output[1] += u[1] * volume;
  output[2] += u[2] * volume;
 
  this->_blockLattice.get(latIntPos[0] + 1, latIntPos[1],
                          latIntPos[2] + 1).computeRhoU(rho,
                              u);
  volume = d[0] * e[1] * d[2];
  output[0] += u[0] * volume;
  output[1] += u[1] * volume;
  output[2] += u[2] * volume;
 
  this->_blockLattice.get(latIntPos[0] + 1, latIntPos[1] + 1,
                          latIntPos[2] + 1).computeRhoU(rho,
                              u);
  volume = d[0] * d[1] * d[2];
  output[0] += u[0] * volume;
  output[1] += u[1] * volume;
  output[2] += u[2] * volume;
 
  output[0] = this->_converter.getPhysVelocity(output[0]);
  output[1] = this->_converter.getPhysVelocity(output[1]);
  output[2] = this->_converter.getPhysVelocity(output[2]);
}