# PhasicFlow: src/Particles/SphereParticles/sphereShape/sphereShape.cpp 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.

sphereShape.cpp
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.
-----------------------------------------------------------------------------*/
#include "sphereShape.hpp"
bool pFlow::sphereShape::readFromDictionary3()
{
diameters_ = getVal<realVector>("diameters");
if(diameters_.size() != numShapes() )
{
fatalErrorInFunction<<
" number of elements in diameters in "<< globalName()<<" is not consistent"<<endl;
return false;
}
return true;
}
bool pFlow::sphereShape::writeToDict(dictionary& dict)const
{
if(!shape::writeToDict(dict))return false;
if( !dict.add("diameters", diameters_) )
{
fatalErrorInFunction<<
" Error in writing diameters to dictionary "<< dict.globalName()<<endl;
return false;
}
return true;
}
pFlow::sphereShape::sphereShape
(
const word& fileName,
repository* owner,
const property& prop
)
:
shape(fileName, owner, prop)
{
if(!readFromDictionary3())
{
fatalExit;
fatalErrorInFunction;
}
}
pFlow::real pFlow::sphereShape::maxBoundingSphere() const
{
return max(diameters_);
}
pFlow::real pFlow::sphereShape::minBoundingSphere() const
{
return min(diameters_);
}
bool pFlow::sphereShape::boundingDiameter(uint32 index, real &bDiam) const
{
if( indexValid(index))
{
bDiam = diameters_[index];
return true;
}
return false;
}
pFlow::real pFlow::sphereShape::boundingDiameter(uint32 index) const
{
if(indexValid(index))
{
return diameters_[index];
}
fatalErrorInFunction<<"Invalid index for diameter "<<
index<<endl;
fatalExit;
return 0.0;
}
pFlow::realVector pFlow::sphereShape::boundingDiameter() const
{
return diameters_;
}
bool pFlow::sphereShape::mass(uint32 index, real &m) const
{
if( indexValid(index) )
{
real d = diameters_[index];
real rho = indexToDensity(index);
m = Pi/6.0*pow(d,3)*rho;
return true;
}
return false;
}
pFlow::real pFlow::sphereShape::mass(uint32 index) const
{
if(real m; mass(index, m))
{
return m;
}
fatalErrorInFunction<<"bad index for mass "<< index<<endl;
fatalExit;
return 0;
}
pFlow::realVector pFlow::sphereShape::mass() const
{
return realVector ("mass", Pi/6*pow(diameters_,(real)3.0)*density());
}
pFlow::realVector pFlow::sphereShape::density()const
{
auto pids = shapePropertyIds();
realVector rho("rho", numShapes());
ForAll(i, pids)
{
rho[i] = properties().density(pids[i]);
}
return rho;
}
bool pFlow::sphereShape::Inertia(uint32 index, real &I) const
{
if( indexValid(index) )
{
I = 0.4 * mass(index) * pow(diameters_[index]/2.0,2.0);
return true;
}
return false;
}
pFlow::real pFlow::sphereShape::Inertia(uint32 index) const
{
if(real I; Inertia(index, I))
{
return I;
}
fatalExit;
return 0;
}
pFlow::realVector pFlow::sphereShape::Inertia() const
{
return realVector("I", (real)0.4*mass()*pow((real)0.5*diameters_,(real)2.0));
}
bool pFlow::sphereShape::Inertia_xx(uint32 index, real &Ixx) const
{
return Inertia(index,Ixx);
}
pFlow::real pFlow::sphereShape::Inertial_xx(uint32 index) const
{
return Inertia(index);
}
bool pFlow::sphereShape::Inertia_yy(uint32 index, real &Iyy) const
{
return Inertia(index,Iyy);
}
pFlow::real pFlow::sphereShape::Inertial_yy(uint32 index) const
{
return Inertia(index);
}
bool pFlow::sphereShape::Inertia_zz(uint32 index, real &Izz) const
{
return Inertia(index,Izz);
}
pFlow::real pFlow::sphereShape::Inertial_zz(uint32 index) const
{
return Inertia(index);
}
pFlow::realVector
Vector< real > realVector
Definition: Vectors.hpp:46
pFlow::sphereShape::writeToDict
bool writeToDict(dictionary &dict) const override
Definition: sphereShape.cpp:39
pFlow::real
float real
Definition: builtinTypes.hpp:45
pFlow::sphereShape::Inertia_xx
bool Inertia_xx(uint32 index, real &Ixx) const override
Definition: sphereShape.cpp:172
fatalExit
#define fatalExit
Fatal exit.
Definition: error.hpp:98
pFlow::sphereShape::mass
realVector mass() const override
Definition: sphereShape.cpp:131
pFlow::sphereShape::maxBoundingSphere
real maxBoundingSphere() const override
Definition: sphereShape.cpp:71
pFlow::pow
Vector< T, Allocator > pow(const Vector< T, Allocator > &v1, const Vector< T, Allocator > &v2)
Definition: VectorMath.hpp:89
pFlow::uint32
unsigned int uint32
Definition: builtinTypes.hpp:56
pFlow::sphereShape::Inertial_yy
real Inertial_yy(uint32 index) const override
Definition: sphereShape.cpp:187
pFlow::word
std::string word
Definition: builtinTypes.hpp:64
pFlow::max
T max(const internalField< T, MemorySpace > &iField)
Definition: internalFieldAlgorithms.hpp:79
pFlow::dictionary::globalName
virtual word globalName() const
global name of entry, separated with dots
Definition: dictionary.cpp:356
pFlow::Vector::size
auto size() const
Size of the vector.
Definition: Vector.hpp:265
pFlow::dictionary::add
bool add(const word &keyword, const float &v)
add a float dataEntry
Definition: dictionary.cpp:435
pFlow::baseShapeNames::numShapes
size_t numShapes() const
Definition: baseShapeNames.hpp:93
pFlow::endl
iOstream & endl(iOstream &os)
Add newline and flush stream.
Definition: iOstream.hpp:341
pFlow::sphereShape::Inertial_zz
real Inertial_zz(uint32 index) const override
Definition: sphereShape.cpp:197
pFlow::sphereShape::Inertia_yy
bool Inertia_yy(uint32 index, real &Iyy) const override
Definition: sphereShape.cpp:182
pFlow::sphereShape::diameters_
realVector diameters_
Definition: sphereShape.hpp:36
pFlow::sphereShape::readFromDictionary3
bool readFromDictionary3()
Definition: sphereShape.cpp:24
pFlow::shape::writeToDict
bool writeToDict(dictionary &dict) const override
Definition: shape.cpp:65
pFlow::sphereShape::boundingDiameter
realVector boundingDiameter() const override
Definition: sphereShape.cpp:103
pFlow::sphereShape::minBoundingSphere
real minBoundingSphere() const override
Definition: sphereShape.cpp:76
sphereShape.hpp
fatalErrorInFunction
#define fatalErrorInFunction
Report a fatal error and function name and exit the application.
Definition: error.hpp:77
pFlow::shape
Definition: shape.hpp:30
pFlow::sphereShape::Inertia_zz
bool Inertia_zz(uint32 index, real &Izz) const override
Definition: sphereShape.cpp:192
pFlow::sphereShape::Inertia
realVector Inertia() const override
Definition: sphereShape.cpp:167
ForAll
#define ForAll(i, container)
Definition: pFlowMacros.hpp:75
pFlow::min
T min(const internalField< T, MemorySpace > &iField)
Definition: internalFieldAlgorithms.hpp:28
pFlow::sphereShape::sphereShape
sphereShape(const word &fileName, repository *owner, const property &prop)
Definition: sphereShape.cpp:55
pFlow::property
property holds the pure properties of materials.
Definition: property.hpp:37
pFlow::sphereShape::density
realVector density() const override
Definition: sphereShape.cpp:136
pFlow::Pi
const real Pi
Definition: numericConstants.hpp:30
pFlow::repository
Definition: repository.hpp:34
pFlow::Vector< real >
m
uint32 m
Definition: NBSLoop.hpp:22
pFlow::sphereShape::Inertial_xx
real Inertial_xx(uint32 index) const override
Definition: sphereShape.cpp:177
pFlow::dictionary
Dictionary holds a set of data entries or sub-dictionaries that are enclosed in a curely braces or ar...
Definition: dictionary.hpp:67