Merge branch 'PhasicFlow:main' into benchmarks
This commit is contained in:
Wenxuan XU
GitHub
commit
7b534a9e91
|
|
@ -21,7 +21,6 @@ Licence:
|
|||
template<typename MotionModel>
|
||||
bool pFlow::geometryMotion<MotionModel>::findMotionIndex()
|
||||
{
|
||||
|
||||
if(motionComponentName().size() != numSurfaces() )
|
||||
{
|
||||
fatalErrorInFunction<<
|
||||
|
|
|
|||
|
|
@ -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>;
|
||||
|
|
|
|||
|
|
@ -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>;
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
)
|
||||
|
||||
|
|
|
|||
|
|
@ -32,7 +32,6 @@ bool pFlow::MotionModel<Model, Component>::impl_nameToIndex(const word& name, ui
|
|||
indx = static_cast<uint32>(i);
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
template<typename Model, typename Component>
|
||||
|
|
|
|||
|
|
@ -22,31 +22,32 @@ Licence:
|
|||
#include "multiRotatingAxisMotion.hpp"
|
||||
#include "dictionary.hpp"
|
||||
|
||||
/// Construct from dictionary
|
||||
FUNCTION_H
|
||||
pFlow::multiRotatingAxis::multiRotatingAxis
|
||||
(
|
||||
multiRotatingAxisMotion* axisMotion
|
||||
)
|
||||
{
|
||||
//axisList_ = axisMotion->getAxisListPtr();
|
||||
}
|
||||
pFlow::multiRotatingAxis::multiRotatingAxis(const dictionary& dict)
|
||||
:
|
||||
rotatingAxis(dict)
|
||||
{}
|
||||
|
||||
|
||||
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();
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -54,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
|
||||
{
|
||||
parentAxisIndex_ = axisMotion-> nameToIndex(rotAxis);
|
||||
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;
|
||||
|
|
@ -78,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;
|
||||
|
|
@ -90,10 +98,8 @@ bool pFlow::multiRotatingAxis::write
|
|||
}
|
||||
else
|
||||
{
|
||||
auto rotAxis = axisMotion->indexToName(parentAxisIndex_);
|
||||
dict.add("rotationAxis", rotAxis);
|
||||
dict.add("rotationAxis", componentNames[parentAxisIndex_]);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ Licence:
|
|||
|
||||
#include "rotatingAxis.hpp"
|
||||
#include "KokkosTypes.hpp"
|
||||
|
||||
#include "List.hpp"
|
||||
|
||||
namespace pFlow
|
||||
{
|
||||
|
|
@ -79,26 +79,31 @@ class multiRotatingAxis
|
|||
protected:
|
||||
|
||||
/// This is device pointer to all axes
|
||||
multiRotatingAxis* axisList_;
|
||||
multiRotatingAxis* axisList_ = nullptr;
|
||||
|
||||
/// Index of parent axis
|
||||
int32 parentAxisIndex_ = -1;
|
||||
uint32 parentAxisIndex_ = static_cast<uint32>(-1);
|
||||
|
||||
public:
|
||||
|
||||
TypeInfoNV("multiRotatingAxis");
|
||||
|
||||
// - Constructors
|
||||
|
||||
/// Empty Constructor
|
||||
INLINE_FUNCTION_HD
|
||||
multiRotatingAxis(){}
|
||||
FUNCTION_HD
|
||||
multiRotatingAxis() = default;
|
||||
|
||||
/// Empty with list of axes
|
||||
/// Construct from dictionary
|
||||
FUNCTION_H
|
||||
multiRotatingAxis(multiRotatingAxisMotion* axisMotion);
|
||||
explicit multiRotatingAxis(const dictionary& dict);
|
||||
|
||||
/// 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
|
||||
|
|
@ -123,11 +128,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
|
||||
|
|
@ -143,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);
|
||||
|
|
@ -157,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_;
|
||||
}
|
||||
|
|
@ -182,6 +187,7 @@ public:
|
|||
* It is assumed that the axis with deepest level (with more parrents) is
|
||||
* moved first and then the axis with lower levels.
|
||||
*/
|
||||
INLINE_FUNCTION_HD
|
||||
void move(real dt)
|
||||
{
|
||||
|
||||
|
|
@ -201,11 +207,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;
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -19,40 +19,63 @@ Licence:
|
|||
-----------------------------------------------------------------------------*/
|
||||
|
||||
#include "multiRotatingAxisMotion.hpp"
|
||||
#include "dictionary.hpp"
|
||||
#include "vocabs.hpp"
|
||||
|
||||
|
||||
bool pFlow::multiRotatingAxisMotion::readDictionary
|
||||
void pFlow::multiRotatingAxisMotion::impl_setTime
|
||||
(
|
||||
const dictionary& dict
|
||||
)
|
||||
uint32 iter,
|
||||
real t,
|
||||
real dt
|
||||
)const
|
||||
{
|
||||
auto motion = motionComponents_.deviceViewAll();
|
||||
Kokkos::parallel_for(
|
||||
"multiRotatingAxisMotion::impl_setTime",
|
||||
deviceRPolicyStatic(0, numComponents_),
|
||||
LAMBDA_D(uint32 i){
|
||||
motion[i].setTime(t);
|
||||
});
|
||||
Kokkos::fence();
|
||||
}
|
||||
|
||||
auto motionModel = dict.getVal<word>("motionModel");
|
||||
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;
|
||||
}
|
||||
|
||||
if(motionModel != "multiRotatingAxisMotion")
|
||||
bool pFlow::multiRotatingAxisMotion::impl_readDictionary(const dictionary &dict)
|
||||
{
|
||||
auto modelName = dict.getVal<word>("motionModel");
|
||||
|
||||
if(modelName != getTypeName<ModelComponent>())
|
||||
{
|
||||
fatalErrorInFunction<<
|
||||
" motionModel should be multiRotatingAxisMotion, but found "
|
||||
<< motionModel <<endl;
|
||||
" motionModel should be "<< Yellow_Text(getTypeName<ModelComponent>())<<
|
||||
", but found "<< Yellow_Text(modelName)<<endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
auto& motionInfo = dict.subDict("multiRotatingAxisMotionInfo");
|
||||
auto axisNames = motionInfo.dictionaryKeywords();
|
||||
wordList rotationAxis;
|
||||
|
||||
// first check if
|
||||
auto& motionInfo = dict.subDict(modelName+"Info");
|
||||
auto compNames = motionInfo.dictionaryKeywords();
|
||||
|
||||
|
||||
for(auto& aName: axisNames)
|
||||
wordList rotationAxisNames;
|
||||
|
||||
|
||||
// in the first round read all dictionaries
|
||||
for(auto& compName: compNames)
|
||||
{
|
||||
auto& axDict = motionInfo.subDict(aName);
|
||||
auto& axDict = motionInfo.subDict(compName);
|
||||
|
||||
if(auto axPtr = makeUnique<rotatingAxis>(axDict); axPtr)
|
||||
{
|
||||
rotationAxis.push_back(
|
||||
rotationAxisNames.push_back(
|
||||
axDict.getValOrSet<word>("rotationAxis", "none"));
|
||||
}
|
||||
else
|
||||
|
|
@ -63,26 +86,26 @@ bool pFlow::multiRotatingAxisMotion::readDictionary
|
|||
}
|
||||
}
|
||||
|
||||
if( !axisNames.search("none") )
|
||||
if( !compNames.search("none") )
|
||||
{
|
||||
axisNames.push_back("none");
|
||||
rotationAxis.push_back("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< axisNames.size(); i++)
|
||||
for(size_t i=0; i< compNames.size(); i++)
|
||||
{
|
||||
word rotAxis = rotationAxis[i];
|
||||
word rotAxis = rotationAxisNames[i];
|
||||
int32 n=0;
|
||||
while(rotAxis != "none")
|
||||
{
|
||||
n++;
|
||||
if(int32 iAxis = axisNames.findi(rotAxis) ; iAxis != -1)
|
||||
if(int32 iAxis = compNames.findi(rotAxis) ; iAxis != -1)
|
||||
{
|
||||
rotAxis = rotationAxis[iAxis];
|
||||
rotAxis = rotationAxisNames[iAxis];
|
||||
}else
|
||||
{
|
||||
fatalErrorInFunction<<
|
||||
|
|
@ -98,60 +121,73 @@ bool pFlow::multiRotatingAxisMotion::readDictionary
|
|||
auto compareFunc = [](const intPair& a, const intPair& b)
|
||||
{ return a.first > b.first; };
|
||||
|
||||
algorithms::STD::sort(numRotAxis.data(), numRotAxis.size(), compareFunc);
|
||||
std::sort(numRotAxis.begin(), numRotAxis.end(), compareFunc);
|
||||
Vector<int> sortedIndex;
|
||||
componentNames_.clear();
|
||||
|
||||
sortedIndex_.clear();
|
||||
axisName_.clear();
|
||||
output<<compNames<<endl;
|
||||
|
||||
|
||||
for(auto ax:numRotAxis)
|
||||
{
|
||||
axisName_.push_back(axisNames[ax.second]);
|
||||
sortedIndex_.push_back(ax.second);
|
||||
componentNames_.push_back(compNames[ax.second]);
|
||||
sortedIndex.push_back(ax.second);
|
||||
}
|
||||
|
||||
numAxis_ = axisName_.size();
|
||||
axis_.clear();
|
||||
axis_.reserve(numAxis_);
|
||||
numComponents_ = componentNames_.size();
|
||||
motionComponents_.reserve(numComponents_);
|
||||
sortedIndex_.assign(sortedIndex);
|
||||
|
||||
|
||||
// create the actual axis vector
|
||||
for(auto& aName: axisName_)
|
||||
Vector<ModelComponent> components("Read::modelComponent",
|
||||
compNames.size()+1,
|
||||
0,
|
||||
RESERVE());
|
||||
|
||||
|
||||
for(auto& compName: componentNames_)
|
||||
{
|
||||
if(aName != "none")
|
||||
|
||||
if(compName != "none")
|
||||
{
|
||||
auto& axDict = motionInfo.subDict(aName);
|
||||
axis_.push_back(
|
||||
multiRotatingAxis(this, axDict));
|
||||
auto& compDict = motionInfo.subDict(compName);
|
||||
components.emplace_back(
|
||||
motionComponents_.data(),
|
||||
componentNames_,
|
||||
compDict);
|
||||
}
|
||||
else
|
||||
{
|
||||
axis_.push_back(
|
||||
multiRotatingAxis(this));
|
||||
components.emplace_back(impl_noneComponent());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return true;
|
||||
motionComponents_.assign(components);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool pFlow::multiRotatingAxisMotion::writeDictionary
|
||||
|
||||
bool pFlow::multiRotatingAxisMotion::impl_writeDictionary
|
||||
(
|
||||
dictionary& dict
|
||||
)const
|
||||
{
|
||||
dict.add("motionModel", "multiRotatingAxisMotion");
|
||||
word modelName = "multiRotatingAxis";
|
||||
|
||||
auto& motionInfo = dict.subDictOrCreate("multiRotatingAxisMotionInfo");
|
||||
|
||||
ForAll(i, axis_)
|
||||
dict.add("motionModel", modelName );
|
||||
|
||||
auto modelDictName = modelName+"Info";
|
||||
|
||||
auto& motionInfo = dict.subDictOrCreate(modelDictName);
|
||||
auto hostComponents = motionComponents_.hostView();
|
||||
|
||||
ForAll(i, motionComponents_)
|
||||
{
|
||||
|
||||
auto& axDict = motionInfo.subDictOrCreate(axisName_[i]);
|
||||
if( !axis_.hostVectorAll()[i].write(this,axDict))
|
||||
auto& axDict = motionInfo.subDictOrCreate(componentNames_[i]);
|
||||
if( !hostComponents[i].write(axDict, componentNames_))
|
||||
{
|
||||
fatalErrorInFunction<<
|
||||
" error in writing axis "<< axisName_[i] << " to dicrionary "
|
||||
" error in writing axis "<< componentNames_[i] << " to dicrionary "
|
||||
<< motionInfo.globalName()<<endl;
|
||||
return false;
|
||||
}
|
||||
|
|
@ -160,79 +196,52 @@ bool pFlow::multiRotatingAxisMotion::writeDictionary
|
|||
return true;
|
||||
}
|
||||
|
||||
pFlow::multiRotatingAxisMotion::multiRotatingAxisMotion()
|
||||
{}
|
||||
|
||||
pFlow::multiRotatingAxisMotion::multiRotatingAxisMotion
|
||||
(
|
||||
const dictionary& dict
|
||||
)
|
||||
pFlow::multiRotatingAxisMotion::multiRotatingAxisMotion(
|
||||
const objectFile &objf,
|
||||
repository *owner)
|
||||
: fileDictionary(objf, owner)
|
||||
{
|
||||
if(! readDictionary(dict) )
|
||||
|
||||
if(! getModel().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
|
||||
pFlow::multiRotatingAxisMotion::multiRotatingAxisMotion
|
||||
(
|
||||
iIstream& is
|
||||
const objectFile &objf,
|
||||
const dictionary &dict,
|
||||
repository *owner
|
||||
)
|
||||
:
|
||||
fileDictionary(objf, dict, owner)
|
||||
{
|
||||
// create an empty file dictionary
|
||||
dictionary motionInfo(motionModelFile__, true);
|
||||
|
||||
// read dictionary from stream
|
||||
if( !motionInfo.read(is) )
|
||||
if(!getModel().impl_readDictionary(*this) )
|
||||
{
|
||||
ioErrorInFile(is.name(), is.lineNumber()) <<
|
||||
" error in reading dictionray " << motionModelFile__ <<" from file. \n";
|
||||
return false;
|
||||
fatalErrorInFunction;
|
||||
fatalExit;
|
||||
}
|
||||
|
||||
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( !getModel().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;
|
||||
}
|
||||
|
|
@ -22,18 +22,16 @@ Licence:
|
|||
#define __multiRotatingAxisMotion_hpp__
|
||||
|
||||
|
||||
#include "types.hpp"
|
||||
#include "typeInfo.hpp"
|
||||
#include "VectorDual.hpp"
|
||||
#include "List.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 +61,55 @@ 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>;
|
||||
VectorSingle<int32> sortedIndex_;
|
||||
|
||||
/// Vector of multiRotaingAxis axes
|
||||
axisVector_HD axis_;
|
||||
|
||||
/// Sorted index based on number of parrents each axis ha
|
||||
VectorDual<int32> sortedIndex_;
|
||||
friend MotionModel<multiRotatingAxisMotion, multiRotatingAxis>;
|
||||
|
||||
/// List of axes names
|
||||
wordList axisName_;
|
||||
/// is the geometry attached to this component moving
|
||||
bool impl_isMoving()const
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
/// Number of axes
|
||||
label numAxis_= 0;
|
||||
|
||||
/// Read from a dictionary
|
||||
bool readDictionary(const dictionary& dict);
|
||||
|
||||
/// Write to a dictionary
|
||||
bool writeDictionary(dictionary& dict)const;
|
||||
/// Read from dictionary
|
||||
bool impl_readDictionary(const dictionary& dict);
|
||||
|
||||
bool impl_writeDictionary(dictionary& dict)const;
|
||||
|
||||
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
|
||||
multiRotatingAxis noneComponent()
|
||||
{
|
||||
return multiRotatingAxis();
|
||||
}
|
||||
|
||||
/// Copy assignment
|
||||
FUNCTION_H
|
||||
multiRotatingAxisMotion& operator=(const multiRotatingAxisMotion&) = default;
|
||||
// TODO: make this method protected
|
||||
void impl_setTime(uint32 iter, real t, real dt)const;
|
||||
|
||||
/// 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;
|
||||
|
||||
|
||||
/// move the component itself
|
||||
bool impl_move(uint32 iter, real t, real dt)const;
|
||||
};
|
||||
|
||||
} // pFlow
|
||||
|
|
|
|||
Loading…
Reference in New Issue