olb::SmoothIndicatorCone3D< T, S, PARTICLE > Class Template Reference

implements a smooth particle cone in 3D with an _epsilon sector More...

#include <smoothIndicatorF3D.h>

Inheritance diagram for olb::SmoothIndicatorCone3D< T, S, PARTICLE >:

Collaboration diagram for olb::SmoothIndicatorCone3D< T, S, PARTICLE >:

Public Member Functions
	SmoothIndicatorCone3D (IndicatorCone3D< S > &indPtr, S epsilon, Vector< S, 3 > theta=Vector< S, 3 >(0., 0., 0.))
	SmoothIndicatorCone3D (Vector< S, 3 > center1, Vector< S, 3 > center2, S radius1, S radius2, S epsilon, Vector< S, 3 > theta=Vector< S, 3 >(0., 0., 0.))
IndicatorCone3D< S > &	getIndicator ()
Vector< S, 3 >	surfaceNormal (const Vector< S, 3 > &pos, const S meshSize) override
const S	signedDistance (const PhysR< S, 3 > input) override
S	getVolume () override
Vector< S, 4 >	calcMofiAndMass (const S density) override
Vector< S, 3 >	calcCenterOfMass () override

Detailed Description

template<typename T, typename S, bool PARTICLE = false>
class olb::SmoothIndicatorCone3D< T, S, PARTICLE >

implements a smooth particle cone in 3D with an _epsilon sector

Definition at line 130 of file smoothIndicatorF3D.h.

Constructor & Destructor Documentation

SmoothIndicatorCone3D() [1/2]

template<typename T , typename S , bool PARTICLE>

olb::SmoothIndicatorCone3D< T, S, PARTICLE >::SmoothIndicatorCone3D	(	IndicatorCone3D< S > &	indPtr,
		S	epsilon,
		Vector< S, 3 >	theta = Vector<S,3> (0.,0.,0.) )

Definition at line 565 of file smoothIndicatorF3D.hh.

  :SmoothIndicatorCone3D(ind.getCenter1(), ind.getCenter2(), ind.getRadius1(), ind.getRadius2(), epsilon, theta)
{ }

SmoothIndicatorCone3D() [2/2]

template<typename T , typename S , bool PARTICLE>

olb::SmoothIndicatorCone3D< T, S, PARTICLE >::SmoothIndicatorCone3D	(	Vector< S, 3 >	center1,
		Vector< S, 3 >	center2,
		S	radius1,
		S	radius2,
		S	epsilon,
		Vector< S, 3 >	theta = Vector<S,3> (0.,0.,0.) )

Definition at line 570 of file smoothIndicatorF3D.hh.

  :_ind(center1, center2, radius1, radius2)
{
  this->_epsilon = epsilon;
  _startPos = this->calcCenterOfMass();
 
  if constexpr (!PARTICLE) {
    this->_pos = _startPos;
    this->_theta = util::degreeToRadian(theta);
  }
 
  Vector<T,3> dist = _ind.getCenter2() - _ind.getCenter1();
  S const length = norm(dist);
  initIndicatorCone3D(theta, length);
}

References olb::SmoothIndicatorCone3D< T, S, PARTICLE >::calcCenterOfMass(), olb::util::degreeToRadian(), and olb::norm().

Here is the call graph for this function:

Member Function Documentation

calcCenterOfMass()

template<typename T , typename S , bool PARTICLE>

Vector< S, 3 > olb::SmoothIndicatorCone3D< T, S, PARTICLE >::calcCenterOfMass ( )

override

Definition at line 660 of file smoothIndicatorF3D.hh.

{
  T topRadius, baseRadius;
  Vector<T,3> centerTop, centerBase;
 
  if (_ind.getRadius1() < _ind.getRadius2()) {
    topRadius = _ind.getRadius1();
    baseRadius =  _ind.getRadius2();
    centerTop = _ind.getCenter1();
    centerBase = _ind.getCenter2();
  }
  else if (_ind.getRadius1() > _ind.getRadius2()) {
    topRadius = _ind.getRadius2();
    baseRadius =  _ind.getRadius1();
    centerTop = _ind.getCenter2();
    centerBase = _ind.getCenter1();
  }
  else {
    std::cerr << "Error calculating a cone's center of mass." << std::endl;
    assert(false);
  }
 
  const T height = norm(centerTop - centerBase);
  const T centerOfMassHeight = 0.25*height * (baseRadius*baseRadius + 2*baseRadius*topRadius + 3*topRadius*topRadius)
                               / (baseRadius*baseRadius + baseRadius*topRadius + topRadius*topRadius);
  return centerBase + normalize(centerTop-centerBase) * centerOfMassHeight;
}

References olb::norm(), and olb::normalize().

Here is the call graph for this function:

Here is the caller graph for this function:

calcMofiAndMass()

template<typename T , typename S , bool PARTICLE>

Vector< S, 4 > olb::SmoothIndicatorCone3D< T, S, PARTICLE >::calcMofiAndMass ( const S density )

override

Definition at line 632 of file smoothIndicatorF3D.hh.

{
  const T _radiusA = _ind.getRadius1();
  const T _radiusB = _ind.getRadius2();
 
  Vector<T,3> dist = _ind.getCenter2() - _ind.getCenter1();
  S const length = norm(dist);
 
  const T mass = getVolume()*density;
  Vector<S,3> mofi;
 
  //TODO: check for correctness
  //TODO: Add check that orientation fits or give a warning
  // This is only valid if the same orientation is chosen. If A and B are not chosen according to this definiton, the calculation will be wrong.
  T topRadius = _radiusA;
  T baseRadius = _radiusB;
  if (_radiusA > _radiusB) {
    topRadius = _radiusB;
    baseRadius = _radiusA;
  }
  mofi[0] = 3/10.*mass*(util::pow(baseRadius,5) - util::pow(topRadius,5))/(util::pow(baseRadius,3) - util::pow(topRadius,3));
  mofi[1] = 3/20.*mass*( (util::pow(baseRadius-topRadius, 2) + 4*length*length) * (util::pow(baseRadius,5) - util::pow(topRadius,5)) )
            / (util::pow(baseRadius-topRadius,3) * (baseRadius*baseRadius+baseRadius*topRadius+topRadius*topRadius));
  mofi[2] = mofi[1];
  return Vector<S,4>(mofi[0], mofi[1], mofi[2], mass);
}

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

Here is the call graph for this function:

getIndicator()

template<typename T , typename S , bool PARTICLE>

IndicatorCone3D< S > & olb::SmoothIndicatorCone3D< T, S, PARTICLE >::getIndicator

(

)

Definition at line 587 of file smoothIndicatorF3D.hh.

                                                                     {
  return _ind;
}

getVolume()

template<typename T , typename S , bool PARTICLE>

S olb::SmoothIndicatorCone3D< T, S, PARTICLE >::getVolume ( )

override

Definition at line 622 of file smoothIndicatorF3D.hh.

{
  const Vector<T,3> dist = _ind.getCenter2() - _ind.getCenter1();
  S const length = norm(dist);
  return (1/3.)*M_PI*length* (_ind.getRadius1()*_ind.getRadius1()
                              +_ind.getRadius1()*_ind.getRadius2()
                              +_ind.getRadius2()*_ind.getRadius2());
}

References M_PI, and olb::norm().

Here is the call graph for this function:

signedDistance()

template<typename T , typename S , bool PARTICLE>

const S olb::SmoothIndicatorCone3D< T, S, PARTICLE >::signedDistance ( const PhysR< S, 3 > input )

override

Definition at line 695 of file smoothIndicatorF3D.hh.

{
  // counter-clockwise rotation by _theta=-theta around the current position of the center of mass
  Vector<S,3> p;
  if constexpr(!PARTICLE) {
    // counter-clockwise rotation by _theta=-theta around the current position of the center of mass & translation
    p = util::executeRotation<S,3,true>(input, this->_rotMat, this->getPos());
  }
  else {
    p = input;
  }
 
  // moving to indicator coordinate system by adding start position coordinate
  return _ind.signedDistance(p + _startPos);
}

surfaceNormal()

template<typename T , typename S , bool PARTICLE>

Vector< S, 3 > olb::SmoothIndicatorCone3D< T, S, PARTICLE >::surfaceNormal ( const Vector< S, 3 > & pos, const S meshSize )

override

Definition at line 689 of file smoothIndicatorF3D.hh.

{
  return _ind.surfaceNormal(pos, meshSize);
}

---

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

• src/functors/analytical/indicator/smoothIndicatorF3D.h
• src/functors/analytical/indicator/smoothIndicatorF3D.hh