olb::BlockStructureD< D > Class Template Reference

Base of a regular block. More...

#include <blockStructure.h>

Inheritance diagram for olb::BlockStructureD< D >:

Collaboration diagram for olb::BlockStructureD< D >:

Public Member Functions
	BlockStructureD (Vector< int, D > size, int padding=0)
	BlockStructureD ()
void	resize (Vector< int, D > size)
auto	getCore () const
int	getNx () const
	Read only access to block width.
int	getNy () const
	Read only access to block height.
int	getNz () const
	Read only access to block height.
LatticeR< D >	getExtent () const
int	getPadding () const
	Read only access to padding.
std::size_t	getNcells () const
	Get number of cells.
CellID	getCellId (LatticeR< D > latticeR) const
	Get 1D cell ID.
template<typename... L>
std::enable_if_t< sizeof...(L)==D, CellID >	getCellId (L... latticeR) const
LatticeR< D >	getLatticeR (CellID iCell) const
CellDistance	getNeighborDistance (LatticeR< D > dir) const
	Get 1D neighbor distance.
bool	isInside (LatticeR< D > latticeR) const
	Return whether location is valid.
bool	isInsideCore (LatticeR< D > latticeR) const
	Return whether location is inside core.
bool	isPadding (LatticeR< D > latticeR) const
	Return whether location is valid.
bool	isPadding (LatticeR< D > latticeR, int overlap) const
bool	isPadding (CellID iCell) const
template<typename... L>
std::enable_if_t< sizeof...(L)==D, bool >	isInside (L... latticeR) const
CellDistance	getNeighborhoodRadius (LatticeR< D > latticeR) const
	Return maximum valid neighborhood sphere radius w.r.t. latticeR.
template<typename F >
void	forSpatialLocations (F f) const
template<typename F >
void	forSpatialLocationsParallel (F f) const
template<typename F >
void	forSpatialLocations (LatticeR< D > min, LatticeR< D > max, F f) const
template<typename F >
void	forCoreSpatialLocations (F f) const
template<typename F >
void	forCellIndices (F f) const

Protected Attributes
LatticeR< D >	_core
LatticeR< D >	_size
LatticeR< D >	_projection
int	_padding

Detailed Description

template<unsigned D>
class olb::BlockStructureD< D >

Base of a regular block.

With extent, optional padding and memory bijection for spatial locations

Definition at line 54 of file blockStructure.h.

Constructor & Destructor Documentation

BlockStructureD() [1/2]

template<unsigned D>

olb::BlockStructureD< D >::BlockStructureD ( Vector< int, D > size, int padding = 0 )

inline

Definition at line 65 of file blockStructure.h.

                                                    :
    _core(size),
    _size(size + 2*padding),
    _padding(padding)
  {
           if constexpr (D == 3) {
      _projection = {_size[1]*_size[2], _size[2], 1};
    } else if constexpr (D == 2) {
      _projection = {_size[1], 1};
    } else if constexpr (D == 1) {
      _projection = {1};
    } else {
      static_assert(D >= 1 && D <= 3, "Invalid D");
    }
 
    if (getNcells() > 0 && getNcells()-1 > std::numeric_limits<CellID>::max()) {
      throw std::invalid_argument("Cell count must not exceed cell index space");
    }
  };

References olb::BlockStructureD< D >::_projection, olb::BlockStructureD< D >::_size, and olb::BlockStructureD< D >::getNcells().

Here is the call graph for this function:

BlockStructureD() [2/2]

template<unsigned D>

olb::BlockStructureD< D >::BlockStructureD ( )

inline

Definition at line 85 of file blockStructure.h.

                   :
    BlockStructureD(1, 0)
  { };

Member Function Documentation

forCellIndices()

template<unsigned D>

template<typename F >

void olb::BlockStructureD< D >::forCellIndices ( F f ) const

inline

Definition at line 376 of file blockStructure.h.

  {
    for (CellID iCell=0; iCell < getNcells(); ++iCell) {
      f(iCell);
    }
  }

References olb::BlockStructureD< D >::getNcells().

Here is the call graph for this function:

forCoreSpatialLocations()

template<unsigned D>

template<typename F >

void olb::BlockStructureD< D >::forCoreSpatialLocations ( F f ) const

inline

Definition at line 343 of file blockStructure.h.

  {
    using loc = typename LatticeR<D>::value_t;
    for (loc iX=0; iX < _core[0]; ++iX) {
      if constexpr (D > 1) {
        for (loc iY=0; iY < _core[1]; ++iY) {
          if constexpr (D == 3) {
            for (loc iZ=0; iZ < _core[2]; ++iZ) {
              if constexpr (std::is_invocable_v<F, LatticeR<D>>) {
                f({iX,iY,iZ});
              } else {
                f(iX,iY,iZ);
              }
            }
          } else {
            if constexpr (std::is_invocable_v<F, LatticeR<D>>) {
              f({iX,iY});
            } else {
              f(iX,iY);
            }
          }
        }
      } else {
        if constexpr (std::is_invocable_v<F, LatticeR<D>>) {
          f({iX});
        } else {
          f(iX);
        }
      }
    }
  };

References olb::BlockStructureD< D >::_core.

Here is the caller graph for this function:

forSpatialLocations() [1/2]

template<unsigned D>

template<typename F >

void olb::BlockStructureD< D >::forSpatialLocations ( F f ) const

inline

Definition at line 236 of file blockStructure.h.

  {
    using loc = typename LatticeR<D>::value_t;
    for (loc iX=-_padding; iX < _core[0] + _padding; ++iX) {
      if constexpr (D > 1) {
        for (loc iY=-_padding; iY < _core[1] + _padding; ++iY) {
          if constexpr (D == 3) {
            for (loc iZ=-_padding; iZ < _core[2] + _padding; ++iZ) {
              if constexpr (std::is_invocable_v<F, LatticeR<D>>) {
                f({iX,iY,iZ});
              } else {
                f(iX,iY,iZ);
              }
            }
          } else {
            if constexpr (std::is_invocable_v<F, LatticeR<D>>) {
              f({iX,iY});
            } else {
              f(iX,iY);
            }
          }
        }
      } else {
        if constexpr (std::is_invocable_v<F, LatticeR<D>>) {
          f({iX});
        } else {
          f(iX);
        }
      }
    }
  };

References olb::BlockStructureD< D >::_core, and olb::BlockStructureD< D >::_padding.

Here is the caller graph for this function:

forSpatialLocations() [2/2]

template<unsigned D>

template<typename F >

void olb::BlockStructureD< D >::forSpatialLocations ( LatticeR< D > min, LatticeR< D > max, F f ) const

inline

Definition at line 310 of file blockStructure.h.

  {
    using loc = typename LatticeR<D>::value_t;
    for (loc iX=std::max(-_padding, min[0]); iX < std::min(_core[0] + _padding, max[0]+1); ++iX) {
      if constexpr (D > 1) {
        for (loc iY=std::max(-_padding, min[1]); iY < std::min(_core[1] + _padding, max[1]+1); ++iY) {
          if constexpr (D == 3) {
            for (loc iZ=std::max(-_padding, min[2]); iZ < std::min(_core[2] + _padding, max[2]+1); ++iZ) {
              if constexpr (std::is_invocable_v<F, LatticeR<D>>) {
                f({iX,iY,iZ});
              } else {
                f(iX,iY,iZ);
              }
            }
          } else {
            if constexpr (std::is_invocable_v<F, LatticeR<D>>) {
              f({iX,iY});
            } else {
              f(iX,iY);
            }
          }
        }
      } else {
        if constexpr (std::is_invocable_v<F, LatticeR<D>>) {
          f({iX});
        } else {
          f(iX);
        }
      }
    }
  };

References olb::BlockStructureD< D >::_core, and olb::BlockStructureD< D >::_padding.

forSpatialLocationsParallel()

template<unsigned D>

template<typename F >

void olb::BlockStructureD< D >::forSpatialLocationsParallel ( F f ) const

inline

Definition at line 269 of file blockStructure.h.

  {
    using loc = typename LatticeR<D>::value_t;
    if constexpr (D > 1) {
      #ifdef PARALLEL_MODE_OMP
      #pragma omp parallel for schedule(dynamic,1)
      #endif
      for (loc iX=-_padding; iX < _core[0] + _padding; ++iX) {
        for (loc iY=-_padding; iY < _core[1] + _padding; ++iY) {
          if constexpr (D == 3) {
            for (loc iZ=-_padding; iZ < _core[2] + _padding; ++iZ) {
              if constexpr (std::is_invocable_v<F, LatticeR<D>>) {
                f({iX,iY,iZ});
              } else {
                f(iX,iY,iZ);
              }
            }
          } else {
            if constexpr (std::is_invocable_v<F, LatticeR<D>>) {
              f({iX,iY});
            } else {
              f(iX,iY);
            }
          }
        }
      }
    } else {
      #ifdef PARALLEL_MODE_OMP
      #pragma omp parallel for schedule(static)
      #endif
      for (loc iX=-_padding; iX < _core[0] + _padding; ++iX) {
         if constexpr (std::is_invocable_v<F, LatticeR<D>>) {
           f({iX});
         } else {
           f(iX);
         }
      }
    }
  }

References olb::BlockStructureD< D >::_core, and olb::BlockStructureD< D >::_padding.

getCellId() [1/2]

template<unsigned D>

template<typename... L>

std::enable_if_t< sizeof...(L)==D, CellID > olb::BlockStructureD< D >::getCellId ( L... latticeR ) const

inline

Definition at line 158 of file blockStructure.h.

  {
    return LatticeR<D>{latticeR+_padding...} * _projection;
  }

References olb::BlockStructureD< D >::_padding, and olb::BlockStructureD< D >::_projection.

getCellId() [2/2]

template<unsigned D>

CellID olb::BlockStructureD< D >::getCellId ( LatticeR< D > latticeR ) const

inline

Get 1D cell ID.

Definition at line 150 of file blockStructure.h.

  {
    OLB_PRECONDITION(isInside(latticeR));
    return (latticeR+_padding) * _projection;
  }

References olb::BlockStructureD< D >::_padding, olb::BlockStructureD< D >::_projection, olb::BlockStructureD< D >::isInside(), and OLB_PRECONDITION.

Here is the call graph for this function:

Here is the caller graph for this function:

getCore()

template<unsigned D>

auto olb::BlockStructureD< D >::getCore ( ) const

inline

Definition at line 102 of file blockStructure.h.

  {
    return _core;
  }

References olb::BlockStructureD< D >::_core.

Here is the caller graph for this function:

getExtent()

template<unsigned D>

LatticeR< D > olb::BlockStructureD< D >::getExtent ( ) const

inline

Definition at line 125 of file blockStructure.h.

  {
    return _core;
  }

References olb::BlockStructureD< D >::_core.

getLatticeR()

template<unsigned D>

LatticeR< D > olb::BlockStructureD< D >::getLatticeR ( CellID iCell ) const

inline

Definition at line 163 of file blockStructure.h.

  {
    if constexpr (D == 3) {
      const std::int32_t iX = iCell / _projection[0];
      const std::int32_t remainder = iCell % _projection[0];
      const std::int32_t iY = remainder / _projection[1];
      const std::int32_t iZ = remainder % _projection[1];
      return LatticeR<D>{iX - _padding, iY - _padding, iZ - _padding};
    } else {
      const std::int32_t iX = iCell / _projection[0];
      const std::int32_t iY = iCell % _projection[0];
      return LatticeR<D>{iX - _padding, iY - _padding};
    }
  };

References olb::BlockStructureD< D >::_padding, and olb::BlockStructureD< D >::_projection.

Here is the caller graph for this function:

getNcells()

template<unsigned D>

std::size_t olb::BlockStructureD< D >::getNcells ( ) const

inline

Get number of cells.

Definition at line 137 of file blockStructure.h.

  {
           if constexpr (D == 3) {
      return _size[0] * _size[1] * _size[2];
    } else if constexpr (D == 2) {
      return _size[0] * _size[1];
    } else if constexpr (D == 1) {
      return _size[0];
    }
    __builtin_unreachable();
  }

References olb::BlockStructureD< D >::_size.

Here is the caller graph for this function:

getNeighborDistance()

template<unsigned D>

CellDistance olb::BlockStructureD< D >::getNeighborDistance ( LatticeR< D > dir ) const

inline

Get 1D neighbor distance.

Definition at line 179 of file blockStructure.h.

  {
    return dir * _projection;
  }

References olb::BlockStructureD< D >::_projection.

Here is the caller graph for this function:

getNeighborhoodRadius()

template<unsigned D>

CellDistance olb::BlockStructureD< D >::getNeighborhoodRadius ( LatticeR< D > latticeR ) const

inline

Return maximum valid neighborhood sphere radius w.r.t. latticeR.

Definition at line 223 of file blockStructure.h.

  {
    auto lower = latticeR + _padding;
    auto upper = LatticeR<D>([&](unsigned iDim) -> int {
      int x = lower[iDim] - _size[iDim] + 1;
      return x < 0 ? -x : 0;
    });
    auto y = std::min(*std::min_element(lower.data(), lower.data() + D),
                      *std::min_element(upper.data(), upper.data() + D));
    return y;
  };

References olb::BlockStructureD< D >::_padding, and olb::BlockStructureD< D >::_size.

Here is the caller graph for this function:

getNx()

template<unsigned D>

int olb::BlockStructureD< D >::getNx ( ) const

inline

Read only access to block width.

Definition at line 108 of file blockStructure.h.

  {
    return _core[0];
  };

References olb::BlockStructureD< D >::_core.

Here is the caller graph for this function:

getNy()

template<unsigned D>

int olb::BlockStructureD< D >::getNy ( ) const

inline

Read only access to block height.

Definition at line 113 of file blockStructure.h.

  {
    static_assert(D >= 2, "y-component only available in 2D or higher");
    return _core[1];
  };

References olb::BlockStructureD< D >::_core.

Here is the caller graph for this function:

getNz()

template<unsigned D>

int olb::BlockStructureD< D >::getNz ( ) const

inline

Read only access to block height.

Definition at line 119 of file blockStructure.h.

  {
    static_assert(D >= 3, "z-component only available in 3D or higher");
    return _core[2];
  };

References olb::BlockStructureD< D >::_core.

Here is the caller graph for this function:

getPadding()

template<unsigned D>

int olb::BlockStructureD< D >::getPadding ( ) const

inline

Read only access to padding.

Definition at line 131 of file blockStructure.h.

  {
    return _padding;
  };

References olb::BlockStructureD< D >::_padding.

Here is the caller graph for this function:

isInside() [1/2]

template<unsigned D>

template<typename... L>

std::enable_if_t< sizeof...(L)==D, bool > olb::BlockStructureD< D >::isInside ( L... latticeR ) const

inline

Definition at line 217 of file blockStructure.h.

  {
    return isInside({latticeR...});
  };

References olb::BlockStructureD< D >::isInside().

Here is the call graph for this function:

isInside() [2/2]

template<unsigned D>

bool olb::BlockStructureD< D >::isInside ( LatticeR< D > latticeR ) const

inline

Return whether location is valid.

Definition at line 185 of file blockStructure.h.

  {
    return latticeR >= -_padding && latticeR < _core + _padding;
  };

References olb::BlockStructureD< D >::_core, and olb::BlockStructureD< D >::_padding.

Here is the caller graph for this function:

isInsideCore()

template<unsigned D>

bool olb::BlockStructureD< D >::isInsideCore ( LatticeR< D > latticeR ) const

inline

Return whether location is inside core.

Definition at line 191 of file blockStructure.h.

  {
    return latticeR >= 0 && latticeR < _core;
  };

References olb::BlockStructureD< D >::_core.

Here is the caller graph for this function:

isPadding() [1/3]

template<unsigned D>

bool olb::BlockStructureD< D >::isPadding ( CellID iCell ) const

inline

Definition at line 210 of file blockStructure.h.

  {
    return isPadding(getLatticeR(iCell));
  };

References olb::BlockStructureD< D >::getLatticeR(), and olb::BlockStructureD< D >::isPadding().

Here is the call graph for this function:

isPadding() [2/3]

template<unsigned D>

bool olb::BlockStructureD< D >::isPadding ( LatticeR< D > latticeR ) const

inline

Return whether location is valid.

Definition at line 197 of file blockStructure.h.

  {
    return isInside(latticeR) && !(latticeR >= 0 && latticeR < _core);
  };

References olb::BlockStructureD< D >::_core, and olb::BlockStructureD< D >::isInside().

Here is the call graph for this function:

Here is the caller graph for this function:

isPadding() [3/3]

template<unsigned D>

bool olb::BlockStructureD< D >::isPadding ( LatticeR< D > latticeR, int overlap ) const

inline

Definition at line 202 of file blockStructure.h.

  {
    return  isInside(latticeR)
        && !isInsideCore(latticeR)
        &&  latticeR >=      -overlap
        &&  latticeR <  _core+overlap;
  };

References olb::BlockStructureD< D >::_core, olb::BlockStructureD< D >::isInside(), and olb::BlockStructureD< D >::isInsideCore().

Here is the call graph for this function:

resize()

template<unsigned D>

void olb::BlockStructureD< D >::resize ( Vector< int, D > size )

inline

Definition at line 89 of file blockStructure.h.

  {
    _core = size;
    _size = size + 2*_padding;
           if constexpr (D == 3) {
      _projection = {_size[1]*_size[2], _size[2], 1};
    } else if constexpr (D == 2) {
      _projection = {_size[1], 1};
    } else if constexpr (D == 1) {
      _projection = {1};
    }
  }

References olb::BlockStructureD< D >::_core, olb::BlockStructureD< D >::_padding, olb::BlockStructureD< D >::_projection, and olb::BlockStructureD< D >::_size.

Member Data Documentation

_core

template<unsigned D>

LatticeR<D> olb::BlockStructureD< D >::_core

protected

Definition at line 56 of file blockStructure.h.

_padding

template<unsigned D>

int olb::BlockStructureD< D >::_padding

protected

Definition at line 60 of file blockStructure.h.

_projection

template<unsigned D>

LatticeR<D> olb::BlockStructureD< D >::_projection

protected

Definition at line 58 of file blockStructure.h.

_size

template<unsigned D>

LatticeR<D> olb::BlockStructureD< D >::_size

protected

Definition at line 57 of file blockStructure.h.

---

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

• src/core/blockStructure.h