olb::SuperLatticeCoupling< COUPLER, COUPLEES > Class Template Reference

Coupling operator COUPLER on named COUPLEES. More...

#include <superLatticeCoupling.h>

Collaboration diagram for olb::SuperLatticeCoupling< COUPLER, COUPLEES >:

Public Member Functions
template<typename... MAP>
	SuperLatticeCoupling (COUPLER, MAP &&... args)
void	execute ()
	Execute coupling operation on all blocks.
template<typename FIELD >
void	setParameter (typename AbstractCouplingO< COUPLEES >::template FieldD< FIELD > &&field)
	Set coupling parameter FIELD.
template<typename FIELD >
auto	getParameter () const -> typename AbstractCouplingO< COUPLEES >::template FieldD< FIELD >
	Get coupling parameter FIELD for block 0.
AbstractCouplingO< COUPLEES > &	getBlock (int iC)
	Return block-level abstract coupling operator.
void	restrictTo (FunctorPtr< SuperIndicatorF< typename AbstractCouplingO< COUPLEES >::value_t, AbstractCouplingO< COUPLEES >::descriptor_t::d > > &&indicator)
	Restrict coupling operation to indicated locations.

Detailed Description

template<typename COUPLER, typename COUPLEES>
class olb::SuperLatticeCoupling< COUPLER, COUPLEES >

Coupling operator COUPLER on named COUPLEES.

Definition at line 232 of file superLatticeCoupling.h.

Constructor & Destructor Documentation

SuperLatticeCoupling()

template<typename COUPLER , typename COUPLEES >

template<typename... MAP>

olb::SuperLatticeCoupling< COUPLER, COUPLEES >::SuperLatticeCoupling ( COUPLER , MAP &&... args )

inline

Definition at line 259 of file superLatticeCoupling.h.

                                      {
    auto map = std::make_tuple(&args...);
    COUPLEES::keys_t::for_each([&](auto id) {
      using name_t = typename decltype(id)::type;
      constexpr unsigned idx = COUPLEES::keys_t::template index<name_t>();
      _lattices.template set<name_t>(std::get<2*idx+1>(map));
    });
 
    auto& load = _lattices.template get<0>()->getLoadBalancer();
    for (int iC = 0; iC < load.size(); ++iC) {
      Platform reference = _lattices.template get<0>()->getBlock(iC).getPlatform();
      _lattices.for_each([&](auto name, auto lattice) {
        if (lattice->getBlock(iC).getPlatform() != reference) {
          throw std::runtime_error("Platforms of coupled block lattices must match");
        }
      });
      callUsingConcretePlatform(reference,
                                [&](auto platform) {
        _block.emplace_back(constructConcreteBlockCoupling<platform.value>(iC));
      });
    }
  }

References olb::callUsingConcretePlatform().

Here is the call graph for this function:

Member Function Documentation

execute()

template<typename COUPLER , typename COUPLEES >

void olb::SuperLatticeCoupling< COUPLER, COUPLEES >::execute ( )

inline

Execute coupling operation on all blocks.

Definition at line 284 of file superLatticeCoupling.h.

  {
    auto& load = _lattices.template get<0>()->getLoadBalancer();
    #ifdef PARALLEL_MODE_OMP
    #pragma omp taskloop
    #endif
    for (int iC = 0; iC < load.size(); ++iC) {
      _block[iC]->execute();
    }
  }

Here is the caller graph for this function:

getBlock()

template<typename COUPLER , typename COUPLEES >

AbstractCouplingO< COUPLEES > & olb::SuperLatticeCoupling< COUPLER, COUPLEES >::getBlock ( int iC )

inline

Return block-level abstract coupling operator.

e.g. to set block-wise mask or parameter:

superCoupling.getBlock(iC).set(latticeR, false);

Definition at line 318 of file superLatticeCoupling.h.

  {
    return *_block[iC];
  }

getParameter()

template<typename COUPLER , typename COUPLEES >

template<typename FIELD >

auto olb::SuperLatticeCoupling< COUPLER, COUPLEES >::getParameter ( ) const -> typename AbstractCouplingO<COUPLEES>::template FieldD<FIELD>

inline

Get coupling parameter FIELD for block 0.

Definition at line 307 of file superLatticeCoupling.h.

  {
    return _block[0]->getParameters().template get<FIELD>();
  }

restrictTo()

template<typename COUPLER , typename COUPLEES >

void olb::SuperLatticeCoupling< COUPLER, COUPLEES >::restrictTo ( FunctorPtr< SuperIndicatorF< typename AbstractCouplingO< COUPLEES >::value_t, AbstractCouplingO< COUPLEES >::descriptor_t::d > > && indicator )

inline

Restrict coupling operation to indicated locations.

By default the entire (non-overlap) lattice area is coupled.

Definition at line 327 of file superLatticeCoupling.h.

  {
    using DESCRIPTOR = typename COUPLEES::values_t::template get<0>::descriptor_t;
    auto& load = _lattices.template get<0>()->getLoadBalancer();
    for (int iC = 0; iC < load.size(); ++iC) {
      const auto& blockL = _lattices.template get<0>()->getBlock(iC);
      auto& blockI = indicator->getBlockIndicatorF(iC);
      blockL.forCoreSpatialLocations([&](LatticeR<DESCRIPTOR::d> latticeR) {
        _block[iC]->set(blockL.getCellId(latticeR), blockI(latticeR));
      });
    }
  }

setParameter()

template<typename COUPLER , typename COUPLEES >

template<typename FIELD >

void olb::SuperLatticeCoupling< COUPLER, COUPLEES >::setParameter ( typename AbstractCouplingO< COUPLEES >::template FieldD< FIELD > && field )

inline

Set coupling parameter FIELD.

Definition at line 297 of file superLatticeCoupling.h.

  {
    auto& load = _lattices.template get<0>()->getLoadBalancer();
    for (int iC = 0; iC < load.size(); ++iC) {
      _block[iC]->getParameters().template set<FIELD>(std::forward<decltype(field)>(field));
    }
  }

---

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

• src/core/superLatticeCoupling.h