olb::SuperLatticePointExtraction< T, DESCRIPTOR, FUNCTOR > Class Template Reference

Convenience class for extracting data associated to set of arbitrary physical points. More...

#include <superLatticePointExtraction.h>

Collaboration diagram for olb::SuperLatticePointExtraction< T, DESCRIPTOR, FUNCTOR >:

Public Member Functions
	SuperLatticePointExtraction (SuperLattice< T, DESCRIPTOR > &sLattice, const std::vector< Vector< T, DESCRIPTOR::d > > &points)
std::size_t	getSize () const
Vector< T, DESCRIPTOR::d >	getPhysR (std::size_t iExtracted) const
auto	getValue (std::size_t iExtracted) const
template<typename FIELD >
void	setParameter (FieldD< T, DESCRIPTOR, FIELD > &&value)
void	update ()

Detailed Description

template<typename T, typename DESCRIPTOR, typename FUNCTOR>
class olb::SuperLatticePointExtraction< T, DESCRIPTOR, FUNCTOR >

Convenience class for extracting data associated to set of arbitrary physical points.

Definition at line 53 of file superLatticePointExtraction.h.

Constructor & Destructor Documentation

SuperLatticePointExtraction()

template<typename T , typename DESCRIPTOR , typename FUNCTOR >

olb::SuperLatticePointExtraction< T, DESCRIPTOR, FUNCTOR >::SuperLatticePointExtraction	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		const std::vector< Vector< T, DESCRIPTOR::d > > &	points )

Definition at line 47 of file superLatticePointExtraction.hh.

  : _sLattice(sLattice),
    _sampleD(sLattice.getLoadBalancer()),
    _couplingO(PointExtractionO<FUNCTOR>{},
               names::Lattice{}, sLattice,
               names::Points{}, _sampleD),
    _extractionPointD(points.size()),
    _extractionResultD(points.size())
{
  const auto& geometry  = _sLattice.getCuboidDecomposition();
  LoadBalancer<T>& load = _sLattice.getLoadBalancer();
 
  for (int iC=0; iC < geometry.size(); ++iC) {
    _rankLocalPointsSize[iC] = 0;
  }
 
  for (std::size_t iG=0; iG < points.size(); ++iG) {
    const auto& physR = points[iG];
    _extractionPointD.setField(iG, physR);
    if (auto iC = geometry.getC(physR)) {
      if (load.isLocal(*iC)) {
        _rankLocalPoints.emplace_back(*iC, iG, physR);
        _rankLocalPointsSize[*iC]++;
      }
    }
  }
 
  std::map<int,int> rankLocalPointsIndex;
  for (auto [iC, size] : _rankLocalPointsSize) {
    if (load.isLocal(iC)) {
      auto& block = _sampleD.getBlock(load.loc(iC));
      block.resize({size,1,1});
      rankLocalPointsIndex[iC] = 0;
    }
  }
 
  for (auto& [iC, iG, physR] : _rankLocalPoints) {
    auto& block = _sampleD.getBlock(load.loc(iC));
    auto iPoint = rankLocalPointsIndex[iC]++;
    auto point = block.get(iPoint);
    point.template setField<fields::PHYS_R>(physR);
  }
 
  _sampleD.setProcessingContext(ProcessingContext::Simulation);
}

Member Function Documentation

getPhysR()

template<typename T , typename DESCRIPTOR , typename FUNCTOR >

Vector< T, DESCRIPTOR::d > olb::SuperLatticePointExtraction< T, DESCRIPTOR, FUNCTOR >::getPhysR ( std::size_t iExtracted ) const

inline

Definition at line 81 of file superLatticePointExtraction.h.

                                                             {
    return _extractionPointD.getField(iExtracted);
  }

References olb::FieldArrayD< T, DESCRIPTOR, PLATFORM, FIELD >::getField().

Here is the call graph for this function:

getSize()

template<typename T , typename DESCRIPTOR , typename FUNCTOR >

std::size_t olb::SuperLatticePointExtraction< T, DESCRIPTOR, FUNCTOR >::getSize ( ) const

inline

Definition at line 77 of file superLatticePointExtraction.h.

                            {
    return _extractionPointD.getSize();
  }

References olb::ColumnVector< COLUMN, D >::getSize().

Here is the call graph for this function:

getValue()

template<typename T , typename DESCRIPTOR , typename FUNCTOR >

auto olb::SuperLatticePointExtraction< T, DESCRIPTOR, FUNCTOR >::getValue ( std::size_t iExtracted ) const

inline

Definition at line 85 of file superLatticePointExtraction.h.

                                            {
    return _extractionResultD.getField(iExtracted);
  }

References olb::FieldArrayD< T, DESCRIPTOR, PLATFORM, FIELD >::getField().

Here is the call graph for this function:

setParameter()

template<typename T , typename DESCRIPTOR , typename FUNCTOR >

template<typename FIELD >

void olb::SuperLatticePointExtraction< T, DESCRIPTOR, FUNCTOR >::setParameter ( FieldD< T, DESCRIPTOR, FIELD > && value )

inline

Definition at line 90 of file superLatticePointExtraction.h.

                                                        {
    _couplingO.template setParameter<FIELD>(std::move(value));
  }

References olb::SuperLatticePointExtraction< T, DESCRIPTOR, FUNCTOR >::setParameter().

Here is the call graph for this function:

Here is the caller graph for this function:

update()

template<typename T , typename DESCRIPTOR , typename FUNCTOR >

void olb::SuperLatticePointExtraction< T, DESCRIPTOR, FUNCTOR >::update

(

)

Definition at line 96 of file superLatticePointExtraction.hh.

{
  _couplingO.execute();
  _sampleD.setProcessingContext(ProcessingContext::Evaluation);
 
#ifdef PARALLEL_MODE_MPI
  FieldArrayD<T,DESCRIPTOR,Platform::CPU_SISD,typename FUNCTOR::result_field> localResultD(
    _extractionResultD.getSize());
 
  updateExtractionResultD(localResultD);
 
  for (unsigned iD=0; iD < DESCRIPTOR::template size<typename FUNCTOR::result_field>(); ++iD) {
    singleton::mpi().reduce(localResultD[iD].data(),
                            _extractionResultD[iD].data(),
                            _extractionResultD[iD].size(),
                            MPI_SUM);
  }
#else
  updateExtractionResultD(_extractionResultD);
#endif
}

References olb::Evaluation, olb::singleton::mpi(), and olb::singleton::MpiManager::reduce().

Here is the call graph for this function:

---

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

• src/core/superLatticePointExtraction.h
• src/core/superLatticePointExtraction.hh