xfygogo/phasicFlow
1
0
Fork 0
mirror of https://github.com/PhasicFlow/phasicFlow.git synced 2025-08-17 03:47:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

adapt the multiRotatingAxisMotion to v-1.0

Browse Source
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
Download Patch File Download Diff File Expand all files Collapse all files

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;
}