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

Helper for conveying the ability for operations on FIELD_TYPE. More...

#include <data.h>

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

Public Member Functions
template<typename FIELD_TYPE >
	FieldTypePromise (meta::id< FIELD_TYPE >)
std::string	name () const
std::optional< unsigned >	dimension () const
void	ensureAvailabilityIn (BlockLattice< T, DESCRIPTOR > &block)
void	ensureAvailabilityIn (BlockD< T, DESCRIPTOR > &block)
void	setPlaceholderExpression (Cell< Expr, DESCRIPTOR > &cell, std::vector< Expr > &expr)
std::vector< Expr >	getPlaceholderExpression (Cell< Expr, DESCRIPTOR > &cell)
bool	operator< (const FieldTypePromise< T, DESCRIPTOR > &rhs) const

Detailed Description

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

Helper for conveying the ability for operations on FIELD_TYPE.

e.g. enable field allocation and communication setup without exposing the concrete field type (which would necessitate templatization)

c.f. DynamicsPromise and PostProcessorPromise

Definition at line 95 of file data.h.

Constructor & Destructor Documentation

FieldTypePromise()

template<typename T , typename DESCRIPTOR >

template<typename FIELD_TYPE >

olb::FieldTypePromise< T, DESCRIPTOR >::FieldTypePromise ( meta::id< FIELD_TYPE > )

inline

Definition at line 113 of file data.h.

                                      :
    _name{fields::name<FIELD_TYPE>()},
    _allocateInLattice([](BlockLattice<T,DESCRIPTOR>& block) {
      if constexpr (concepts::LatticeDescriptor<DESCRIPTOR>) {
        block.template getData<FIELD_TYPE>();
      }
    }),
    _allocateInBlockD([](BlockD<T,DESCRIPTOR>& block) {
       block.template getData<FIELD_TYPE>();
    }),
    _setPlaceholderExpr([](Cell<Expr,DESCRIPTOR>& cell, std::vector<Expr>& expr) {
      if constexpr (concepts::LatticeDescriptor<DESCRIPTOR>) {
        if constexpr (fields::isArray<FIELD_TYPE>()) {
          if constexpr (std::is_same_v<Expr, typename FieldD<Expr,DESCRIPTOR,typename FIELD_TYPE::field_t>::value_t>) {
            FieldD<Expr,DESCRIPTOR,typename FIELD_TYPE::field_t> placeholder{};
            for (unsigned iD=0; iD < placeholder.d; ++iD) {
              placeholder[iD] = expr[iD];
            }
            cell.template setField<typename FIELD_TYPE::field_t>(placeholder);
          } else {
            throw std::runtime_error("Can not set placeholder for non-T types");
          }
        } else {
          throw std::runtime_error("Can not set placeholder for non-FieldArray types");
        }
      }
    }),
    _getPlaceholderExpr([](Cell<Expr,DESCRIPTOR>& cell) {
      std::vector<Expr> expressions;
      if constexpr (concepts::LatticeDescriptor<DESCRIPTOR>) {
        if constexpr (fields::isArray<FIELD_TYPE>()) {
          if constexpr (std::is_same_v<Expr, typename FieldD<Expr,DESCRIPTOR,typename FIELD_TYPE::field_t>::value_t>) {
            FieldD<Expr,DESCRIPTOR,typename FIELD_TYPE::field_t> placeholder{};
            placeholder = cell.template getFieldPointer<typename FIELD_TYPE::field_t>();
            for (unsigned iD=0; iD < placeholder.d; ++iD) {
              expressions.push_back(placeholder[iD]);
            }
          } else {
            throw std::runtime_error("Can not get placeholder for non-T types");
          }
        } else {
          throw std::runtime_error("Can not get placeholder for non-FieldArray types");
        }
      }
      return expressions;
    })
  {
    if constexpr (fields::isArray<FIELD_TYPE>()) {
      _dim = std::optional<unsigned>{DESCRIPTOR::template size<typename FIELD_TYPE::field_t>()};
    }
  }

Member Function Documentation

dimension()

template<typename T , typename DESCRIPTOR >

std::optional< unsigned > olb::FieldTypePromise< T, DESCRIPTOR >::dimension ( ) const

inline

Definition at line 169 of file data.h.

                                          {
    return _dim;
  }

ensureAvailabilityIn() [1/2]

template<typename T , typename DESCRIPTOR >

void olb::FieldTypePromise< T, DESCRIPTOR >::ensureAvailabilityIn ( BlockD< T, DESCRIPTOR > & block )

inline

Definition at line 177 of file data.h.

                                                         {
    _allocateInBlockD(block);
  }

ensureAvailabilityIn() [2/2]

template<typename T , typename DESCRIPTOR >

void olb::FieldTypePromise< T, DESCRIPTOR >::ensureAvailabilityIn ( BlockLattice< T, DESCRIPTOR > & block )

inline

Definition at line 173 of file data.h.

                                                               {
    _allocateInLattice(block);
  }

getPlaceholderExpression()

template<typename T , typename DESCRIPTOR >

std::vector< Expr > olb::FieldTypePromise< T, DESCRIPTOR >::getPlaceholderExpression ( Cell< Expr, DESCRIPTOR > & cell )

inline

Definition at line 185 of file data.h.

                                                                        {
    return _getPlaceholderExpr(cell);
  }

name()

template<typename T , typename DESCRIPTOR >

std::string olb::FieldTypePromise< T, DESCRIPTOR >::name ( ) const

inline

Definition at line 165 of file data.h.

                         {
    return _name;
  }

Here is the caller graph for this function:

operator<()

template<typename T , typename DESCRIPTOR >

bool olb::FieldTypePromise< T, DESCRIPTOR >::operator< ( const FieldTypePromise< T, DESCRIPTOR > & rhs ) const

inline

Definition at line 189 of file data.h.

                                                                  {
    return name() < rhs.name();
  }

References olb::FieldTypePromise< T, DESCRIPTOR >::name().

Here is the call graph for this function:

setPlaceholderExpression()

template<typename T , typename DESCRIPTOR >

void olb::FieldTypePromise< T, DESCRIPTOR >::setPlaceholderExpression ( Cell< Expr, DESCRIPTOR > & cell, std::vector< Expr > & expr )

inline

Definition at line 181 of file data.h.

                                                                                    {
    _setPlaceholderExpr(cell, expr);
  }

---

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

• src/core/data.h