phasicFlow/src/Interaction/contactSearch/methods/cellBased/cells.hpp

/*------------------------------- 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