# PhasicFlow: src/Interaction/contactSearch/methods/cellBased/cells.hpp Source File
PhasicFlow is an open-source parallel DEM (discrete element method) package for simulating granular flow. It is developed in C++ and can be exectued on both GPU (like CUDA) and CPU.

cells.hpp
Go to the documentation of this file.
/*------------------------------- phasicFlow ---------------------------------
O C enter of
O O E ngineering and
O O M ultiscale modeling of
OOOOOOO F luid flow
------------------------------------------------------------------------------
Copyright (C): www.cemf.ir
email: hamid.r.norouzi AT gmail.com
------------------------------------------------------------------------------
Licence:
This file is part of phasicFlow code. It is a free software for simulating
granular and multiphase flows. You can redistribute it and/or modify it under
the terms of GNU General Public License v3 or any other later versions.
phasicFlow is distributed to help others in their research in the field of
granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-----------------------------------------------------------------------------*/
#ifndef __cells_hpp__
#define __cells_hpp__
#include "types.hpp"
#include "box.hpp"
namespace pFlow
{
class cells
{
private:
// - domain
box domainBox_{realx3(0.0), realx3(1.0)};
// - cell size
real celldx_{1};
int32x3 numCells_{1,1,1};
// - protected methods
INLINE_FUNCTION_H
void calculate()
{
numCells_ = (domainBox_.maxPoint()-domainBox_.minPoint())/celldx_ + realx3(1.0);
numCells_ = max( numCells_ , int32x3(1) );
}
public:
INLINE_FUNCTION_HD
cells() = default;
INLINE_FUNCTION_H
cells(const box& domain, real cellSize)
:
domainBox_(domain),
celldx_(cellSize)
{
calculate();
}
INLINE_FUNCTION_HD
cells(const cells&) = default;
INLINE_FUNCTION_HD
cells& operator = (const cells&) = default;
INLINE_FUNCTION_HD
cells(cells &&) = default;
INLINE_FUNCTION_HD
cells& operator=(cells&&) = default;
cells getCells()const
{
return *this;
}
INLINE_FUNCTION_H
void setCellSize(real cellSize)
{
celldx_ = cellSize;
calculate();
}
INLINE_FUNCTION_HD
real cellSize()const
{
return celldx_;
}
INLINE_FUNCTION_HD
const int32x3& numCells()const
{
return numCells_;
}
INLINE_FUNCTION_HD
int32 nx()const
{
return numCells_.x();
}
INLINE_FUNCTION_HD
int32 ny()const
{
return numCells_.y();
}
INLINE_FUNCTION_HD
int32 nz()const
{
return numCells_.z();
}
INLINE_FUNCTION_HD
int64 totalCells()const
{
return static_cast< int64 >(numCells_.x())*
static_cast< int64 >(numCells_.y())*
static_cast< int64 >(numCells_.z());
}
const auto& domainBox()const
{
return domainBox_;
}
INLINE_FUNCTION_HD
int32x3 pointIndex(const realx3& p)const
{
return int32x3( (p - domainBox_.minPoint())/celldx_ );
}
INLINE_FUNCTION_HD
bool pointIndexInDomain(const realx3 p, int32x3& index)const
{
if(!inDomain(p))return false;
index = this->pointIndex(p);
return true;
}
INLINE_FUNCTION_HD
bool inDomain(const realx3& p)const
{
return domainBox_.isInside(p);
}
INLINE_FUNCTION_HD
bool inCellRange(const int32x3& cell)const
{
if(cell.x()<0)return false;
if(cell.y()<0)return false;
if(cell.z()<0)return false;
if(cell.x()>numCells_.x()-1) return false;
if(cell.y()>numCells_.y()-1) return false;
if(cell.z()>numCells_.z()-1) return false;
return true;
}
INLINE_FUNCTION_HD
bool inCellRange(int32 i, int32 j, int32 k)const
{
if(i<0)return false;
if(j<0)return false;
if(k<0)return false;
if(i>numCells_.x()-1) return false;
if(j>numCells_.y()-1) return false;
if(k>numCells_.z()-1) return false;
return true;
}
INLINE_FUNCTION_HD
void extendBox(
const realx3& p1,
const realx3& p2,
const realx3& p3,
real extent,
realx3& minP,
realx3& maxP)const
{
minP = min(min(p1,p2),p3) - extent*celldx_ ;
maxP = max(max(p1,p2),p3) + extent*celldx_ ;
minP = bound(minP);
maxP = bound(maxP);
}
INLINE_FUNCTION_HD
int32x3 bound(int32x3 p)const
{
return int32x3(
min( numCells_.x()-1, max(0,p.x())),
min( numCells_.y()-1, max(0,p.y())),
min( numCells_.z()-1, max(0,p.z()))
);
}
INLINE_FUNCTION_HD
realx3 bound(realx3 p)const
{
return realx3(
min( domainBox_.maxPoint().x(), max(domainBox_.minPoint().x(),p.x())),
min( domainBox_.maxPoint().y(), max(domainBox_.minPoint().y(),p.y())),
min( domainBox_.maxPoint().z(), max(domainBox_.minPoint().z(),p.z()))
);
}
};
}
#endif
pFlow::cells::numCells_
int32x3 numCells_
Definition: cells.hpp:41
pFlow::cells::nz
INLINE_FUNCTION_HD int32 nz() const
Definition: cells.hpp:114
pFlow::real
float real
Definition: builtinTypes.hpp:45
pFlow::cells::ny
INLINE_FUNCTION_HD int32 ny() const
Definition: cells.hpp:108
types.hpp
pFlow::cells::operator=
INLINE_FUNCTION_HD cells & operator=(const cells &)=default
pFlow::cells::pointIndexInDomain
INLINE_FUNCTION_HD bool pointIndexInDomain(const realx3 p, int32x3 &index) const
Definition: cells.hpp:139
pFlow::cells::inCellRange
INLINE_FUNCTION_HD bool inCellRange(int32 i, int32 j, int32 k) const
Definition: cells.hpp:165
box.hpp
pFlow::cells::domainBox
const auto & domainBox() const
Definition: cells.hpp:127
pFlow::cells::cells
INLINE_FUNCTION_H cells(const box &domain, real cellSize)
Definition: cells.hpp:57
pFlow::max
T max(const internalField< T, MemorySpace > &iField)
Definition: internalFieldAlgorithms.hpp:79
pFlow::int64
long long int int64
Definition: builtinTypes.hpp:52
pFlow::cells::nx
INLINE_FUNCTION_HD int32 nx() const
Definition: cells.hpp:102
pFlow::cells::cellSize
INLINE_FUNCTION_HD real cellSize() const
Definition: cells.hpp:90
pFlow::cells::extendBox
INLINE_FUNCTION_HD void extendBox(const realx3 &p1, const realx3 &p2, const realx3 &p3, real extent, realx3 &minP, realx3 &maxP) const
Definition: cells.hpp:178
pFlow::box::maxPoint
const INLINE_FUNCTION_HD realx3 & maxPoint() const
Definition: box.hpp:97
pFlow::realx3
triple< real > realx3
Definition: types.hpp:43
pFlow::triple::y
INLINE_FUNCTION_HD T & y()
access component
Definition: triple.hpp:144
pFlow
Definition: demGeometry.hpp:27
pFlow::cells::calculate
INLINE_FUNCTION_H void calculate()
Definition: cells.hpp:45
pFlow::cells::inCellRange
INLINE_FUNCTION_HD bool inCellRange(const int32x3 &cell) const
Definition: cells.hpp:153
pFlow::int32
int int32
Definition: builtinTypes.hpp:50
pFlow::cells::numCells
const INLINE_FUNCTION_HD int32x3 & numCells() const
Definition: cells.hpp:96
pFlow::cells::celldx_
real celldx_
Definition: cells.hpp:39
INLINE_FUNCTION_H
#define INLINE_FUNCTION_H
Definition: pFlowMacros.hpp:57
pFlow::int32x3
triple< int32 > int32x3
Definition: types.hpp:38
pFlow::cells::inDomain
INLINE_FUNCTION_HD bool inDomain(const realx3 &p) const
Definition: cells.hpp:147
pFlow::min
T min(const internalField< T, MemorySpace > &iField)
Definition: internalFieldAlgorithms.hpp:28
pFlow::triple::z
INLINE_FUNCTION_HD T & z()
access component
Definition: triple.hpp:156
pFlow::cells::pointIndex
INLINE_FUNCTION_HD int32x3 pointIndex(const realx3 &p) const
Definition: cells.hpp:133
pFlow::box::minPoint
const INLINE_FUNCTION_HD realx3 & minPoint() const
Definition: box.hpp:91
pFlow::box
Definition: box.hpp:32
pFlow::cells::bound
INLINE_FUNCTION_HD int32x3 bound(int32x3 p) const
Definition: cells.hpp:194
pFlow::cells::cells
INLINE_FUNCTION_HD cells()=default
pFlow::cells::bound
INLINE_FUNCTION_HD realx3 bound(realx3 p) const
Definition: cells.hpp:204
pFlow::domain
Definition: domain.hpp:31
pFlow::triple::x
INLINE_FUNCTION_HD T & x()
access component
Definition: triple.hpp:132
pFlow::cells
Definition: cells.hpp:31
INLINE_FUNCTION_HD
#define INLINE_FUNCTION_HD
Definition: pFlowMacros.hpp:55
pFlow::triple< int32 >
pFlow::cells::setCellSize
INLINE_FUNCTION_H void setCellSize(real cellSize)
Definition: cells.hpp:83
pFlow::box::isInside
INLINE_FUNCTION_HD bool isInside(const realx3 &point) const
Definition: box.hpp:84
pFlow::cells::totalCells
INLINE_FUNCTION_HD int64 totalCells() const
Definition: cells.hpp:120
pFlow::cells::domainBox_
box domainBox_
Definition: cells.hpp:36
pFlow::cells::getCells
cells getCells() const
Definition: cells.hpp:77