This functor gives a parabolic profile for a given point x as it computes the distance between x and the axis. More...

#include <latticeFrameChangeF3D.h>

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

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

Public Member Functions
	HarmonicOscillatingRotatingForceField3D (SuperLattice< T, DESCRIPTOR > &sLattice_, SuperGeometry< T, 3 > &superGeometry_, const UnitConverter< T, DESCRIPTOR > &converter_, std::vector< T > axisPoint_, std::vector< T > axisDirection_, T amplitude_, T frequency_)

void	updateTimeStep (int iT)

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

Public Member Functions inherited from olb::SuperLatticeF3D< T, DESCRIPTOR >
SuperLattice< T, DESCRIPTOR > &	getSuperLattice ()

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

Public Member Functions inherited from olb::SuperF3D< T, T >
SuperF3D< T, T > &	operator- (SuperF3D< T, T > &rhs)

SuperF3D< T, T > &	operator+ (SuperF3D< T, T > &rhs)

SuperF3D< T, T > &	operator* (SuperF3D< T, T > &rhs)

SuperF3D< T, T > &	operator/ (SuperF3D< T, T > &rhs)

SuperStructure< T, 3 > &	getSuperStructure ()

int	getBlockFSize () const

BlockF3D< T > &	getBlockF (int iCloc)

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

Public Member Functions inherited from olb::GenericF< T, S >
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 S 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[], S input0)

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

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

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

Protected Attributes
SuperGeometry< T, 3 > &	sg

const UnitConverter< T, DESCRIPTOR > &	converter

std::vector< T >	axisPoint

std::vector< T >	axisDirection

T	amplitude

T	resonanceFrequency

T	w

T	dwdt

SuperLatticePhysVelocity3D< T, DESCRIPTOR >	velocity

Protected Attributes inherited from olb::SuperLatticeF3D< T, DESCRIPTOR >
SuperLattice< T, DESCRIPTOR > &	_sLattice

Protected Attributes inherited from olb::SuperF3D< T, T >
SuperStructure< T, 3 > &	_superStructure

std::vector< std::unique_ptr< BlockF3D< T > > >	_blockF
	Super functors may consist of several BlockF3D<W> derived functors.

Additional Inherited Members
Public Types inherited from olb::SuperLatticeF3D< T, DESCRIPTOR >
using	identity_functor_type = SuperLatticeIdentity3D<T,DESCRIPTOR>

Public Types inherited from olb::SuperF3D< T, T >
using	identity_functor_type

Public Types inherited from olb::GenericF< T, S >
using	targetType = T

using	sourceType = S

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

Static Public Attributes inherited from olb::SuperF3D< T, T >
static constexpr bool	isSuper

static constexpr unsigned	d

Protected Member Functions inherited from olb::SuperLatticeF3D< T, DESCRIPTOR >
	SuperLatticeF3D (SuperLattice< T, DESCRIPTOR > &superLattice, int targetDim)

Protected Member Functions inherited from olb::SuperF3D< T, T >
	SuperF3D (SuperStructure< T, 3 > &superStructure, int targetDim)

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

Detailed Description

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

This functor gives a parabolic profile for a given point x as it computes the distance between x and the axis.

The forces set are the fake forces caused by a non-Galilean frame, here harmonic oscillation around an axis. Oscillation is determined by an amplitude and a frequency Functor for the rotation of forces.

Definition at line 103 of file latticeFrameChangeF3D.h.

Constructor & Destructor Documentation

◆ HarmonicOscillatingRotatingForceField3D()

template<typename T , typename DESCRIPTOR >

olb::HarmonicOscillatingRotatingForceField3D< T, DESCRIPTOR >::HarmonicOscillatingRotatingForceField3D	(	SuperLattice< T, DESCRIPTOR > &	sLattice_,
		SuperGeometry< T, 3 > &	superGeometry_,
		const UnitConverter< T, DESCRIPTOR > &	converter_,
		std::vector< T >	axisPoint_,
		std::vector< T >	axisDirection_,
		T	amplitude_,
		T	frequency_ )

Definition at line 92 of file latticeFrameChangeF3D.hh.

  : SuperLatticeF3D<T,DESCRIPTOR>(sLattice_,3), sg(superGeometry_),
    converter(converter_), axisPoint(axisPoint_), axisDirection(axisDirection_),
    amplitude(amplitude_), resonanceFrequency(2.*4.*util::atan(1.0)*frequency_), w(0.0), dwdt(0.0),
    velocity(sLattice_,converter_)
{
  this->getName() = "harmonicOscillatingrotatingForce";
}

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

Here is the call graph for this function:

Member Function Documentation

◆ operator()()

template<typename T , typename DESCRIPTOR >

bool olb::HarmonicOscillatingRotatingForceField3D< T, DESCRIPTOR >::operator()	(	T	output[],
		const int	x[] )

override

Definition at line 113 of file latticeFrameChangeF3D.hh.

{
 
 
  std::vector<T> F_centri(3,0);
  std::vector<T> F_coriolis(3,0);
  std::vector<T> F_euler(3,0);
 
  if ( this->_sLattice.getLoadBalancer().rank(x[0]) == singleton::mpi().getRank() ) {
    // local coords are given, fetch local cell and compute value(s)
    std::vector<T> physR(3,T());
    this->sg.getCuboidGeometry().getPhysR(&(physR[0]),&(x[0]));
 
    T scalar =  (physR[0]-axisPoint[0])*axisDirection[0]
                +(physR[1]-axisPoint[1])*axisDirection[1]
                +(physR[2]-axisPoint[2])*axisDirection[2];
 
    T r[3];
    r[0] = physR[0]-axisPoint[0]-scalar*axisDirection[0];
    r[1] = physR[1]-axisPoint[1]-scalar*axisDirection[1];
    r[2] = physR[2]-axisPoint[2]-scalar*axisDirection[2];
 
    F_centri[0] = w*w*(r[0]);
    F_centri[1] = w*w*(r[1]);
    F_centri[2] = w*w*(r[2]);
 
    T _vel[3];
    (velocity)(_vel,x);
    F_coriolis[0] = -2*w*(axisDirection[1]*_vel[2]-axisDirection[2]*_vel[1]);
    F_coriolis[1] = -2*w*(axisDirection[2]*_vel[0]-axisDirection[0]*_vel[2]);
    F_coriolis[2] = -2*w*(axisDirection[0]*_vel[1]-axisDirection[1]*_vel[0]);
 
    F_euler[0] = -dwdt*(axisDirection[1]*r[2]-axisDirection[2]*r[1]);
    F_euler[1] = -dwdt*(axisDirection[2]*r[0]-axisDirection[0]*r[2]);
    F_euler[2] = -dwdt*(axisDirection[0]*r[1]-axisDirection[1]*r[0]);
 
 
    // return latticeForce
    output[0] = (F_coriolis[0]+F_centri[0]+F_euler[0]) * converter.getConversionFactorTime() / converter.getConversionFactorVelocity();
    output[1] = (F_coriolis[1]+F_centri[1]+F_euler[1]) * converter.getConversionFactorTime() / converter.getConversionFactorVelocity();
    output[2] = (F_coriolis[2]+F_centri[2]+F_euler[2]) * converter.getConversionFactorTime() / converter.getConversionFactorVelocity();
  }
  return true;
}

References olb::singleton::MpiManager::getRank(), and olb::singleton::mpi().

Here is the call graph for this function:

◆ updateTimeStep()

template<typename T , typename DESCRIPTOR >

void olb::HarmonicOscillatingRotatingForceField3D< T, DESCRIPTOR >::updateTimeStep ( int iT )

Definition at line 105 of file latticeFrameChangeF3D.hh.

{
  w = resonanceFrequency * amplitude * util::cos(resonanceFrequency*converter.getPhysTime(iT));
  dwdt = -resonanceFrequency * resonanceFrequency * amplitude * util::sin(resonanceFrequency*converter.getPhysTime(iT));
}