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

Multirotating axis motion for version 1.0

This commit is contained in:
Hamidreza 2025-03-19 18:10:50 +03:30
parent be7b2eb632
commit 340f3a551a
5 changed files with 212 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Interaction/sphereInteraction/sphereInteractionsNonLinearModModels.cpp
View File

@ -58,5 +58,5 @@ createInteraction(pFlow::cfModels::limitedNonLinearModNormalRolling, pFlow::conv
createInteraction(pFlow::cfModels::nonLimitedNonLinearModNormalRolling,pFlow::conveyorBeltMotionGeometry);
// multiRotationAxisMotionGeometry
//createInteraction(pFlow::cfModels::limitedNonLinearModNormalRolling, pFlow::multiRotationAxisMotionGeometry);
//createInteraction(pFlow::cfModels::nonLimitedNonLinearModNormalRolling,pFlow::multiRotationAxisMotionGeometry);
createInteraction(pFlow::cfModels::limitedNonLinearModNormalRolling, pFlow::multiRotationAxisMotionGeometry);
createInteraction(pFlow::cfModels::nonLimitedNonLinearModNormalRolling,pFlow::multiRotationAxisMotionGeometry);

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

@ -25,40 +25,29 @@ Licence:
/// 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;
}
}
:
rotatingAxis(dict)
{}
FUNCTION_H
pFlow::multiRotatingAxis::multiRotatingAxis
(
multiRotatingAxisMotion* axisMotion
)
{
//axisList_ = axisMotion->getAxisListPtr();
}
FUNCTION_H
pFlow::multiRotatingAxis::multiRotatingAxis
(
multiRotatingAxisMotion* axisMotion,
multiRotatingAxis* axisListPtr,
const wordList& componentsNames,
const dictionary& dict
)
:
rotatingAxis(dict),
axisList_(axisListPtr)
{
if(!read(axisMotion, dict))
if(!read(dict, componentsNames))
{
fatalErrorInFunction<<
" error in reading rotatingAxis from dictionary "<< dict.globalName()<<endl;
fatalExit;
}
//axisList_ = axisMotion->getAxisListPtr();
}
@ -66,22 +55,29 @@ pFlow::multiRotatingAxis::multiRotatingAxis
FUNCTION_H
bool pFlow::multiRotatingAxis::read
(
multiRotatingAxisMotion* axisMotion,
const dictionary& dict
const dictionary& dict,
const wordList& componentNames
)
{
if(!rotatingAxis::read(dict))return false;
word rotAxis = dict.getValOrSet<word>("rotationAxis", "none");
if(rotAxis == "none")
{
parentAxisIndex_ = -1;
parentAxisIndex_ = static_cast<uint32>(-1);
}
else
{
bool result = axisMotion-> nameToIndex(rotAxis, parentAxisIndex_);
if( auto i = componentNames.findi(rotAxis); i != -1 )
{
parentAxisIndex_ = i;
}
else
{
fatalErrorInFunction<<"crotationAxis "<< rotAxis<<" in dictionary "<<
dict.globalName()<<" is not found in list of axis names "<< componentNames<<endl;
return false;
}
}
return true;
@ -90,8 +86,8 @@ bool pFlow::multiRotatingAxis::read
FUNCTION_H
bool pFlow::multiRotatingAxis::write
(
const multiRotatingAxisMotion* axisMotion,
dictionary& dict
dictionary& dict,
const wordList& componentNames
) const
{
if( !rotatingAxis::write(dict) ) return false;
@ -102,33 +98,8 @@ bool pFlow::multiRotatingAxis::write
}
else
{
word rotAxis;
bool result = axisMotion->indexToName(parentAxisIndex_, rotAxis);
dict.add("rotationAxis", rotAxis);
dict.add("rotationAxis", componentNames[parentAxisIndex_]);
}
return true;
}
FUNCTION_H
bool pFlow::multiRotatingAxis::write
(
dictionary& dict
) const
{
// if( !rotatingAxis::write(dict) ) return false;
// if(parentAxisIndex_ == -1)
// {
// dict.add("rotationAxis", "none");
// }
// else
// {
// word rotAxis;
// bool result = axisMotion->indexToName(parentAxisIndex_, rotAxis);
// dict.add("rotationAxis", rotAxis);
// }
return true;
}

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

@ -24,7 +24,7 @@ Licence:
#include "rotatingAxis.hpp"
#include "KokkosTypes.hpp"
#include "List.hpp"
namespace pFlow
{
@ -79,7 +79,7 @@ class multiRotatingAxis
protected:
/// This is device pointer to all axes
multiRotatingAxis* axisList_;
multiRotatingAxis* axisList_ = nullptr;
/// Index of parent axis
uint32 parentAxisIndex_ = static_cast<uint32>(-1);
@ -98,13 +98,12 @@ public:
FUNCTION_H
explicit multiRotatingAxis(const dictionary& dict);
/// Empty with list of axes
FUNCTION_H
multiRotatingAxis(multiRotatingAxisMotion* axisMotion);
/// Construct from dictionary and list of axes
FUNCTION_H
multiRotatingAxis(multiRotatingAxisMotion* axisMotion, const dictionary& dict);
multiRotatingAxis(
multiRotatingAxis* axisListPtr,
const wordList& componentsNames,
const dictionary& dict);
/// Copy constructor
FUNCTION_HD
@ -149,7 +148,7 @@ public:
}
auto parIndex = parentAxisIndex_;
while(parIndex != -1)
while(parIndex != static_cast<uint32>(-1))
{
auto& ax = axisList_[parIndex];
newP = pFlow::rotate(newP, ax, dt);
@ -163,12 +162,12 @@ public:
INLINE_FUNCTION_HD
bool hasParent()const
{
return parentAxisIndex_ > -1;
return parentAxisIndex_ != static_cast<uint32>(-1);
}
/// Return the index of parent axis
INLINE_FUNCTION_HD
int32 parentAxisIndex()const
uint32 parentAxisIndex()const
{
return parentAxisIndex_;
}
@ -207,15 +206,12 @@ public:
/// Read from dictionary
FUNCTION_H
bool read(multiRotatingAxisMotion* axisMotion, const dictionary& dict);
bool read(const dictionary& dict, const wordList& componentNames);
/// Write to dictionary
FUNCTION_H
bool write(const multiRotatingAxisMotion* axisMotion, dictionary& dict) const;
bool write(dictionary& dict, const wordList& componentNames) const;
/// Write to dictionary
FUNCTION_H
bool write(dictionary& dict) const;
};

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

@ -31,19 +31,179 @@ void pFlow::multiRotatingAxisMotion::impl_setTime
Kokkos::parallel_for(
"multiRotatingAxisMotion::impl_setTime",
deviceRPolicyStatic(0, numComponents_),
LAMBDA_HD(uint32 i){
LAMBDA_D(uint32 i){
motion[i].setTime(t);
});
Kokkos::fence();
}
bool pFlow::multiRotatingAxisMotion::impl_move(uint32 iter, real t , real dt ) const
{
auto motion = motionComponents_.deviceViewAll();
Kokkos::parallel_for(
"multiRotatingAxisMotion::impl_move",
deviceRPolicyStatic(0, numComponents_),
LAMBDA_D(uint32 i){
motion[i].move(dt);
});
Kokkos::fence();
return true;
}
bool pFlow::multiRotatingAxisMotion::impl_readDictionary(const dictionary &dict)
{
auto modelName = dict.getVal<word>("motionModel");
if(modelName != getTypeName<ModelComponent>())
{
fatalErrorInFunction<<
" motionModel should be "<< Yellow_Text(getTypeName<ModelComponent>())<<
", but found "<< Yellow_Text(modelName)<<endl;
return false;
}
auto& motionInfo = dict.subDict(modelName+"Info");
auto compNames = motionInfo.dictionaryKeywords();
wordList rotationAxisNames;
// in the first round read all dictionaries
for(auto& compName: compNames)
{
auto& axDict = motionInfo.subDict(compName);
if(auto axPtr = makeUnique<rotatingAxis>(axDict); axPtr)
{
rotationAxisNames.push_back(
axDict.getValOrSet<word>("rotationAxis", "none"));
}
else
{
fatalErrorInFunction<<
"could not read rotating axis from "<< axDict.globalName()<<endl;
return false;
}
}
if( !compNames.search("none") )
{
compNames.push_back("none");
rotationAxisNames.push_back("none");
}
using intPair = std::pair<int32, int32>;
std::vector<intPair> numRotAxis;
for(size_t i=0; i< compNames.size(); i++)
{
word rotAxis = rotationAxisNames[i];
int32 n=0;
while(rotAxis != "none")
{
n++;
if(int32 iAxis = compNames.findi(rotAxis) ; iAxis != -1)
{
rotAxis = rotationAxisNames[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; };
std::sort(numRotAxis.begin(), numRotAxis.end(), compareFunc);
Vector<int> sortedIndex;
componentNames_.clear();
output<<compNames<<endl;
for(auto ax:numRotAxis)
{
componentNames_.push_back(compNames[ax.second]);
sortedIndex.push_back(ax.second);
}
numComponents_ = componentNames_.size();
motionComponents_.reserve(numComponents_);
sortedIndex_.assign(sortedIndex);
Vector<ModelComponent> components("Read::modelComponent",
compNames.size()+1,
0,
RESERVE());
for(auto& compName: componentNames_)
{
if(compName != "none")
{
auto& compDict = motionInfo.subDict(compName);
components.emplace_back(
motionComponents_.data(),
componentNames_,
compDict);
}
else
{
components.emplace_back(impl_noneComponent());
}
}
motionComponents_.assign(components);
return true;
}
bool pFlow::multiRotatingAxisMotion::impl_writeDictionary
(
dictionary& dict
)const
{
word modelName = "multiRotatingAxis";
dict.add("motionModel", modelName );
auto modelDictName = modelName+"Info";
auto& motionInfo = dict.subDictOrCreate(modelDictName);
auto hostComponents = motionComponents_.hostView();
ForAll(i, motionComponents_)
{
auto& axDict = motionInfo.subDictOrCreate(componentNames_[i]);
if( !hostComponents[i].write(axDict, componentNames_))
{
fatalErrorInFunction<<
" error in writing axis "<< componentNames_[i] << " to dicrionary "
<< motionInfo.globalName()<<endl;
return false;
}
}
return true;
}
pFlow::multiRotatingAxisMotion::multiRotatingAxisMotion(
const objectFile &objf,
repository *owner)
: fileDictionary(objf, owner)
{
if(! impl_readDictionary(*this) )
if(! getModel().impl_readDictionary(*this) )
{
fatalErrorInFunction;
fatalExit;
@ -59,7 +219,7 @@ pFlow::multiRotatingAxisMotion::multiRotatingAxisMotion
:
fileDictionary(objf, dict, owner)
{
if(!impl_readDictionary(*this) )
if(!getModel().impl_readDictionary(*this) )
{
fatalErrorInFunction;
fatalExit;
@ -76,7 +236,7 @@ bool pFlow::multiRotatingAxisMotion::write
dictionary newDict(fileDictionary::dictionary::name(), true);
if( iop.thisProcWriteData() )
{
if( !this->impl_writeDictionary(newDict) ||
if( !getModel().impl_writeDictionary(newDict) ||
!newDict.write(os))
{
fatalErrorInFunction<<

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

@ -67,6 +67,8 @@ class multiRotatingAxisMotion
{
protected:
VectorSingle<int32> sortedIndex_;
friend MotionModel<multiRotatingAxisMotion, multiRotatingAxis>;
/// is the geometry attached to this component moving
@ -76,10 +78,12 @@ protected:
}
/// move the component itself
bool impl_move(uint32, real, real)const
{
return true;
}
bool impl_move(uint32 iter, real t, real dt)const;
/// Read from dictionary
bool impl_readDictionary(const dictionary& dict);
bool impl_writeDictionary(dictionary& dict)const;
public:
@ -97,7 +101,7 @@ public:
bool write(iOstream& os, const IOPattern& iop)const override;
static
auto noneComponent()
multiRotatingAxis noneComponent()
{
return multiRotatingAxis();
}