adapt the multiRotatingAxisMotion to v-1.0

src/Geometry/geometryMotion/geometryMotions.cpp

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

src/Geometry/geometryMotion/geometryMotions.hpp

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

src/MotionModel/CMakeLists.txt

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

src/MotionModel/entities/multiRotatingAxis/multiRotatingAxis.cpp

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

src/MotionModel/entities/multiRotatingAxis/multiRotatingAxis.hpp

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

src/MotionModel/multiRotatingAxisMotion/multiRotatingAxisMotion.cpp

@@ -19,220 +19,70 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "multiRotatingAxisMotion.hpp"
-#include "dictionary.hpp"
-#include "vocabs.hpp"
 
-
+void pFlow::multiRotatingAxisMotion::impl_setTime
-bool pFlow::multiRotatingAxisMotion::readDictionary
 (
-	const dictionary& dict
+	uint32 iter, 
-)
+	real t, 
-{
+	real dt
-
-	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
 )const
 {
-	dict.add("motionModel", "multiRotatingAxisMotion");
+	auto motion = motionComponents_.deviceViewAll();
-
+	Kokkos::parallel_for(
-	auto& motionInfo = dict.subDictOrCreate("multiRotatingAxisMotionInfo");
+		"multiRotatingAxisMotion::impl_setTime",
-	
+		deviceRPolicyStatic(0, numComponents_),
-	ForAll(i, axis_)
+		LAMBDA_HD(uint32 i){
-	{
+			motion[i].setTime(t);
-		
+		});
-		auto& axDict = motionInfo.subDictOrCreate(axisName_[i]);
+	Kokkos::fence();
-		if( !axis_.hostVectorAll()[i].write(this,axDict))
-		{
-			fatalErrorInFunction<<
-			"  error in writing axis "<< axisName_[i] << " to dicrionary "
-			<< motionInfo.globalName()<<endl;
-			return false;
-		}
-	}
-
-	return true;
 }
 
-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
+	iOstream &os, 
-)const
+	const IOPattern &iop
+) const
 {
-	// create an empty file dictionary
+	// a global dictionary
-	dictionary motionInfo(motionModelFile__, true);
+	dictionary newDict(fileDictionary::dictionary::name(), true);
-
+	if( iop.thisProcWriteData() )
-	if( !writeDictionary(motionInfo))
 	{
-		return false;
+		if( !this->impl_writeDictionary(newDict) || 
+			!newDict.write(os))
+		{
+			fatalErrorInFunction<<
+			" error in writing to dictionary "<< newDict.globalName()<<endl;
+			return false;
+		}
 	}
-
+    return true;
-	if( !motionInfo.write(os) )
-	{
-		ioErrorInFile( os.name(), os.lineNumber() )<<
-		"  error in writing dictionray to file. \n";
-		return false;
-	}
-	return true;
 }

src/MotionModel/multiRotatingAxisMotion/multiRotatingAxisMotion.hpp

@@ -22,18 +22,22 @@ Licence:
 #define __multiRotatingAxisMotion_hpp__
 
 
-#include "types.hpp"
+// #include "types.hpp"
-#include "typeInfo.hpp"
+// #include "typeInfo.hpp"
-#include "VectorDual.hpp"
+// #include "VectorSingle.hpp"
-#include "List.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
+	/// is the geometry attached to this component moving
-	axisVector_HD 		axis_;
+	bool impl_isMoving()const
+	{
+		return true;
+	}
 
-	/// Sorted index based on number of parrents each axis ha
+	/// move the component itself
-	VectorDual<int32> 	sortedIndex_;
+	bool impl_move(uint32, real, real)const
-
+	{
-	/// List of axes names
+		return true;
-	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;
 
 public:
 	
-	/// Type info
+    TypeInfo("multiRotatingAxisMotion");
-	TypeInfoNV("multiRotatingAxisMotion");
 
-	// - Constructor 
+	multiRotatingAxisMotion(const objectFile& objf, repository* owner);
 
-		/// Empty constructor 
+	multiRotatingAxisMotion(
-		FUNCTION_H
+		const objectFile& objf, 
-		multiRotatingAxisMotion();
+		const dictionary& dict, 
+		repository* owner);
 
-		/// Construct with dictionary 
+    using fileDictionary::write;
-		FUNCTION_H
-		multiRotatingAxisMotion(const dictionary& dict);
 
-		/// Copy constructor 
+	bool write(iOstream& os, const IOPattern& iop)const override;
-		FUNCTION_H
-		multiRotatingAxisMotion(const multiRotatingAxisMotion&) = default;
-
-		/// No Move 
-		multiRotatingAxisMotion(multiRotatingAxisMotion&&) = delete;
-
-		/// 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;
 
+	static
+    auto noneComponent()
+    {
+        return multiRotatingAxis{};
+    }
 
+    // TODO: make this method protected
+    void impl_setTime(uint32 iter, real t, real dt)const;
 };
 
 } // pFlow