Update codingStyle.md

doxygen documentation is added

doc/mdDocs/codingStyle.md

@@ -0,0 +1,231 @@
+# PhasicFlow Coding Style Guidelines
+This document outlines the coding style guidelines for the PhasicFlow codebase. 
+Adhering to these guidelines ensures consistency, readability, and maintainability of the project.
+## 1. FormattingIndentation: 
+* Use 4 spaces for every logical level and block.
+* Line Spacing: Leave two empty lines between sections (e.g., between functions in a .cpp file, between class members).
+
+## 2. Naming ConventionsGeneral Naming: 
+* All names should start with lowercase letters, except for special names (e.g., Ergun, Hertz).
+* Macro names start with Upper case or all the letters are in UPPER case.
+* Compound Names: For compound names, the first word starts with a lowercase letter, and subsequent words start with an uppercase letter (e.g., boundaryBase, motionModel).
+
+## 3. File Structure 
+* Header Files: Use the .hpp extension for header files.
+* Source Files: Use the .cpp extension for source files.
+* Header and Source File Headers: All header and source files must include a standardized header that describes the project's intention and licensing information.
+* File Naming: Header and source file names should correspond to the class they contain. Aim for one class per file.
+* Inline Functions: Place inline functions in a separate classNameI.hpp file to avoid cluttering the main header file.
+
+## 4. Class DesignClass Member Order:
+* Private members and methods
+* Private static members and methods
+* Public methods
+* Public static methods
+* Enumerations and Nested Classes: Declare enumerations and nested classes before all class members and methods.
+* Special Functions: Each class must explicitly define all special functions:Constructor, Copy constructor and assignment operator, Move constructor and assignment operator
+* Destructor: Each class must have an explicit destructor declaration:`~className() = default`; or `~className();`
+* Interface classes or classes with virtual methods must have a virtual destructor.
+* Virtual Method Overrides: When implementing a `virtual` method from a base class in a derived class, use the `override` keyword. The same applies to derived class destructors.
+## 5. NamespacesOfficial Namespace: 
+The official namespace for the codebase is pFlow. All entities should be defined within this namespace.
+
+### Example File Structure
+```
+src/
+├── componentName1/
+│   ├── componentName1.hpp
+│   ├── componentName1.cpp
+│   ├── componentName1I.hpp
+│   └── ...
+└── componentName2/
+    ├── componentName2.hpp
+    ├── componentName2.cpp
+    └── ...
+```
+### Example Class Structure
+```C++
+namespace pFlow 
+{
+
+class MyClass 
+{
+public:
+    enum class MyEnum 
+    {
+        Value1,
+        Value2
+    };
+
+    class NestedClass 
+    {
+        // ...
+    };
+
+private:
+    int privateMember_;
+    
+    void privateMethod();
+
+    
+    static int privateStaticMember_;
+    
+    static void privateStaticMethod();
+
+public:
+    
+    MyClass();
+
+    MyClass(const MyClass& other);
+    
+    MyClass(MyClass&& other);
+    
+    MyClass& operator=(const MyClass& other);
+    
+    MyClass& operator=(MyClass&& other);
+    
+    ~MyClass();
+
+    
+    void publicMethod();
+    
+    static void publicStaticMethod();
+
+};
+
+// assuming base class has virtual methods 
+class DerivedClass 
+: 
+    public BaseClass 
+{
+public:
+     
+     ...
+
+    ~DerivedClass() override;
+    
+     void virtualMethod() override;
+};
+
+} // namespace pFlow
+``` 
+
+## 6. Doxygen Documentation
+
+### 6.1. Ruls
+provide the documentations in the header files only. In rare cases where you are generating documentations for executables, the doxygen documentation can be supplied in the .cpp file.  
+
+* **General Doxygen Style:**
+
+    * Use `///` for short documentations for methods and members.
+
+    * Use `/** */` for classes and main methods which play a significant role in the class or code.
+
+    * Place Doxygen comments *before* the declaration of the entity being documented (e.g., class, function, variable).
+
+    * Use `@param` to document function parameters, `@return` for return values, `@brief` for a short description, and `@details` for a more in-depth explanation.
+
+    * Use Markdown syntax within Doxygen comments for formatting.
+
+* **File Headers:** Each file should contain a Doxygen comment at the top, including:
+
+    * `@file` : The name of the file.
+
+    * `@brief`: A brief description of the file's purpose.
+
+    * `@author`: The author(s) of the file.
+
+    * `@date` : The date of creation or last modification.
+
+* **Class Documentation:**
+
+    * Use `/** */` for class documentation.
+
+    * Provide a `@brief` description of the class.
+
+    * Use `@tparam` to document template parameters.
+
+    * Document the purpose of the class, its invariants, and how it should be used.
+
+* **Function/Method Documentation:**
+
+    * Use `///` for short documentations.
+
+    * Use `/** */` for main methods which play a significant role.
+
+    * Provide a `@brief` description of the function.
+
+    * Use `@param` to describe each parameter, including its purpose and whether it is an input, output, or input/output parameter.
+
+    * Use `@return` to describe the return value, including its meaning and possible values.
+
+    * Use `@pre` to document any preconditions that must be met before calling the function.
+
+    * Use `@post` to document any postconditions that will be true after the function returns.
+
+    * Use `@throws` to document any exceptions that the function may throw.
+
+    * Use `@details` for a more detailed explanation of the function's behavior, algorithms, or any other relevant information.
+
+* **Variable Documentation:**
+
+    * Use `///<` for single-line documentation of variables.
+
+### 6.2. Doxygen Documentation Examples
+
+* **Class example**
+
+```cpp
+/**
+ * @brief Represents a particle in the simulation.
+ * @details This class stores the position, velocity, and other physical
+ * properties of a particle.
+ */
+class Particle
+{
+private:
+
+    Point     position_;   ///< The current position of the particle.
+
+    Vector    velocity_;   ///< The current velocity of the particle.
+
+    double     mass_;      ///< The mass of the particle.
+
+public:
+
+    /// Constructs a particle with default values.
+    Particle();
+
+    /**
+     * @brief Updates the position of the particle based on its velocity
+     * and the given time step.
+     * @param deltaTime The time elapsed since the last update, in seconds.
+     */
+    void updatePosition(const timeInfo& ti );
+
+    /// Gets the current position of the particle.
+    Point getPosition() const;
+};
+```
+
+* **Function Example**
+
+```cpp
+/**
+ * @brief Calculates the distance between two points.
+ * @param p1 The first point.
+ * @param p2 The second point.
+ * @return The distance between the two points.
+ */
+double calculateDistance(const Point& p1, const Point& p2)
+{
+    // Implementation
+    return 0.0;
+}
+
+/// Returns the velocity of the particle.
+Vector getVelocity() const
+{
+    return velocity_;
+}
+``` 

src/Geometry/geometryMotion/geometryMotion.cpp

@@ -21,7 +21,6 @@ Licence:
 template<typename MotionModel>
 bool pFlow::geometryMotion<MotionModel>::findMotionIndex()
 {
-	
 	if(motionComponentName().size() != numSurfaces() )
 	{
 		fatalErrorInFunction<<

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/Interaction/contactLists/sortedPairs.hpp

@@ -193,7 +193,7 @@ public:
 
 		if( capacity+1 > flags_.size() )
 		{
-			reallocNoInit(flags_, capacity+1);
+			reallocInit(flags_, capacity+1);
 		}
 
 		// fill the flags
@@ -219,7 +219,7 @@ public:
 		{
 			// get more space to prevent reallocations in next iterations
 			uint32 len = size_*1.1+1; 
-			reallocNoInit(sortedPairs_, len);
+			reallocInit(sortedPairs_, len);
 		}
 		
 		Kokkos::parallel_for(
@@ -232,6 +232,7 @@ public:
 		sort(sortedPairs_, 0, size_ );
 		
 		
+
 	}
 
 	INLINE_FUNCTION_HD

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/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/MotionModel/MotionModel.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>

src/MotionModel/entities/multiRotatingAxis/multiRotatingAxis.cpp

@@ -22,31 +22,32 @@ Licence:
 #include "multiRotatingAxisMotion.hpp"
 #include "dictionary.hpp"
 
+/// Construct from dictionary
 FUNCTION_H
-pFlow::multiRotatingAxis::multiRotatingAxis
+pFlow::multiRotatingAxis::multiRotatingAxis(const dictionary& dict)
-(
+:
-	multiRotatingAxisMotion* axisMotion
+	rotatingAxis(dict)
-)
+{}
-{
+
-	//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();
 }
 
 
@@ -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", componentNames[parentAxisIndex_]);	
-		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,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
+		FUNCTION_HD
-		multiRotatingAxis(){}
+		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;
+
 
 };
 

src/MotionModel/multiRotatingAxisMotion/multiRotatingAxisMotion.cpp

@@ -19,40 +19,63 @@ 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
+)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 should be "<< Yellow_Text(getTypeName<ModelComponent>())<<
-		 << motionModel <<endl;
+		", but found "<< Yellow_Text(modelName)<<endl;
 		return false;
 	}
 
-	auto& motionInfo = dict.subDict("multiRotatingAxisMotionInfo");
+	auto& motionInfo = dict.subDict(modelName+"Info");
-	auto axisNames = motionInfo.dictionaryKeywords();
+	auto compNames = motionInfo.dictionaryKeywords();
-	wordList rotationAxis;
 	
-	// first check if 
+	wordList rotationAxisNames;
 
 	
-	for(auto& aName: axisNames)
+	// 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");
+		compNames.push_back("none");
-		rotationAxis.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; 
-	sortedIndex_.clear();
+	componentNames_.clear();
-	axisName_.clear();
 
+	output<<compNames<<endl;
 	
 	for(auto ax:numRotAxis)
 	{
-		axisName_.push_back(axisNames[ax.second]);
+		componentNames_.push_back(compNames[ax.second]);
-		sortedIndex_.push_back(ax.second);
+		sortedIndex.push_back(ax.second);
 	}
 
-	numAxis_ = axisName_.size();
+	numComponents_ = componentNames_.size();
-	axis_.clear();
+	motionComponents_.reserve(numComponents_);
-	axis_.reserve(numAxis_);
+	sortedIndex_.assign(sortedIndex);
+
+	Vector<ModelComponent> components("Read::modelComponent", 
+		compNames.size()+1, 
+		0, 
+		RESERVE());
 	
 		
-	// create the actual axis vector 
+	for(auto& compName: componentNames_)
-	for(auto& aName: axisName_)
 	{
-		if(aName != "none")
+		
+		if(compName != "none")
 		{
-			auto& axDict = motionInfo.subDict(aName);
+			auto& compDict = motionInfo.subDict(compName);
-			axis_.push_back(
+			components.emplace_back(
-				multiRotatingAxis(this, axDict));	
+				motionComponents_.data(), 
+				componentNames_, 
+				compDict);
 		}
 		else
 		{
-			axis_.push_back(
+			components.emplace_back(impl_noneComponent());
-				multiRotatingAxis(this));
 		}
 		
 	}
 
+	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");
+	dict.add("motionModel", modelName );
 
-	ForAll(i, axis_)
+	auto modelDictName = modelName+"Info";
+
+	auto& motionInfo = dict.subDictOrCreate(modelDictName);
+	auto hostComponents = motionComponents_.hostView();
+
+	ForAll(i, motionComponents_)
 	{
 		
-		auto& axDict = motionInfo.subDictOrCreate(axisName_[i]);
+		auto& axDict = motionInfo.subDictOrCreate(componentNames_[i]);
-		if( !axis_.hostVectorAll()[i].write(this,axDict))
+		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 objectFile &objf,
+    repository *owner)
+    : fileDictionary(objf, owner)
+{
 
-pFlow::multiRotatingAxisMotion::multiRotatingAxisMotion
+	if(! getModel().impl_readDictionary(*this) )
-(
-	const dictionary& dict
-)
-{
-	if(! readDictionary(dict) )
 	{
+		fatalErrorInFunction;
 		fatalExit;
 	}
 }
 
-FUNCTION_H
+pFlow::multiRotatingAxisMotion::multiRotatingAxisMotion
-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
+	const objectFile &objf, 
+	const dictionary &dict, 
+	repository *owner
 )
+:
+fileDictionary(objf, dict, owner)
 {
-	// create an empty file dictionary
+	if(!getModel().impl_readDictionary(*this) )
-	dictionary motionInfo(motionModelFile__, true);
-
-	// read dictionary from stream
-	if( !motionInfo.read(is) )
 	{
-		ioErrorInFile(is.name(), is.lineNumber()) <<
+		fatalErrorInFunction;
-		"  error in reading dictionray " << motionModelFile__ <<" from file. \n";
+		fatalExit;
-		return false;
 	}
-
-	if( !readDictionary(motionInfo) ) return false;
-	
-	return true;
 }
 
 bool pFlow::multiRotatingAxisMotion::write
 (
-	iOstream& os
+	iOstream &os, 
+	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))
 	{
+		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;
 }

src/MotionModel/multiRotatingAxisMotion/multiRotatingAxisMotion.hpp

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

src/phasicFlow/Kokkos/KokkosUtilities.hpp

@@ -56,7 +56,7 @@ template<typename Type, typename... Properties>
 INLINE_FUNCTION_H void
 reallocInit(ViewType1D<Type, Properties...>& view, uint32 len)
 {
-	Kokkos::realloc(Kokkos::WithoutInitializing, view, len);
+	Kokkos::realloc(view, len);
 }
 
 template<typename Type, typename... Properties>

src/phasicFlow/Kokkos/ViewAlgorithms.hpp

@@ -28,6 +28,8 @@ Licence:
 #include "cudaAlgorithms.hpp"
 #include "kokkosAlgorithms.hpp"
 #include "stdAlgorithms.hpp"
+#include "Kokkos_Sort.hpp"
+
 
 namespace pFlow
 {
@@ -295,7 +297,9 @@ sort(ViewType1D<T, properties...>& view, uint32 start, uint32 end)
 
 	if constexpr (isHostAccessible<ExecutionSpace>())
 	{
-		pFlow::algorithms::STD::sort<T, true>(view.data() + start, numElems);
+		//auto sView = Kokkos::subview(view, Kokkos::make_pair<uint32,uint32>(start,end));
+		//Kokkos::sort(sView);
+		pFlow::algorithms::STD::sort<T, false>(view.data() + start, numElems);
 		return;
 	}
 
@@ -316,7 +320,7 @@ sort(
   ViewType1D<T, properties...>& view,
   uint32                        start,
   uint32                        end,
-  CompareFunc                   compare
+  const CompareFunc&            compare
 )
 {
 	using ExecutionSpace =
@@ -326,9 +330,12 @@ sort(
 
 	if constexpr (isHostAccessible<ExecutionSpace>())
 	{
-		pFlow::algorithms::STD::sort<T, CompareFunc, true>(
+		// sort without parallelization 
+		pFlow::algorithms::STD::sort<T, CompareFunc,false>(
 		  view.data() + start, numElems, compare
 		);
+		//auto sView = Kokkos::subview(view, Kokkos::make_pair<uint32,uint32>(start,end));
+		//Kokkos::sort(sView, compare);
 		return;
 	}
 
@@ -345,6 +352,7 @@ sort(
 	return;
 }
 
+
 template<
   typename Type,
   typename... properties,

src/phasicFlow/algorithms/stdAlgorithms.hpp

@@ -148,7 +148,7 @@ void sort(Type* first, int32 numElems)
 	if constexpr(useParallel)
 	{
 		std::sort(
-			std::execution::par,
+			std::execution::par_unseq,
 			first,
 			first+numElems,
 			less<Type>());