xfygogo
/
phasicFlow
mirror of https://github.com/PhasicFlow/phasicFlow.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Geometry folder is finalized

This commit is contained in:
Hamidreza Norouzi 2024-03-20 00:50:58 -07:00
parent df8bea213d
commit acfaacfe4a
7 changed files with 235 additions and 422 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

245
src/Geometry/geometry/geometry.cpp
View File

@ -34,8 +34,8 @@ bool pFlow::geometry::createPropertyId()
uint32Vector propId(
"propId",
surface().capacity(),
surface().size(),
capacity(),
size(),
RESERVE());
ForAll(i, materialName_)
@ -61,6 +61,11 @@ bool pFlow::geometry::createPropertyId()
}
void pFlow::geometry::zeroForce()
{
contactForceWall_.fill(zero3);
}
pFlow::geometry::geometry
(
systemControl& control,
@ -84,16 +89,6 @@ pFlow::geometry::geometry
control
),
wallProperty_(prop),
motionComponentName_
(
"motionComponentName",
"motionComponentName"
),
materialName_
(
"materialName",
"materialName"
),
propertyId_
(
objectFile
@ -197,16 +192,6 @@ pFlow::geometry::geometry
(
prop
),
motionComponentName_
(
"motionComponentName",
"motionComponentName"
),
materialName_
(
"materialName",
"materialName"
),
propertyId_
(
objectFile
@ -274,9 +259,47 @@ pFlow::geometry::geometry
}
}
bool pFlow::geometry::beforeIteration()
{
zeroForce();
return true;
}
bool pFlow::geometry::iterate()
{
return true;
}
bool pFlow::geometry::afterIteration()
{
auto numTris = size();
auto& normalsD = normals().deviceViewAll();
auto& areaD = area().deviceViewAll();
auto& cForceD = contactForceWall_.deviceViewAll();
auto& sStressD = shearStressWall_.deviceViewAll();
auto& nStressD = normalStressWall_.deviceViewAll();
Kokkos::parallel_for(
"pFlow::geometry::afterIteration",
deviceRPolicyStatic(0, numTris),
LAMBDA_HD(uint32 i)
{
realx3 n = normalsD[i];
real A = max(areaD[i],smallValue);
realx3 nF = dot(cForceD[i],n)*n;
realx3 sF = cForceD[i] - nF;
nStressD[i] = nF/A;
sStressD[i] = sF/A;
});
Kokkos::fence();
return true;
}
bool pFlow::geometry::read(iIstream &is, const IOPattern &iop)
{
motionComponentName_.read(is, iop);
materialName_.read(is, iop);
if( readWholeObject_ )
@ -305,6 +328,93 @@ bool pFlow::geometry::write(iOstream &os, const IOPattern &iop) const
return multiTriSurface::write(os,iop);
}
pFlow::uniquePtr<pFlow::geometry>
pFlow::geometry::create
(
systemControl& control,
const property& prop
)
{
//
fileDictionary dict( motionModelFile__, control.time().geometry().path());
word model = dict.getVal<word>("motionModel");
auto geomModel = angleBracketsNames("geometry", model);
REPORT(1)<< "Selecting geometry model . . ."<<END_REPORT;
if( systemControlvCtorSelector_.search(geomModel) )
{
auto objPtr = systemControlvCtorSelector_[geomModel] (control, prop);
REPORT(2)<<"Model "<< Green_Text(geomModel)<<" is created.\n"<<END_REPORT;
return objPtr;
}
else
{
printKeys
(
fatalError << "Ctor Selector "<< Yellow_Text(geomModel) << " dose not exist. \n"
<<"Avaiable ones are: \n\n"
,
systemControlvCtorSelector_
);
fatalExit;
}
return nullptr;
}
pFlow::uniquePtr<pFlow::geometry>
pFlow::geometry::create
(
systemControl& control,
const property& prop,
multiTriSurface& surf,
const wordVector& motionCompName,
const wordVector& materialName,
const dictionary& motionDic
)
{
word model = motionDic.getVal<word>("motionModel");
auto geomModel = angleBracketsNames("geometry", model);
REPORT(1)<< "Selecting geometry model . . ."<<END_REPORT;
if( dictionaryvCtorSelector_.search(geomModel) )
{
auto objPtr = dictionaryvCtorSelector_[geomModel]
(
control,
prop,
surf,
motionCompName,
materialName,
motionDic
);
REPORT(2)<<"Model "<< Green_Text(geomModel)<<" is created.\n"<<END_REPORT;
return objPtr;
}
else
{
printKeys
(
fatalError << "Ctor Selector "<< Yellow_Text(geomModel) << " dose not exist. \n"
<<"Avaiable ones are: \n\n"
,
dictionaryvCtorSelector_
);
fatalExit;
}
return nullptr;
}
/*pFlow::geometry::geometry
(
systemControl& control,
@ -400,52 +510,7 @@ pFlow::geometry::geometry
{}
pFlow::uniquePtr<pFlow::geometry>
pFlow::geometry::create
(
systemControl& control,
const property& prop
)
{
//motionModelFile__
auto motionDictPtr = IOobject::make<dictionary>
(
objectFile
(
motionModelFile__,
control.geometry().path(),
objectFile::READ_ALWAYS,
objectFile::WRITE_NEVER
),
motionModelFile__,
true
);
word model = motionDictPtr().getObject<dictionary>().getVal<word>("motionModel");
auto geomModel = angleBracketsNames("geometry", model);
REPORT(1)<< "Selecting geometry model . . ."<<endREPORT;
if( systemControlvCtorSelector_.search(geomModel) )
{
auto objPtr = systemControlvCtorSelector_[geomModel] (control, prop);
REPORT(2)<<"Model "<< greenText(geomModel)<<" is created.\n"<<endREPORT;
return objPtr;
}
else
{
printKeys
(
fatalError << "Ctor Selector "<< yellowText(geomModel) << " dose not exist. \n"
<<"Avaiable ones are: \n\n"
,
systemControlvCtorSelector_
);
fatalExit;
}
return nullptr;
}
bool pFlow::geometry::beforeIteration()
{
@ -473,49 +538,3 @@ bool pFlow::geometry::afterIteration()
return true;
}*/
pFlow::uniquePtr<pFlow::geometry>
pFlow::geometry::create
(
systemControl& control,
const property& prop,
multiTriSurface& surf,
const wordVector& motionCompName,
const wordVector& materialName,
const dictionary& motionDic
)
{
word model = motionDic.getVal<word>("motionModel");
auto geomModel = angleBracketsNames("geometry", model);
REPORT(1)<< "Selecting geometry model . . ."<<END_REPORT;
if( dictionaryvCtorSelector_.search(geomModel) )
{
auto objPtr = dictionaryvCtorSelector_[geomModel]
(
control,
prop,
surf,
motionCompName,
materialName,
motionDic
);
REPORT(2)<<"Model "<< Green_Text(geomModel)<<" is created.\n"<<END_REPORT;
return objPtr;
}
else
{
printKeys
(
fatalError << "Ctor Selector "<< Yellow_Text(geomModel) << " dose not exist. \n"
<<"Avaiable ones are: \n\n"
,
dictionaryvCtorSelector_
);
fatalExit;
}
return nullptr;
}

143
src/Geometry/geometry/geometry.hpp
View File

@ -54,10 +54,14 @@ private:
const property& wallProperty_;
/// The name of motion component of each wall surface
wordField_H motionComponentName_;
wordField_H motionComponentName_{
"motionComponentName",
"motionComponentName"};
/// Material name of each wall surface
wordField_H materialName_;
wordField_H materialName_{
"materialName",
"materialName"};
/// Property id of each triangle in the set of wall surfaces
uint32TriSurfaceField_D propertyId_;
@ -81,11 +85,7 @@ private:
bool createPropertyId();
/// Initialize contact force to zero
/*void zeroForce()
{
contactForceWall_.fill(zero3);
}*/
void zeroForce();
public:
@ -122,10 +122,10 @@ public:
const wordVector& propName);*/
/// Destructor
virtual ~geometry() = default;
~geometry()override = default;
/// Virtual constructor
/*create_vCtor
create_vCtor
(
geometry,
systemControl,
@ -134,7 +134,7 @@ public:
const property& prop
),
(control, prop)
);*/
);
/// Virtual constructor
create_vCtor
@ -152,48 +152,6 @@ public:
);
//- Methods
/// Number of triangles in the set of surface walls
inline
auto numTriangles()const
{
return size();
}
/// Access to the points
/*inline
const auto& points()const
{
return triSurface_.points();
}*/
/// Access to the vertices
/*inline
const auto& vertices()const
{
return triSurface_.vertices();
}*/
/// Obtain an object for accessing triangles
/*inline auto getTriangleAccessor()const
{
return triSurface_.getTriangleAccessor();
}*/
/// Surface
inline
auto& surface()
{
return static_cast<multiTriSurface&>(*this);
}
/// Surface
inline
const auto& surface()const
{
return static_cast<const multiTriSurface&>(*this);
}
inline
const auto& motionComponentName()const
{
@ -201,90 +159,53 @@ public:
}
/// Access to contact force
/*inline
realx3TriSurfaceField_D& contactForceWall()
inline
auto& contactForceWall()
{
return contactForceWall_;
}
/// Access to contact force
inline
const realx3TriSurfaceField_D& contactForceWall() const
const auto& contactForceWall() const
{
return contactForceWall_;
}
/// Property ide of triangles
inline
const auto& propertyId()const
{
return propertyId_;
}
/// Access to property
inline const auto& wallProperty()const
{
return wallProperty_;
}*/
/// Owner repository
/*inline
const repository& owner()const
{
return geometryRepository_;
}*/
/// Owner repository
/*inline
repository& owner()
{
return geometryRepository_;
}*/
/// Path to the repository folder
/*inline auto path()
{
return owner().path();
}*/
}
/// The name of motion model
/*virtual
word motionModelTypeName()const = 0;*/
virtual
word motionModelTypeName()const = 0;
/// Motion model index of triangles
/*virtual
const int8Vector_HD& triMotionIndex() const =0;
virtual
const uint32Field_D& triMotionIndex() const =0;
/// Motion model index of points
virtual
const int8Vector_HD& pointMotionIndex()const = 0;
/// Property ide of triangles
const int8TriSurfaceField_D& propertyId() const
{
return propertyId_;
}*/
/// Operations before each iteration
//bool beforeIteration() override;
/// Operations after each iteration
//bool afterIteration() override;
const uint32Field_D& pointMotionIndex()const = 0;
bool beforeIteration() override
{
notImplementedFunction;
return true;
}
bool beforeIteration() override;
/// This is called in time loop. Perform the main calculations
/// when the component should evolve along time.
bool iterate() override
{
notImplementedFunction;
return true;
}
bool iterate() override;
/// This is called in time loop, after iterate.
bool afterIteration() override
{
notImplementedFunction;
return true;
}
bool afterIteration() override;
//- IO
@ -297,8 +218,10 @@ public:
//- Static members
/*static
uniquePtr<geometry> create(systemControl& control, const property& prop);*/
static
uniquePtr<geometry> create(
systemControl& control,
const property& prop);
static
uniquePtr<geometry> create(

159
src/Geometry/geometryMotion/geometryMotion.cpp
View File

@ -45,17 +45,18 @@ bool pFlow::geometryMotion<MotionModel>::findMotionIndex()
fatalErrorInFunction<<
mName<< " does not exist in the list of motion names -> "<<
motionModel_.componentNames();
return false;
}
surfMotionIndex.push_back(mInd);
auto surfRange = this->surface().subSurfaceRange(surfI);
auto surfRange = subSurfaceRange(surfI);
for(uint32 i=0; i<surfRange.numElements(); i++)
{
triMotionIndex.push_back(mInd);
}
auto pointRange = this->surface().subSurfacePointRange(surfI);
auto pointRange = subSurfacePointRange(surfI);
for(uint32 n=0; n<pointRange.numElements(); n++)
{
pointMotionIndex.push_back(mInd);
@ -70,6 +71,39 @@ bool pFlow::geometryMotion<MotionModel>::findMotionIndex()
}
template<typename MotionModel>
bool pFlow::geometryMotion<MotionModel>::moveGeometry()
{
uint32 iter = this->currentIter();
real t = this->currentTime();
real dt = this->dt();
auto mModel = motionModel_.getModelInterface(iter, t, dt);
auto& pointMIndexD= pointMotionIndex_.deviceViewAll();
auto& pointsD = points().deviceViewAll();
Kokkos::parallel_for(
"geometryMotion<MotionModel>::movePoints",
deviceRPolicyStatic(0, numPoints()),
LAMBDA_HD(uint32 i){
auto newPos = mModel.transferPoint(pointMIndexD[i], pointsD[i], dt);
pointsD[i] = newPos;
});
Kokkos::fence();
// move the motion components
motionModel_.move(iter, t,dt);
// end of calculations
return true;
}
template<typename MotionModel>
pFlow::geometryMotion<MotionModel>::geometryMotion
(
@ -137,129 +171,16 @@ pFlow::geometryMotion<MotionModelType>::geometryMotion
}
}
/*template<typename MotionModel>
pFlow::geometryMotion<MotionModel>::geometryMotion
(
systemControl& control,
const property& prop,
const multiTriSurface& triSurface,
const wordVector& motionCompName,
const wordVector& propName,
const MotionModel& motionModel
)
:
geometry(
control,
prop,
triSurface,
motionCompName,
propName
),
motionModel_(
this->owner().template emplaceObject<MotionModel>(
objectFile(
motionModelFile__,
"",
objectFile::READ_NEVER,
objectFile::WRITE_ALWAYS
),
motionModel
)
),
moveGeomTimer_("move geometry", &this->timers())
{
findMotionIndex();
}
template<typename MotionModel>
pFlow::geometryMotion<MotionModel>::geometryMotion
(
systemControl& control,
const property& prop,
const dictionary& dict,
const multiTriSurface& triSurface,
const wordVector& motionCompName,
const wordVector& propName
)
:
geometry(
control,
prop,
dict,
triSurface,
motionCompName,
propName
),
motionModel_(
this->owner().template emplaceObject<MotionModel>(
objectFile(
motionModelFile__,
"",
objectFile::READ_NEVER,
objectFile::WRITE_ALWAYS
),
dict
)
),
moveGeomTimer_("move geometry", &this->timers())
{
findMotionIndex();
}
template<typename MotionModel>
bool pFlow::geometryMotion<MotionModel>::beforeIteration()
{
geometry::beforeIteration();
return true;
}
template<typename MotionModel>
bool pFlow::geometryMotion<MotionModel>::iterate()
{
if( motionModel_.isMoving() )
{
moveGeomTimer_.start();
moveGeometry();
moveGeomTimer_.end();
moveGeomTimer_.start();
moveGeometry();
this->calculateNormals();
moveGeomTimer_.end();
}
return true;
}
template<typename MotionModel>
bool pFlow::geometryMotion<MotionModel>::afterIteration()
{
geometry::afterIteration();
return true;
}
template<typename MotionModel>
bool pFlow::geometryMotion<MotionModel>::moveGeometry()
{
real dt = this->dt();
real t = this->currentTime();
auto pointMIndex= pointMotionIndex_.deviceVector();
auto mModel = motionModel_.getModel(t);
realx3* points = triSurface_.pointsData_D();
auto numPoints = triSurface_.numPoints();
Kokkos::parallel_for(
"geometryMotion<MotionModel>::movePoints",
numPoints,
LAMBDA_HD(int32 i){
auto newPos = mModel.transferPoint(pointMIndex[i], points[i], dt);
points[i] = newPos;
});
Kokkos::fence();
// move the motion components
motionModel_.move(t,dt);
// end of calculations
moveGeomTimer_.end();
return true;
}*/

53
src/Geometry/geometryMotion/geometryMotion.hpp
View File

@ -38,6 +38,8 @@ class geometryMotion
{
public:
using MotionModel = MotionModelType;
using ModelComponent = typename MotionModelType::ModelComponent;
private:
@ -60,6 +62,9 @@ private:
/// determine the motion index of each triangle
bool findMotionIndex();
/// Move geometry
bool moveGeometry();
public:
/// Type info
@ -77,31 +82,13 @@ public:
const wordVector& materialName,
const dictionary& motionDict);
/*geometryMotion(
systemControl& control,
const property& prop,
const multiTriSurface& triSurface,
const wordVector& motionCompName,
const wordVector& propName,
const MotionModel& motionModel);*/
/// Construct from components and dictionary that contains
/// motionModel
/*geometryMotion(systemControl& control,
const property& prop,
const dictionary& dict,
const multiTriSurface& triSurface,
const wordVector& motionCompName,
const wordVector& propName);*/
/// Add virtual constructor
/*add_vCtor
add_vCtor
(
geometry,
geometryMotion,
systemControl
);*/
);
/// Add virtual constructor
add_vCtor
@ -114,40 +101,33 @@ public:
// - Methods
/// Obtain motion model at time t
/*auto getModel(real t)const
auto getModel(uint32 iter, real t, real dt)const
{
return motionModel_.getModel(t);
}*/
return motionModel_.getModelInterface(iter, t, dt);
}
/// TypeName / TypeInfo of motion model
/*word motionModelTypeName()const override
word motionModelTypeName()const override
{
return motionModel_.typeName();
}*/
}
/// Access to motion model index of triangles
/*const auto& triMotionIndex()const override
const uint32Field_D& triMotionIndex()const override
{
return triMotionIndex_;
}
/// Access to motion model index of points
const int8Vector_HD& pointMotionIndex()const override
const uint32Field_D& pointMotionIndex()const override
{
return pointMotionIndex_;
}*/
/// Operations before each iteration
/*bool beforeIteration() override;
}
/// Iterate geometry one time step
bool iterate() override ;
/// Operations after each iteration
bool afterIteration() override;*/
/// Move geometry
//bool moveGeometry();
};
@ -155,9 +135,6 @@ public:
#include "geometryMotion.cpp"
#ifndef BUILD_SHARED_LIBS
#include "geometryMotionsInstantiate.cpp"
#endif
#endif //__geometryMotion_hpp__

12
src/Geometry/geometryMotion/geometryMotions.cpp
View File

@ -17,9 +17,13 @@ Licence:
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-----------------------------------------------------------------------------*/
#include "geometryMotions.hpp"
#ifdef BUILD_SHARED_LIBS
#include "geometryMotionsInstantiate.cpp"
#endif
template class pFlow::geometryMotion<pFlow::vibratingMotion>;
template class pFlow::geometryMotion<pFlow::rotatingAxisMotion>;
template class pFlow::geometryMotion<pFlow::stationaryWall>;
//template class pFlow::geometryMotion<pFlow::multiRotatingAxisMotion>;

3
src/Geometry/geometryMotion/geometryMotions.hpp
View File

@ -35,9 +35,10 @@ using vibratingMotionGeometry = geometryMotion<vibratingMotion>;
using rotationAxisMotionGeometry = geometryMotion<rotatingAxisMotion>;
using stationaryGeometry = geometryMotion<stationaryWall>;
//typedef geometryMotion<multiRotatingAxisMotion> multiRotationAxisMotionGeometry;
typedef geometryMotion<stationaryWall> stationaryGeometry;

32
src/Geometry/geometryMotion/geometryMotionsInstantiate.cpp
View File

@ -1,32 +0,0 @@
/*------------------------------- 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 "stationaryWall.hpp"
#include "rotatingAxisMotion.hpp"
//#include "multiRotatingAxisMotion.hpp"
#include "vibratingMotion.hpp"
template class pFlow::geometryMotion<pFlow::stationaryWall>;
template class pFlow::geometryMotion<pFlow::rotatingAxisMotion>;
//template class pFlow::geometryMotion<pFlow::multiRotatingAxisMotion>;
template class pFlow::geometryMotion<pFlow::vibratingMotion>;