Multirotating axis motion for version 1.0

src/Interaction/sphereInteraction/sphereInteractionsNonLinearModModels.cpp

@@ -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::limitedNonLinearModNormalRolling, pFlow::multiRotationAxisMotionGeometry);
-//createInteraction(pFlow::cfModels::nonLimitedNonLinearModNormalRolling,pFlow::multiRotationAxisMotionGeometry);
+createInteraction(pFlow::cfModels::nonLimitedNonLinearModNormalRolling,pFlow::multiRotationAxisMotionGeometry);

src/MotionModel/entities/multiRotatingAxis/multiRotatingAxis.cpp

@@ -25,40 +25,29 @@ Licence:
 /// Construct from dictionary
 FUNCTION_H
 pFlow::multiRotatingAxis::multiRotatingAxis(const dictionary& dict)
-{
+:
-	if(!read(nullptr, dict))
+	rotatingAxis(dict)
-	{
+{}
-		fatalErrorInFunction<<
+
-		"  error in reading multiRotatingAxis from dictionary "<< dict.globalName()<<endl;
-		fatalExit;
-	}
-}
 
 FUNCTION_H
 pFlow::multiRotatingAxis::multiRotatingAxis
 (
-	multiRotatingAxisMotion* axisMotion
+	multiRotatingAxis* axisListPtr,
-)
+	const wordList& componentsNames,
-{
-	//axisList_ = axisMotion->getAxisListPtr();	
-}
-
-FUNCTION_H
-pFlow::multiRotatingAxis::multiRotatingAxis
-(
-	multiRotatingAxisMotion* axisMotion,
 	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;
+		dict.add("rotationAxis", componentNames[parentAxisIndex_]);	
-		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_ == -1)
-	// {
-	// 	dict.add("rotationAxis", "none");
-	// }
-	// else
-	// {
-	// 	word rotAxis;
-	// 	bool result  = axisMotion->indexToName(parentAxisIndex_, rotAxis);
-	// 	dict.add("rotationAxis", rotAxis);	
-	// }
-	
-	return true;
-}

src/MotionModel/entities/multiRotatingAxis/multiRotatingAxis.hpp

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

src/MotionModel/multiRotatingAxisMotion/multiRotatingAxisMotion.cpp

@@ -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<<

src/MotionModel/multiRotatingAxisMotion/multiRotatingAxisMotion.hpp

@@ -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
+	bool impl_move(uint32 iter, real t, real dt)const;
-	{
+
-		return true;
+	/// 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();
     }