olb::IndicatorF2D< S > Class Template Reference

IndicatorF2D is an application from . More...

#include <indicatorBaseF2D.h>

Inheritance diagram for olb::IndicatorF2D< S >:

Collaboration diagram for olb::IndicatorF2D< S >:

Public Member Functions
virtual Vector< S, 2 > &	getMin ()
virtual Vector< S, 2 > &	getMax ()
virtual bool	distance (S &distance, const Vector< S, 2 > &origin, S precision, const Vector< S, 2 > &direction)
	returns false or true and pos. distance if there was one found for an given origin and direction
virtual bool	distance (S &distance, const Vector< S, 2 > &origin, const Vector< S, 2 > &direction, S precision, S pitch)
virtual bool	distance (S &distance, const Vector< S, 2 > &origin, const Vector< S, 2 > &direction, int iC=-1)
virtual bool	distance (S &distance, const Vector< S, 2 > &origin)
virtual bool	distance (S &distance, const S input[])
virtual bool	normal (Vector< S, 2 > &normal, const Vector< S, 2 > &origin, const Vector< S, 2 > &direction, int iC=-1)
	returns true and the normal if there was one found for an given origin and direction
virtual bool	operator() (bool output[1], const S input[2])
	Returns true if input is inside the indicator.
virtual S	signedDistance (const Vector< S, 2 > &input)
	Returns signed distance to the nearest point on the indicator surface.
virtual Vector< S, 2 >	surfaceNormal (const Vector< S, 2 > &pos, const S meshSize)
	Return surface normal.
Vector< S, 2 >	surfaceNormal (const Vector< S, 2 > &pos, const S meshSize, std::function< Vector< S, 2 >(const Vector< S, 2 > &)> transformPos)
	Return surface normal after possible translation and rotation.
bool	isInsideBox (Vector< S, 2 > point)
	Returns true if point is inside a cube with corners _myMin and _myMax
virtual bool	operator() (const S input[])
	Indicator specific function operator overload.
Public Member Functions inherited from olb::GenericF< bool, 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() (bool output[], const S input[])=0
	has to be implemented for 'every' derived class
bool	operator() (bool output[])
	wrapper that call the pure virtual operator() (T output[], const S input[]) from above
bool	operator() (bool output[], S input0)
bool	operator() (bool output[], S input0, S input1)
bool	operator() (bool output[], S input0, S input1, S input2)
bool	operator() (bool output[], S input0, S input1, S input2, S input3)

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

Protected Attributes
Vector< S, 2 >	_myMin
Vector< S, 2 >	_myMax

Additional Inherited Members
Public Types inherited from olb::GenericF< bool, S >
using	targetType
using	sourceType
Public Attributes inherited from olb::GenericF< bool, S >
std::shared_ptr< GenericF< bool, S > >	_ptrCalcC
	memory management, frees resouces (calcClass)

Detailed Description

template<typename S>
class olb::IndicatorF2D< S >

IndicatorF2D is an application from .

Parameters

_myMin	holds minimal(component wise) vector of the domain .
_myMax	holds maximal(component wise) vector of the domain .

Definition at line 70 of file indicatorBaseF2D.h.

Constructor & Destructor Documentation

IndicatorF2D()

template<typename S >

olb::IndicatorF2D< S >::IndicatorF2D ( )

protected

Definition at line 64 of file indicatorBaseF2D.hh.

  : GenericF<bool,S>(1, 2)
{ }

Member Function Documentation

distance() [1/5]

template<typename S >

bool olb::IndicatorF2D< S >::distance ( S & distance, const S input[] )

virtual

Definition at line 120 of file indicatorBaseF2D.hh.

{
  distance = util::abs(signedDistance(input));
  return true;
}

References olb::util::abs().

Here is the call graph for this function:

distance() [2/5]

template<typename S >

bool olb::IndicatorF2D< S >::distance ( S & distance, const Vector< S, 2 > & origin )

virtual

Definition at line 113 of file indicatorBaseF2D.hh.

{
  S input[3] = {origin[0],origin[1],origin[2]};
  return this->distance(distance, input);
}

distance() [3/5]

template<typename S >

bool olb::IndicatorF2D< S >::distance ( S & distance, const Vector< S, 2 > & origin, const Vector< S, 2 > & direction, int iC = -1 )

virtual

Reimplemented in olb::IndicatorCircle2D< S >.

Definition at line 105 of file indicatorBaseF2D.hh.

{
  S precision = .0001;
  S pitch = 0.5;
  return this->distance(distance, origin, direction, precision, pitch);
}

distance() [4/5]

template<typename S >

bool olb::IndicatorF2D< S >::distance ( S & distance, const Vector< S, 2 > & origin, const Vector< S, 2 > & direction, S precision, S pitch )

virtual

Definition at line 93 of file indicatorBaseF2D.hh.

{
  return util::distance(distance, origin, direction, precision, pitch,
  [&](bool output[1], const S input[2]) {
    return (*this)(output, input);
  },
  [&](const Vector<S,2>& pos) {
    return isInsideBox(pos);
  });
}

distance() [5/5]

template<typename S >

bool olb::IndicatorF2D< S >::distance ( S & distance, const Vector< S, 2 > & origin, S precision, const Vector< S, 2 > & direction )

virtual

returns false or true and pos. distance if there was one found for an given origin and direction

(mind that the default computation is done by a numerical approximation which searches .. [TODO])

Definition at line 81 of file indicatorBaseF2D.hh.

{
  return util::distance(distance, origin, direction, precision,
  [&](const Vector<S,2> input) {
    return this->signedDistance(input);
  },
  [&](const Vector<S,2>& pos) {
    return isInsideBox(pos);
  });
}

References olb::util::distance().

Here is the call graph for this function:

Here is the caller graph for this function:

getMax()

template<typename S >

Vector< S, 2 > & olb::IndicatorF2D< S >::getMax ( )

virtual

Definition at line 75 of file indicatorBaseF2D.hh.

{
  return _myMax;
}

Here is the caller graph for this function:

getMin()

template<typename S >

Vector< S, 2 > & olb::IndicatorF2D< S >::getMin ( )

virtual

Definition at line 69 of file indicatorBaseF2D.hh.

{
  return _myMin;
}

Here is the caller graph for this function:

isInsideBox()

template<typename S >

bool olb::IndicatorF2D< S >::isInsideBox

(

Vector< S, 2 >

point

)

Returns true if point is inside a cube with corners _myMin and _myMax

Definition at line 195 of file indicatorBaseF2D.hh.

{
  return point >= _myMin && point <= _myMax;
}

normal()

template<typename S >

bool olb::IndicatorF2D< S >::normal ( Vector< S, 2 > & normal, const Vector< S, 2 > & origin, const Vector< S, 2 > & direction, int iC = -1 )

virtual

returns true and the normal if there was one found for an given origin and direction

(mind that the default computation is done by a numerical approximation which searches .. [TODO])

Reimplemented in olb::IndicatorCircle2D< S >.

Definition at line 134 of file indicatorBaseF2D.hh.

{
  //OstreamManager clout(std::cout,"normal");
  //clout << "Calculating IndicatorF2D Normal " << std::endl;
  bool originValue;
  (*this)(&originValue, origin.data());
  Vector<S,2> currentPoint(origin);
 
  S precision = .0001;
 
  S dist;
  distance(dist, origin, direction, iC);
 
 
  Vector<S,2> POS(origin + dist*direction*(1/norm(direction))); //Point on Surface
 
  Vector<S,2> point1;
  Vector<S,2> point2;
 
  bool currentValue;
 
  for (int n: {
         -90,90
         }) { //std::range<int> n = {-90, 90};
    S rotate(n);
    S pitch(rotate/2.);
    while (util::abs(pitch) >= precision) {
      S theta( util::degreeToRadian(rotate) );
 
      Vector<S,2> vec(util::cos(theta)*direction[0]+util::sin(theta)*direction[1],-util::sin(theta)*direction[0]+util::cos(theta)*direction[1]);
      currentPoint = POS + vec;
      (*this)(&currentValue, currentPoint.data());
 
      if (currentValue == originValue) {
        rotate -= pitch;
      }
      else {
        rotate += pitch;
      }
      pitch /= 2.;
    }
 
    if (n == -90) {
      point1 = currentPoint;
    }
    else if (n == 90) {
      point2 = currentPoint;
    }
  }
  // Calculate Normal from point1 and point2
  normal = Vector<S,2>((point2[1] - point1[1]), (-1)*(point2[0] - point1[0]));
 
 
  //S dist;
  //Vector<S,2> dist;
  //distance(dist, origin, direction, iC);
  //normal = Vector<S,2>(dist);
  return true;
}

References olb::util::abs(), olb::util::cos(), olb::Vector< T, D >::data(), olb::util::degreeToRadian(), olb::norm(), and olb::util::sin().

Here is the call graph for this function:

Here is the caller graph for this function:

operator()() [1/2]

template<typename S >

bool olb::IndicatorF2D< S >::operator() ( bool output[1], const S input[2] )

virtual

Returns true if input is inside the indicator.

Reimplemented in olb::IndicatorIdentity2D< S >.

Definition at line 239 of file indicatorBaseF2D.hh.

{
  output[0] = this->operator()(input);
  return output[0];
}

operator()() [2/2]

template<typename S >

bool olb::IndicatorF2D< S >::operator() ( const S input[] )

virtual

Indicator specific function operator overload.

Returns

Domain indicator i.e. true iff the input lies within the described domain.

Definition at line 201 of file indicatorBaseF2D.hh.

{
  return this->signedDistance(input) <= 0;
}

signedDistance()

template<typename S >

S olb::IndicatorF2D< S >::signedDistance ( const Vector< S, 2 > & input )

virtual

Returns signed distance to the nearest point on the indicator surface.

Reimplemented in olb::IndicatorCuboid2D< S >, olb::IndicatorCircle2D< S >, olb::IndicatorTriangle2D< S >, olb::IndicatorEquiTriangle2D< S >, olb::IndicatorBlockData2D< S >, olb::IndicPlus2D< S >, olb::IndicMinus2D< S >, olb::IndicMultiplication2D< S >, olb::IndicCalc2D< S, F >, olb::IndicCalc2D< S, util::minus >, olb::IndicCalc2D< S, util::multiplies >, and olb::IndicCalc2D< S, util::plus >.

Definition at line 215 of file indicatorBaseF2D.hh.

{
  // TODO: Add fallback algorithm here
  assert(false);
  return std::numeric_limits<double>::quiet_NaN();
}

surfaceNormal() [1/2]

template<typename S >

Vector< S, 2 > olb::IndicatorF2D< S >::surfaceNormal ( const Vector< S, 2 > & pos, const S meshSize )

virtual

Return surface normal.

Definition at line 223 of file indicatorBaseF2D.hh.

{
  return util::surfaceNormal(pos, meshSize,
  [&](const Vector<S,2>& pos) {
    return this->signedDistance(pos);
  });
}

References olb::util::surfaceNormal().

Here is the call graph for this function:

surfaceNormal() [2/2]

template<typename S >

Vector< S, 2 > olb::IndicatorF2D< S >::surfaceNormal	(	const Vector< S, 2 > &	pos,
		const S	meshSize,
		std::function< Vector< S, 2 >(const Vector< S, 2 > &)>	transformPos )

Return surface normal after possible translation and rotation.

Definition at line 232 of file indicatorBaseF2D.hh.

{
  return this->surfaceNormal(transformPos(pos), meshSize);
}

Member Data Documentation

_myMax

template<typename S >

Vector<S,2> olb::IndicatorF2D< S >::_myMax

protected

Definition at line 74 of file indicatorBaseF2D.h.

_myMin

template<typename S >

Vector<S,2> olb::IndicatorF2D< S >::_myMin

protected

Definition at line 73 of file indicatorBaseF2D.h.

---

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

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