# PhasicFlow: src/phasicFlow/types/types.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.

types.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 __types_hpp__
#define __types_hpp__
#include "bTypes.hpp"
#include "bTypesFunctions.hpp"
#include "triple.hpp"
#include "quadruple.hpp"
#include "typeInfo.hpp"
namespace pFlow
{
using int8x3 = triple<int8>;
using int32x3 = triple<int32>;
using int64x3 = triple<int64>;
using uint8x3 = triple<uint8>;
using uint32x3 = triple<uint32>;
using uint64x3 = triple<uint64>;
using realx3 = triple<real>;
using int32x3x3 = triple<int32x3>;
using uint32x3x3 = triple<uint32x3>;
using realx3x3 = triple<realx3>;
using realx4 = quadruple<real>;
using realx4x3 = quadruple<realx3>;
/*template<>
inline word
triple<int8>::TYPENAME()
{
return "int8x3";
}
template<>
inline word
triple<int32>::TYPENAME()
{
return "int32x3";
}
template<>
inline word
basicTypeName<int64x3>()
{
return "int64x3";
}
template<>
inline word
basicTypeName<uint8x3>()
{
return "uint8x3";
}
template<>
inline word
basicTypeName<uint32x3>()
{
return "uint32x3";
}
template<>
inline word
basicTypeName<uint64x3>()
{
return "unit64x3";
}
template<>
inline word
basicTypeName<realx3>()
{
return "realx3";
}
template<>
inline word
basicTypeName<int32x3x3>()
{
return "int32x3x3";
}
template<>
inline word
basicTypeName<uint32x3x3>()
{
return "uint32x3x3";
}
template<>
inline word
basicTypeName<realx3x3>()
{
return "realx3x3";
}
template<>
inline word
basicTypeName<realx4>()
{
return "realx4";
}
template<>
inline word
basicTypeName<realx4x3>()
{
return "realx4x3";
}*/
extern const realx3 zero3;
extern const realx3 one3;
extern const realx3x3 zero33;
extern const realx3x3 one33;
extern const realx4 zero4;
} // pFlow
#endif //__types_hpp__
pFlow::zero33
const realx3x3 zero33(zero3)
Definition: types.hpp:140
pFlow::zero3
const realx3 zero3(0.0)
Definition: types.hpp:137
pFlow::one3
const realx3 one3(1.0)
Definition: types.hpp:138
quadruple.hpp
bTypes.hpp
pFlow
Definition: demGeometry.hpp:27
pFlow::one33
const realx3x3 one33(one3)
Definition: types.hpp:141
triple.hpp
typeInfo.hpp
pFlow::quadruple
Definition: quadruple.hpp:36
pFlow::zero4
const realx4 zero4(zero)
Definition: types.hpp:143
bTypesFunctions.hpp
pFlow::triple
A set of 3 variables that can be used for vector variables.
Definition: triple.hpp:36