olb::AnalyticalVelocityVolumeF< T > Class Template Reference

#include <analyticalVelocityVolumeF.h>

Inheritance diagram for olb::AnalyticalVelocityVolumeF< T >:

Collaboration diagram for olb::AnalyticalVelocityVolumeF< T >:

Public Member Functions
	AnalyticalVelocityVolumeF (std::string fileName)
Vector< T, 3 >	getPhysShape () const
T	getSpacing () const
bool	operator() (T output[], const T physR[]) override
Public Member Functions inherited from olb::AnalyticalF< 3, T, T >
AnalyticalF< D, T, T > &	operator- (AnalyticalF< D, T, T > &rhs)
AnalyticalF< D, T, T > &	operator+ (AnalyticalF< D, T, T > &rhs)
AnalyticalF< D, T, T > &	operator* (AnalyticalF< D, T, T > &rhs)
AnalyticalF< D, T, T > &	operator/ (AnalyticalF< D, T, T > &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
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)

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

Detailed Description

template<typename T>
class olb::AnalyticalVelocityVolumeF< T >

Definition at line 39 of file analyticalVelocityVolumeF.h.

Constructor & Destructor Documentation

AnalyticalVelocityVolumeF()

template<typename T >

olb::AnalyticalVelocityVolumeF< T >::AnalyticalVelocityVolumeF ( std::string fileName )

inline

Definition at line 56 of file analyticalVelocityVolumeF.h.

      : AnalyticalF<3,T,T>(3)
  {
    this->getName() = "VelocityVolumeImporter";
 
    OstreamManager clout(std::cout, "VelocityVolumeImporter");
    _fileName = fileName;
 
    #if not defined(FEATURE_VTK)
    if (isVTIFile(_fileName))
    {
      std::cerr << "To use the VTK format, add VTK to the FEATURES list in config.mk";
      exit(1);
    }
    #endif
    #if defined(FEATURE_VTK)
    if (!isVTIFile(_fileName)) {
      std::cerr << "Please convert your file to .vti to use the functor.";
      exit(1);
    } else {
      clout << "Read .vti file..." << std::endl;
      _reader->SetFileName(fileName.c_str());
      _reader->Update();
      auto* _data = _reader->GetOutput();
 
      _spacing = static_cast<T>(_data->GetSpacing()[0]);
      clout << "Read spacing : " << _spacing << std::endl;
      _data->GetDimensions(_shape.data());
      clout << "Read shape : " << _shape << std::endl;
      _data->GetOrigin(_origin.data());
      clout << "Read origin : " << _origin << std::endl;
 
      vtkCellData* _cellData = _data->GetCellData();
      vtkPointData* _pointData = _data->GetPointData();
      if (_cellData->GetNumberOfArrays() > 0) {
        clout << "Found CellData. " << std::endl;
        CellData = true;
        _cellLocator->SetDataSet(_data);
        _cellLocator->BuildLocator();
      } else if (_pointData->GetNumberOfArrays() > 0) {
        clout << "Found PointData." << std::endl;
        clout << "Warning: If functor reads only 0, consider converting PointData to CellData." << std::endl;
        PointData = true;
      } else {
        std::cerr << "Neither cell data nor point data found.";
        exit(1);
      }
    }
    #endif
  }

References olb::Vector< T, D >::data(), and olb::GenericF< T, S >::getName().

Here is the call graph for this function:

Member Function Documentation

getPhysShape()

template<typename T >

Vector< T, 3 > olb::AnalyticalVelocityVolumeF< T >::getPhysShape ( ) const

inline

Definition at line 107 of file analyticalVelocityVolumeF.h.

                                   {
    return _shape * _spacing;
  }

getSpacing()

template<typename T >

T olb::AnalyticalVelocityVolumeF< T >::getSpacing ( ) const

inline

Definition at line 111 of file analyticalVelocityVolumeF.h.

                       {
    return _spacing;
  }

operator()()

template<typename T >

bool olb::AnalyticalVelocityVolumeF< T >::operator() ( T output[], const T physR[] )

inlineoverride

Definition at line 115 of file analyticalVelocityVolumeF.h.

                                                       {
    #if defined(FEATURE_VTK)
    if (!isInside(physR)) {
      //std::cout << "Point outside." << std::endl;
      output[0] = 0;
      output[1] = 0;
      output[2] = 0;
      return true;
    }
 
    auto* _data = _reader->GetOutput();
 
    // cell data (preferred)
    if (CellData) {
      vtkCellData* _cellData = _data->GetCellData();
      // Assuming cellData holds the velocity data in the first array
      vtkDataArray* _vectors = _cellData->GetVectors(_cellData->GetArrayName(0));
      if (_vectors == nullptr) {
        std::cerr << "[AnalyticalVelocityVolumeF]: ";
        std::cerr << "Cell data: No vector data was found." << std::endl;
        exit(1);
      }
 
      double x[3] = {physR[0], physR[1], physR[2]};
      vtkIdType cellId = _cellLocator->FindCell(x);
      if (cellId >= 0) {
        double velocity[3] = {};
        _vectors->GetTuple(cellId, velocity);
        for (int dim = 0; dim < 3; ++dim) {
          output[dim] = static_cast<T>(velocity[dim]);
        }
      } else {
        //std::cout << "Cell not found." << std::endl;
        output[0] = 0;
        output[1] = 0;
        output[2] = 0;
      }
    }
 
    // point data (can cause problems due to round-off)
    else if (PointData) {
      vtkPointData* _pointData = _data->GetPointData();
      // Assuming pointData holds the velocity data in the first array
      vtkDataArray* _vectors = _pointData->GetVectors(_pointData->GetArrayName(0));
      if (_vectors == nullptr) {
        std::cerr << "[AnalyticalVelocityVolumeF]: ";
        std::cerr << "Point data: No vector data was found." << std::endl;
        return false;
      }
 
      Vector<int,3> x = getVtiLatticeR(physR);
      vtkIdType pointId = _data->FindPoint(x[0], x[1], x[2]);
      if (pointId >= 0) {
        double velocity[3] = {};
        _vectors->GetTuple(pointId, velocity);
        for (int dim = 0; dim < 3; ++dim) {
          output[dim] = static_cast<T>(velocity[dim]);
        }
      } else {
        //std::cout << "Point not found." << std::endl;
        output[0] = 0;
        output[1] = 0;
        output[2] = 0;
      }
    }
    #endif
    return true;
  }

References olb::AnalyticalF< 3, T, T >::dim.

---

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

• src/io/analyticalVelocityVolumeF.h