olb::CartesianToPolar2D< T, S > Class Template Reference

This class converts Cartesian coordinates of point x to polar coordinates wrote into output field (output[0] = radius>= 0, output[1] = phi in [0, 2Pi). More...

#include <frameChangeF2D.h>

Inheritance diagram for olb::CartesianToPolar2D< T, S >:

Collaboration diagram for olb::CartesianToPolar2D< T, S >:

Public Member Functions
	CartesianToPolar2D (olb::Vector< T, 3 > cartesianOrigin, olb::Vector< T, 3 > axisDirection, olb::Vector< T, 3 > orientation={T(1), T(), T()})
	CartesianToPolar2D (T cartesianOriginX, T cartesianOriginY, T cartesianOriginZ, T axisDirectionX, T axisDirectionY, T axisDirectionZ, T orientationX=T(1), T orientationY=T(), T orientationZ=T())
bool	operator() (T output[], const S x[]) override
	operator writes polar coordinates of Cartesian point x into output field, returns output[0] = radius ( >= 0 ), output[1] = phi in [0, 2Pi)
Public Member Functions inherited from olb::AnalyticalF< D, T, S >
AnalyticalF< D, T, S > &	operator- (AnalyticalF< D, T, S > &rhs)
AnalyticalF< D, T, S > &	operator+ (AnalyticalF< D, T, S > &rhs)
AnalyticalF< D, T, S > &	operator* (AnalyticalF< D, T, S > &rhs)
AnalyticalF< D, T, S > &	operator/ (AnalyticalF< D, T, S > &rhs)
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
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
olb::Vector< T, 3 >	_cartesianOrigin
	origin of the Cartesian coordinate system
olb::Vector< T, 3 >	_axisDirection
	direction of the axis along which the polar coordinates are calculated
olb::Vector< T, 3 >	_orientation
	direction to know orientation for math positive to obtain angle phi of Cartesian point x

Additional Inherited Members
Public Types inherited from olb::AnalyticalF< D, T, S >
using	identity_functor_type = AnalyticalIdentity<D,T,S>
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::AnalyticalF< D, T, S >
static constexpr unsigned	dim = D
Protected Member Functions inherited from olb::AnalyticalF< D, T, S >
	AnalyticalF (int n)
Protected Member Functions inherited from olb::GenericF< T, S >
	GenericF (int targetDim, int sourceDim)

Detailed Description

template<typename T, typename S>
class olb::CartesianToPolar2D< T, S >

This class converts Cartesian coordinates of point x to polar coordinates wrote into output field (output[0] = radius>= 0, output[1] = phi in [0, 2Pi).

Initial situation for the polar coordinate system is that angle phi lies in plane perpendicular to the _axisDirection and turns around the _cartesianOrigin. The radius is the distance of point x to the _axisDirection.

Definition at line 146 of file frameChangeF2D.h.

Constructor & Destructor Documentation

CartesianToPolar2D() [1/2]

template<typename T , typename S >

olb::CartesianToPolar2D< T, S >::CartesianToPolar2D	(	olb::Vector< T, 3 >	cartesianOrigin,
		olb::Vector< T, 3 >	axisDirection,
		olb::Vector< T, 3 >	orientation = {T(1),T(),T()} )

Definition at line 211 of file frameChangeF2D.hh.

  : AnalyticalF2D<T, S>(2),
    _cartesianOrigin(cartesianOrigin),
    _axisDirection(axisDirection),
    _orientation(orientation)
{
  this->getName() = "const";
}

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

Here is the call graph for this function:

CartesianToPolar2D() [2/2]

template<typename T , typename S >

olb::CartesianToPolar2D< T, S >::CartesianToPolar2D	(	T	cartesianOriginX,
		T	cartesianOriginY,
		T	cartesianOriginZ,
		T	axisDirectionX,
		T	axisDirectionY,
		T	axisDirectionZ,
		T	orientationX = T(1),
		T	orientationY = T(),
		T	orientationZ = T() )

Definition at line 191 of file frameChangeF2D.hh.

  : AnalyticalF2D<T, S>(2)
{
  _cartesianOrigin[0] = cartesianOriginX;
  _cartesianOrigin[1] = cartesianOriginY;
  _cartesianOrigin[2] = cartesianOriginZ;
 
  _axisDirection[0] = axisDirectionX;
  _axisDirection[1] = axisDirectionY;
  _axisDirection[2] = axisDirectionZ;
 
  _orientation[0] = orientationX;
  _orientation[1] = orientationY;
  _orientation[2] = orientationZ;
}

References olb::CartesianToPolar2D< T, S >::_axisDirection, olb::CartesianToPolar2D< T, S >::_cartesianOrigin, and olb::CartesianToPolar2D< T, S >::_orientation.

Member Function Documentation

operator()()

template<typename T , typename S >

bool olb::CartesianToPolar2D< T, S >::operator() ( T output[], const S x[] )

overridevirtual

operator writes polar coordinates of Cartesian point x into output field, returns output[0] = radius ( >= 0 ), output[1] = phi in [0, 2Pi)

Implements olb::GenericF< T, S >.

Definition at line 225 of file frameChangeF2D.hh.

{
  //Vector<T, 3> x_rot(x[this->getSourceDim()]); //// CAUSES ERROR
  int dim = this->getSourceDim();
  //std::cout<<"Source dim return: "<<dim<<std::endl; //sourceDim = 2
  Vector<T, 3> x_rot;
  for (int i = 0; i < dim; ++i) {
    x_rot[i] = x[i];
  }
  Vector<T, 3> e3(T(), T(), 1);
  Vector<T, 3> axisDirection(_axisDirection);
 
  Vector<T, 3> normal = crossProduct3D(axisDirection, e3);
  Vector<T, 3> normalAxisDir(axisDirection);
  normalAxisDir = normalize(normalAxisDir);
 
  // if axis has to be rotated
  if (!( util::nearZero(normalAxisDir[0]) && util::nearZero(normalAxisDir[1]) && util::nearZero(normalAxisDir[2]-1) ) ) {
 
    if ( !util::nearZero(olb::norm(_orientation)) ) {
      normal = _orientation;
    }
 
    // normal is orientation direction
    AngleBetweenVectors3D<T, S> angle(util::fromVector3(e3), util::fromVector3(normal));
    T tmp[3] = {_axisDirection[0],_axisDirection[1],_axisDirection[2]};
    T alpha[1] = {};
    angle(alpha, tmp);
 
    // cross is rotation axis
    //Vector<T, 3> cross = crossProduct3D(e3, axisDirection);
    // rotation with angle alpha to rotAxisDir
    RotationRoundAxis3D<T, S> rotRAxis(_cartesianOrigin, util::fromVector3(normal), -alpha[0]);
    T x_tmp[3] = {};
    x_tmp[0] = x[0];
    x_tmp[1] = x[1];
    x_tmp[2] = x[2];
    T tmp2[3] = {};
    rotRAxis(tmp2,x_tmp);
    x_rot[0] = tmp2[0];
    x_rot[1] = tmp2[1];
    x_rot[2] = tmp2[2];
  }
 
  // calculates r, phi related to cartesianAxisDirection and their origin
  Vector<T, 2> difference;
  difference[0] = x_rot[0] - _cartesianOrigin[0];
  difference[1] = x_rot[1] - _cartesianOrigin[1];
  T distance = T();
 
  for (int i = 0; i < 2; ++i) {
    distance += difference[i]*difference[i];
  }
 
  distance = util::sqrt(distance);
  T phi[1] = {};
 
  if (distance > T()) {
    Vector<T, 3> e1(T(1), T(), T());
    AngleBetweenVectors3D<T, S> angle(util::fromVector3(e1), util::fromVector3(e3));
 
    T x_help[3] = {difference[0],difference[1],0.};
    angle(phi, x_help);
  }
 
  output[0] = distance;
  output[1] = phi[0];
  return true;
}

References olb::crossProduct3D(), olb::util::fromVector3(), olb::util::nearZero(), olb::norm(), olb::normalize(), and olb::util::sqrt().

Here is the call graph for this function:

Member Data Documentation

_axisDirection

template<typename T , typename S >

olb::Vector<T, 3> olb::CartesianToPolar2D< T, S >::_axisDirection

protected

direction of the axis along which the polar coordinates are calculated

Definition at line 151 of file frameChangeF2D.h.

_cartesianOrigin

template<typename T , typename S >

olb::Vector<T, 3> olb::CartesianToPolar2D< T, S >::_cartesianOrigin

protected

origin of the Cartesian coordinate system

Definition at line 149 of file frameChangeF2D.h.

_orientation

template<typename T , typename S >

olb::Vector<T, 3> olb::CartesianToPolar2D< T, S >::_orientation

protected

direction to know orientation for math positive to obtain angle phi of Cartesian point x

Definition at line 154 of file frameChangeF2D.h.

---

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

• src/functors/analytical/frameChangeF2D.h
• src/functors/analytical/frameChangeF2D.hh