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

adapt the multiRotatingAxisMotion to v-1.0

This commit is contained in:
wanqing0421 2025-03-16 00:36:38 +08:00
parent 5eef26a6ed
commit 797334af87
7 changed files with 138 additions and 393 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -28,4 +28,4 @@ template class pFlow::geometryMotion<pFlow::stationaryWall>;
template class pFlow::geometryMotion<pFlow::conveyorBeltMotion>;
//template class pFlow::geometryMotion<pFlow::multiRotatingAxisMotion>;
template class pFlow::geometryMotion<pFlow::multiRotatingAxisMotion>;

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

@ -25,7 +25,7 @@ Licence:
#include "stationaryWall.hpp"
#include "rotatingAxisMotion.hpp"
#include "conveyorBeltMotion.hpp"
//#include "multiRotatingAxisMotion.hpp"
#include "multiRotatingAxisMotion.hpp"
#include "vibratingMotion.hpp"
@ -40,10 +40,7 @@ using stationaryGeometry = geometryMotion<stationaryWall>;
using conveyorBeltMotionGeometry = geometryMotion<conveyorBeltMotion>;
//typedef geometryMotion<multiRotatingAxisMotion> multiRotationAxisMotionGeometry;
using multiRotationAxisMotionGeometry = geometryMotion<multiRotatingAxisMotion>;
}

4
src/MotionModel/CMakeLists.txt
View File

@ -14,8 +14,8 @@ entities/stationary/stationary.cpp
conveyorBeltMotion/conveyorBeltMotion.cpp
entities/conveyorBelt/conveyorBelt.cpp
#entities/multiRotatingAxis/multiRotatingAxis.cpp
#multiRotatingAxisMotion/multiRotatingAxisMotion.cpp
entities/multiRotatingAxis/multiRotatingAxis.cpp
multiRotatingAxisMotion/multiRotatingAxisMotion.cpp
)

39
src/MotionModel/entities/multiRotatingAxis/multiRotatingAxis.cpp
View File

@ -22,6 +22,18 @@ Licence:
#include "multiRotatingAxisMotion.hpp"
#include "dictionary.hpp"
/// Construct from dictionary
FUNCTION_H
pFlow::multiRotatingAxis::multiRotatingAxis(const dictionary& dict)
{
if(!read(nullptr, dict))
{
fatalErrorInFunction<<
" error in reading multiRotatingAxis from dictionary "<< dict.globalName()<<endl;
fatalExit;
}
}
FUNCTION_H
pFlow::multiRotatingAxis::multiRotatingAxis
(
@ -69,7 +81,7 @@ bool pFlow::multiRotatingAxis::read
}
else
{
parentAxisIndex_ = axisMotion-> nameToIndex(rotAxis);
bool result = axisMotion-> nameToIndex(rotAxis, parentAxisIndex_);
}
return true;
@ -90,10 +102,33 @@ bool pFlow::multiRotatingAxis::write
}
else
{
auto rotAxis = axisMotion->indexToName(parentAxisIndex_);
word rotAxis;
bool result = axisMotion->indexToName(parentAxisIndex_, rotAxis);
dict.add("rotationAxis", rotAxis);
}
return true;
}
FUNCTION_H
bool pFlow::multiRotatingAxis::write
(
dictionary& dict
) const
{
if( !rotatingAxis::write(dict) ) return false;
if(parentAxisIndex_ == 0)
{
dict.add("rotationAxis", "none");
}
// else
// {
// word rotAxis;
// bool result = axisMotion->indexToName(parentAxisIndex_, rotAxis);
// dict.add("rotationAxis", rotAxis);
// }
return true;
}

16
src/MotionModel/entities/multiRotatingAxis/multiRotatingAxis.hpp
View File

@ -82,16 +82,22 @@ protected:
multiRotatingAxis* axisList_;
/// Index of parent axis
int32 parentAxisIndex_ = -1;
uint32 parentAxisIndex_ = static_cast<uint32>(-1);
public:
TypeInfoNV("multiRotatingAxis");
// - Constructors
/// Empty Constructor
INLINE_FUNCTION_HD
multiRotatingAxis(){}
/// Construct from dictionary
FUNCTION_H
explicit multiRotatingAxis(const dictionary& dict);
/// Empty with list of axes
FUNCTION_H
multiRotatingAxis(multiRotatingAxisMotion* axisMotion);
@ -123,11 +129,11 @@ public:
while(parIndex != -1)
{
auto& ax = axisList_[parIndex];
parentVel += ax.linTangentialVelocityPoint(p);
parentVel += ax.linVelocityPoint(p);
parIndex = ax.parentAxisIndex();
}
return parentVel + rotatingAxis::linTangentialVelocityPoint(p);
return parentVel + rotatingAxis::linVelocityPoint(p);
}
/// Translate point p for dt seconds based on the axis information
@ -207,6 +213,10 @@ public:
FUNCTION_H
bool write(const multiRotatingAxisMotion* axisMotion, dictionary& dict) const;
/// Write to dictionary
FUNCTION_H
bool write(dictionary& dict) const;
};

240
src/MotionModel/multiRotatingAxisMotion/multiRotatingAxisMotion.cpp
View File

@ -19,220 +19,70 @@ Licence:
-----------------------------------------------------------------------------*/
#include "multiRotatingAxisMotion.hpp"
#include "dictionary.hpp"
#include "vocabs.hpp"
bool pFlow::multiRotatingAxisMotion::readDictionary
void pFlow::multiRotatingAxisMotion::impl_setTime
(
const dictionary& dict
)
{
auto motionModel = dict.getVal<word>("motionModel");
if(motionModel != "multiRotatingAxisMotion")
{
fatalErrorInFunction<<
" motionModel should be multiRotatingAxisMotion, but found "
<< motionModel <<endl;
return false;
}
auto& motionInfo = dict.subDict("multiRotatingAxisMotionInfo");
auto axisNames = motionInfo.dictionaryKeywords();
wordList rotationAxis;
// first check if
for(auto& aName: axisNames)
{
auto& axDict = motionInfo.subDict(aName);
if(auto axPtr = makeUnique<rotatingAxis>(axDict); axPtr)
{
rotationAxis.push_back(
axDict.getValOrSet<word>("rotationAxis", "none"));
}
else
{
fatalErrorInFunction<<
"could not read rotating axis from "<< axDict.globalName()<<endl;
return false;
}
}
if( !axisNames.search("none") )
{
axisNames.push_back("none");
rotationAxis.push_back("none");
}
using intPair = std::pair<int32, int32>;
std::vector<intPair> numRotAxis;
for(size_t i=0; i< axisNames.size(); i++)
{
word rotAxis = rotationAxis[i];
int32 n=0;
while(rotAxis != "none")
{
n++;
if(int32 iAxis = axisNames.findi(rotAxis) ; iAxis != -1)
{
rotAxis = rotationAxis[iAxis];
}else
{
fatalErrorInFunction<<
"rotation axis name "<< rotAxis << "is does not exist!"<<endl;
return false;
}
}
numRotAxis.push_back({n,i});
}
auto compareFunc = [](const intPair& a, const intPair& b)
{ return a.first > b.first; };
algorithms::STD::sort(numRotAxis.data(), numRotAxis.size(), compareFunc);
sortedIndex_.clear();
axisName_.clear();
for(auto ax:numRotAxis)
{
axisName_.push_back(axisNames[ax.second]);
sortedIndex_.push_back(ax.second);
}
numAxis_ = axisName_.size();
axis_.clear();
axis_.reserve(numAxis_);
// create the actual axis vector
for(auto& aName: axisName_)
{
if(aName != "none")
{
auto& axDict = motionInfo.subDict(aName);
axis_.push_back(
multiRotatingAxis(this, axDict));
}
else
{
axis_.push_back(
multiRotatingAxis(this));
}
}
return true;
}
bool pFlow::multiRotatingAxisMotion::writeDictionary
(
dictionary& dict
uint32 iter,
real t,
real dt
)const
{
dict.add("motionModel", "multiRotatingAxisMotion");
auto& motionInfo = dict.subDictOrCreate("multiRotatingAxisMotionInfo");
ForAll(i, axis_)
{
auto& axDict = motionInfo.subDictOrCreate(axisName_[i]);
if( !axis_.hostVectorAll()[i].write(this,axDict))
{
fatalErrorInFunction<<
" error in writing axis "<< axisName_[i] << " to dicrionary "
<< motionInfo.globalName()<<endl;
return false;
}
}
return true;
auto motion = motionComponents_.deviceViewAll();
Kokkos::parallel_for(
"multiRotatingAxisMotion::impl_setTime",
deviceRPolicyStatic(0, numComponents_),
LAMBDA_HD(uint32 i){
motion[i].setTime(t);
});
Kokkos::fence();
}
pFlow::multiRotatingAxisMotion::multiRotatingAxisMotion()
{}
pFlow::multiRotatingAxisMotion::multiRotatingAxisMotion(
const objectFile &objf,
repository *owner)
: fileDictionary(objf, owner)
{
// if(! impl_readDictionary(*this) )
// {
// fatalErrorInFunction;
// fatalExit;
// }
}
pFlow::multiRotatingAxisMotion::multiRotatingAxisMotion
(
const dictionary& dict
const objectFile &objf,
const dictionary &dict,
repository *owner
)
:
fileDictionary(objf, dict, owner)
{
if(! readDictionary(dict) )
if(!impl_readDictionary(*this) )
{
fatalErrorInFunction;
fatalExit;
}
}
FUNCTION_H
bool pFlow::multiRotatingAxisMotion::move(real t, real dt)
{
// every thing is done on host
for(int32 i=0; i<numAxis_; i++)
{
auto& ax = axis_[sortedIndex_[i]];
ax.setTime(t);
ax.setAxisList(getAxisListPtrHost());
ax.move(dt);
}
// transfer to device
axis_.modifyOnHost();
axis_.syncViews();
return true;
}
bool pFlow::multiRotatingAxisMotion::read
(
iIstream& is
)
{
// create an empty file dictionary
dictionary motionInfo(motionModelFile__, true);
// read dictionary from stream
if( !motionInfo.read(is) )
{
ioErrorInFile(is.name(), is.lineNumber()) <<
" error in reading dictionray " << motionModelFile__ <<" from file. \n";
return false;
}
if( !readDictionary(motionInfo) ) return false;
return true;
}
bool pFlow::multiRotatingAxisMotion::write
(
iOstream& os
)const
iOstream &os,
const IOPattern &iop
) const
{
// create an empty file dictionary
dictionary motionInfo(motionModelFile__, true);
if( !writeDictionary(motionInfo))
// a global dictionary
dictionary newDict(fileDictionary::dictionary::name(), true);
if( iop.thisProcWriteData() )
{
return false;
if( !this->impl_writeDictionary(newDict) ||
!newDict.write(os))
{
fatalErrorInFunction<<
" error in writing to dictionary "<< newDict.globalName()<<endl;
return false;
}
}
if( !motionInfo.write(os) )
{
ioErrorInFile( os.name(), os.lineNumber() )<<
" error in writing dictionray to file. \n";
return false;
}
return true;
return true;
}

223
src/MotionModel/multiRotatingAxisMotion/multiRotatingAxisMotion.hpp
View File

@ -22,18 +22,22 @@ Licence:
#define __multiRotatingAxisMotion_hpp__
#include "types.hpp"
#include "typeInfo.hpp"
#include "VectorDual.hpp"
#include "List.hpp"
// #include "types.hpp"
// #include "typeInfo.hpp"
// #include "VectorSingle.hpp"
// #include "List.hpp"
// #include "multiRotatingAxis.hpp"
#include "MotionModel.hpp"
#include "multiRotatingAxis.hpp"
#include "fileDictionary.hpp"
namespace pFlow
{
// forward
class dictionary;
// class dictionary;
/**
* Rotating axis motion model for walls
@ -63,200 +67,49 @@ multiRotatingAxisMotionInfo
*
*/
class multiRotatingAxisMotion
:
public fileDictionary,
public MotionModel<multiRotatingAxisMotion, multiRotatingAxis>
{
public:
/** Motion model class to be passed to computational units/kernels for
* transfing points and returning velocities at various positions
*/
class Model
{
protected:
deviceViewType1D<multiRotatingAxis> axis_;
int32 numAxis_=0;
public:
INLINE_FUNCTION_HD
Model(deviceViewType1D<multiRotatingAxis> axis, int32 numAxis):
axis_(axis),
numAxis_(numAxis)
{}
INLINE_FUNCTION_HD
Model(const Model&) = default;
INLINE_FUNCTION_HD
Model& operator=(const Model&) = default;
INLINE_FUNCTION_HD
realx3 pointVelocity(int32 n, const realx3& p)const
{
return axis_[n].pointTangentialVel(p);
}
INLINE_FUNCTION_HD
realx3 operator()(int32 n, const realx3& p)const
{
return pointVelocity(n,p);
}
INLINE_FUNCTION_HD
realx3 transferPoint(int32 n, const realx3 p, real dt)const
{
return axis_[n].transferPoint(p, dt);
}
INLINE_FUNCTION_HD int32 numComponents()const
{
return numAxis_;
}
};
protected:
using axisVector_HD = VectorDual<multiRotatingAxis>;
friend MotionModel<multiRotatingAxisMotion, multiRotatingAxis>;
/// Vector of multiRotaingAxis axes
axisVector_HD axis_;
/// Sorted index based on number of parrents each axis ha
VectorDual<int32> sortedIndex_;
/// is the geometry attached to this component moving
bool impl_isMoving()const
{
return true;
}
/// List of axes names
wordList axisName_;
/// Number of axes
label numAxis_= 0;
/// Read from a dictionary
bool readDictionary(const dictionary& dict);
/// Write to a dictionary
bool writeDictionary(dictionary& dict)const;
/// move the component itself
bool impl_move(uint32, real, real)const
{
return true;
}
public:
/// Type info
TypeInfoNV("multiRotatingAxisMotion");
TypeInfo("multiRotatingAxisMotion");
// - Constructor
multiRotatingAxisMotion(const objectFile& objf, repository* owner);
/// Empty constructor
FUNCTION_H
multiRotatingAxisMotion();
multiRotatingAxisMotion(
const objectFile& objf,
const dictionary& dict,
repository* owner);
/// Construct with dictionary
FUNCTION_H
multiRotatingAxisMotion(const dictionary& dict);
using fileDictionary::write;
/// Copy constructor
FUNCTION_H
multiRotatingAxisMotion(const multiRotatingAxisMotion&) = default;
bool write(iOstream& os, const IOPattern& iop)const override;
/// No Move
multiRotatingAxisMotion(multiRotatingAxisMotion&&) = delete;
static
auto noneComponent()
{
return multiRotatingAxis{};
}
/// Copy assignment
FUNCTION_H
multiRotatingAxisMotion& operator=(const multiRotatingAxisMotion&) = default;
/// No move assignment
multiRotatingAxisMotion& operator=(multiRotatingAxisMotion&&) = delete;
/// Destructor
FUNCTION_H
~multiRotatingAxisMotion() = default;
// - Methods
/// Retrun motion model at time t
Model getModel(real t)
{
for(int32 i= 0; i<numAxis_; i++ )
{
axis_[i].setTime(t);
axis_[i].setAxisList(getAxisListPtrDevice());
}
axis_.modifyOnHost();
axis_.syncViews();
return Model(axis_.deviceVector(), numAxis_);
}
/// Pointer to axis list on host side
INLINE_FUNCTION_H
multiRotatingAxis* getAxisListPtrHost()
{
return axis_.hostVectorAll().data();
}
/// Pointer to axis list on device
INLINE_FUNCTION_H
multiRotatingAxis* getAxisListPtrDevice()
{
return axis_.deviceVectorAll().data();
}
/// Name of motion component to index
INLINE_FUNCTION_H
int32 nameToIndex(const word& name)const
{
if( auto i = axisName_.findi(name); i == -1)
{
fatalErrorInFunction<<
"axis name " << name << " does not exist. \n";
fatalExit;
return i;
}
else
{
return i;
}
}
/// Index of motion component to component name
INLINE_FUNCTION_H
word indexToName(label i)const
{
if(i < numAxis_ )
return axisName_[i];
else
{
fatalErrorInFunction<<
"out of range access to the list of axes " << i <<endl<<
" size of axes_ is "<<numAxis_<<endl;
fatalExit;
return "";
}
}
/// Is moving
INLINE_FUNCTION_HD
bool isMoving()const
{
return true;
}
/// Move points
FUNCTION_H
bool move(real t, real dt);
// - IO operation
/// Read from input stream is
FUNCTION_H
bool read(iIstream& is);
/// Write to output stream os
FUNCTION_H
bool write(iOstream& os)const;
// TODO: make this method protected
void impl_setTime(uint32 iter, real t, real dt)const;
};
} // pFlow