olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR > Class Template Reference

#include <superPorousElementEmbeddingO.h>

Collaboration diagram for olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >:

Public Member Functions
	SuperPorousElementEmbeddingO (SuperLattice< T, DESCRIPTOR > &sLattice)
template<concepts::PorosityElementF PorosityF>
void	registerElementType (FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&indicatorF)
template<concepts::Parameters PARAMETERS>
void	add (PARAMETERS &element)
void	initialize ()
template<typename FIELD >
FieldD< T, DESCRIPTOR, FIELD >	getField (std::size_t iElement) const
template<typename FIELD >
void	setField (std::size_t iElement, FieldD< T, DESCRIPTOR, FIELD > data)
template<typename FIELD_TYPE >
void	setProcessingContext (ProcessingContext context)
void	apply ()

Detailed Description

template<typename T, typename DESCRIPTOR>
class olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >

Definition at line 47 of file superPorousElementEmbeddingO.h.

Constructor & Destructor Documentation

SuperPorousElementEmbeddingO()

template<typename T , typename DESCRIPTOR >

olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >::SuperPorousElementEmbeddingO ( SuperLattice< T, DESCRIPTOR > & sLattice )

inline

Definition at line 68 of file superPorousElementEmbeddingO.h.

                                                                     :
    _sLattice(sLattice),
    _elementsD(makeSharedData<
      T,descriptors::fsi::ELEMENTS<DESCRIPTOR::d>>(sLattice.getLoadBalancer(), 0))
  {
    OstreamManager clout(std::cout, "SuperPorousElementEmbeddingO");
 
    //clout << "Expose physical cell locations" << std::endl;
 
    auto& load = _sLattice.getLoadBalancer();
    for (int iC=0; iC < load.size(); ++iC) {
      auto& block = _sLattice.getBlock(iC);
      block.template getField<fields::fsi::REDUCED_ELEMENT_TAG>();
      block.forCoreSpatialLocations([&](LatticeR<DESCRIPTOR::d> loc) {
        auto latticeR = loc.withPrefix(load.glob(iC));
        auto physR = _sLattice.getCuboidDecomposition().getPhysR(latticeR);
        block.get(loc).template setField<descriptors::LOCATION>(physR);
      });
    }
    _sLattice.template setProcessingContext<Array<descriptors::LOCATION>>(ProcessingContext::Simulation);
 
    _exposeElementTypeParametersO[typeid(SuperPorousElementEmbeddingO)] = [this](std::size_t nElements){
      descriptors::fsi::ELEMENTS<DESCRIPTOR::d>::fields_t::for_each([this,nElements](auto field) {
        using field_t = typename decltype(field)::type;
        auto& fieldArrayD = _elementsD->template get<Array<field_t>>();
        fieldArrayD.resize(nElements);
        _sLattice.template setParameter<fields::array_of<field_t>>(fieldArrayD);
      });
    };
  }

References olb::meta::list< FIELDS... >::for_each(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getCuboidDecomposition(), olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >::getField(), olb::SuperStructure< T, D >::getLoadBalancer(), olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >::setField(), olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >::setProcessingContext(), olb::Simulation, olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >::SuperPorousElementEmbeddingO(), and olb::Vector< T, Size >::withPrefix().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Function Documentation

add()

template<typename T , typename DESCRIPTOR >

template<concepts::Parameters PARAMETERS>

void olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >::add ( PARAMETERS & element )

inline

Definition at line 126 of file superPorousElementEmbeddingO.h.

                                {
    std::size_t iElement = getElementCount();
    setElementCount(iElement+1);
    const std::size_t nElements = getElementCount();
 
    PARAMETERS::fields_t::for_each([&](auto field) {
      using field_t = typename decltype(field)::type;
      if (_elementsD->template provides<Array<field_t>>()) {
        _elementsD->template get<Array<field_t>>().set(
          iElement, element.template get<field_t>());
      }
    });
 
    if constexpr (PARAMETERS::fields_t::template contains<fields::fsi::ELEMENT_LOWER>()) {
      if constexpr (PARAMETERS::fields_t::template contains<fields::fsi::ELEMENT_UPPER>()) {
        _elementsD->template get<Array<fields::fsi::ELEMENT_UPPER>>().set(
          iElement, element.template get<fields::fsi::ELEMENT_UPPER>());
      } else {
        auto upper = element.template get<fields::fsi::ELEMENT_LOWER>()
                   + element.template get<fields::fsi::ELEMENT_REFERENCE_DELTA_X>()
                   * element.template get<fields::fsi::ELEMENT_REFERENCE_EXTENT>();
        _elementsD->template get<Array<fields::fsi::ELEMENT_UPPER>>().set(iElement, upper);
      }
    }
 
    if constexpr (PARAMETERS::fields_t::template contains<fields::fsi::ELEMENT_REFERENCE_DELTA_X>()) {
      _elementsD->template get<Array<fields::fsi::ELEMENT_REFERENCE_DELTA_X>>().set(
        iElement, element.template get<fields::fsi::ELEMENT_REFERENCE_DELTA_X>());
      _elementsD->template get<Array<fields::fsi::ELEMENT_REFERENCE_POROSITY>>().set(
        iElement, element.template get<fields::fsi::ELEMENT_REFERENCE_POROSITY>());
      auto extent = element.template get<fields::fsi::ELEMENT_REFERENCE_EXTENT>();
      FieldD<T,DESCRIPTOR,fields::fsi::ELEMENT_REFERENCE_PROJECTION> projection{};
      if constexpr (DESCRIPTOR::d == 3) {
        projection = {extent[1]*extent[2], extent[2], 1};
      } else {
        projection = {extent[1], 1};
      }
      _elementsD->template get<Array<fields::fsi::ELEMENT_REFERENCE_PROJECTION>>().set(iElement, projection);
    }
 
    _elementsD->setProcessingContext(ProcessingContext::Simulation);
    _sLattice.template setParameter<fields::fsi::ELEMENTS_COUNT>(nElements);
  }

References olb::Simulation.

apply()

template<typename T , typename DESCRIPTOR >

void olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >::apply ( )

inline

Definition at line 191 of file superPorousElementEmbeddingO.h.

               {
    _sLattice.executePostProcessors(stage::fsi::DistributeToFluid{});
  }

References olb::SuperLattice< T, DESCRIPTOR >::executePostProcessors().

Here is the call graph for this function:

getField()

template<typename T , typename DESCRIPTOR >

template<typename FIELD >

FieldD< T, DESCRIPTOR, FIELD > olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >::getField ( std::size_t iElement ) const

inline

Definition at line 177 of file superPorousElementEmbeddingO.h.

                                                                {
    return _elementsD->template get<Array<FIELD>>().get(iElement);
  }

Here is the caller graph for this function:

initialize()

template<typename T , typename DESCRIPTOR >

void olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >::initialize ( )

inline

Definition at line 170 of file superPorousElementEmbeddingO.h.

                    {
    setElementCount(getElementCount());
    _elementsD->setProcessingContext(ProcessingContext::Simulation);
    _sLattice.executePostProcessors(stage::fsi::Initialize{});
  }

References olb::SuperLattice< T, DESCRIPTOR >::executePostProcessors(), and olb::Simulation.

Here is the call graph for this function:

registerElementType()

template<typename T , typename DESCRIPTOR >

template<concepts::PorosityElementF PorosityF>

void olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >::registerElementType ( FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && indicatorF )

inline

Definition at line 100 of file superPorousElementEmbeddingO.h.

                                                                                    {
    PorosityF::data::for_each([&](auto field) {
      using field_t = typename decltype(field)::type;
      if (!_elementsD->template provides<Array<field_t>>()) {
        _elementsD->template allocate<Array<field_t>>(getElementCount());
      }
    });
 
    _sLattice.template addPostProcessor<stage::fsi::Initialize>(
      std::forward<decltype(indicatorF)>(indicatorF),
      meta::id<InitializePorosityO<PorosityF>>{});
    _sLattice.template addPostProcessor<stage::fsi::DistributeToFluid>(
      std::forward<decltype(indicatorF)>(indicatorF),
      meta::id<UpdatePorosityO<PorosityF>>{});
 
    _exposeElementTypeParametersO[typeid(PorosityF)] = [this](std::size_t nElements){
      PorosityF::data::for_each([this,nElements](auto field) {
        using field_t = typename decltype(field)::type;
        auto& fieldArrayD = _elementsD->template get<Array<field_t>>();
        fieldArrayD.resize(nElements);
        _sLattice.template setParameter<fields::array_of<field_t>>(fieldArrayD);
      });
    };
  }

setField()

template<typename T , typename DESCRIPTOR >

template<typename FIELD >

void olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >::setField ( std::size_t iElement, FieldD< T, DESCRIPTOR, FIELD > data )

inline

Definition at line 182 of file superPorousElementEmbeddingO.h.

                                                                     {
    _elementsD->template get<Array<FIELD>>().set(iElement, data);
  }

Here is the caller graph for this function:

setProcessingContext()

template<typename T , typename DESCRIPTOR >

template<typename FIELD_TYPE >

void olb::SuperPorousElementEmbeddingO< T, DESCRIPTOR >::setProcessingContext ( ProcessingContext context )

inline

Definition at line 187 of file superPorousElementEmbeddingO.h.

                                                       {
    _elementsD->template get<FIELD_TYPE>().setProcessingContext(context);
  }

Here is the caller graph for this function:

---

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

• src/fsi/superPorousElementEmbeddingO.h