Boundary conditions are created and tested.

- exit and periodic, follows the previous commit.

src/Interaction/sphereInteraction/boundaries/boundarySphereInteraction/boundarySphereInteraction.cpp

@@ -0,0 +1,91 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+
+
+template <typename cFM, typename gMM>
+pFlow::boundarySphereInteraction<cFM, gMM>::boundarySphereInteraction(
+	const boundaryBase &boundary,
+	const sphereParticles &sphPrtcls,
+	const GeometryMotionModel &geomMotion)
+	: generalBoundary(boundary, sphPrtcls.pStruct(), "", ""),
+	  geometryMotion_(geomMotion),
+	  sphParticles_(sphPrtcls)
+{
+	ppPairs_ = makeUnique<ContactListType>(1);
+	pwPairs_ = makeUnique<ContactListType>(1);
+}
+
+template <typename cFM, typename gMM>
+pFlow::uniquePtr<pFlow::boundarySphereInteraction<cFM, gMM>>
+pFlow::boundarySphereInteraction<cFM, gMM>::create(
+	const boundaryBase &boundary,
+	const sphereParticles &sphPrtcls,
+	const GeometryMotionModel &geomMotion)
+{
+	word cfTypeName = ContactForceModel::TYPENAME();
+	word gmTypeName = MotionModel::TYPENAME();
+	word bType = boundary.type();
+
+	word boundaryTypeName = angleBracketsNames3(
+		"boundarySphereInteraction",
+		bType,
+		cfTypeName,
+		gmTypeName);
+
+	word altBTypeName = angleBracketsNames2(
+		"boundarySphereInteraction",
+		cfTypeName,
+		gmTypeName);
+
+	if (boundaryBasevCtorSelector_.search(boundaryTypeName))
+	{
+		REPORT(2) << "Creating boundry type " << Green_Text(boundaryTypeName) << 
+		" for boundary " << boundary.name() << " . . ." << END_REPORT;
+		return boundaryBasevCtorSelector_[boundaryTypeName](
+			boundary,
+			sphPrtcls,
+			geomMotion);
+	}
+	else if(boundaryBasevCtorSelector_[altBTypeName])
+	{
+		// if boundary condition is not implemented, the default is used
+		
+		REPORT(2) << "Creating boundry type " << Green_Text(altBTypeName) << 
+		" for boundary " << boundary.name() << " . . ." << END_REPORT;
+		return boundaryBasevCtorSelector_[altBTypeName](
+			boundary,
+			sphPrtcls,
+			geomMotion);
+	}
+	else
+	{
+		printKeys
+		( 
+			fatalError << "Ctor Selector "<< boundaryTypeName<<
+			" and "<< altBTypeName << " do not exist. \n"
+			<<"Avaiable ones are: \n\n"
+			,
+			boundaryBasevCtorSelector_
+		);
+		fatalExit;
+	}
+
+	return nullptr;
+}

src/Interaction/sphereInteraction/boundaries/boundarySphereInteraction/boundarySphereInteraction.hpp

@@ -0,0 +1,168 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+#ifndef __boundarySphereInteraction_hpp__
+#define __boundarySphereInteraction_hpp__
+
+#include "virtualConstructor.hpp"
+#include "generalBoundary.hpp"
+#include "unsortedContactList.hpp"
+#include "sphereParticles.hpp"
+
+namespace pFlow
+{
+
+template<typename contactForceModel,typename geometryMotionModel>
+class boundarySphereInteraction
+:
+    public generalBoundary
+{
+public:
+	
+	using BoundarySphereInteractionType
+			= boundarySphereInteraction<contactForceModel, geometryMotionModel>;
+
+    using GeometryMotionModel 	= geometryMotionModel;
+	
+	using ContactForceModel 	= contactForceModel;
+
+	using MotionModel 			= typename geometryMotionModel::MotionModel;
+
+	using ModelStorage 			= typename ContactForceModel::contactForceStorage;
+	
+	using IdType 			    = uint32;
+
+	using IndexType    		    = uint32;
+    
+    using ContactListType = 
+        unsortedContactList<ModelStorage, DefaultExecutionSpace, IdType>;
+
+private:
+
+	const GeometryMotionModel& 			geometryMotion_;
+
+	/// const reference to sphere particles 
+	const sphereParticles& 				sphParticles_;
+    
+	uniquePtr<ContactListType> 			ppPairs_;
+
+	uniquePtr<ContactListType>			pwPairs_;
+
+public:
+
+	TypeInfoTemplate12("boundarySphereInteraction", ContactForceModel, MotionModel);
+
+	boundarySphereInteraction(
+		const boundaryBase& boundary,
+		const sphereParticles& sphPrtcls,
+		const GeometryMotionModel& geomMotion);
+
+	create_vCtor
+	(
+		BoundarySphereInteractionType,
+		boundaryBase,
+		(
+			const boundaryBase& boundary,
+			const sphereParticles& sphPrtcls,
+			const GeometryMotionModel& geomMotion
+		),
+		(boundary, sphPrtcls, geomMotion)
+	);
+
+	add_vCtor
+	(
+		BoundarySphereInteractionType,
+		BoundarySphereInteractionType,
+		boundaryBase
+	);
+
+	~boundarySphereInteraction()override=default;
+
+	const auto& sphParticles()const
+	{
+		return sphParticles_;
+	}
+
+	const auto& geometryMotion()const
+	{
+		return geometryMotion_;
+	}
+
+	ContactListType& ppPairs()
+	{
+		return ppPairs_();
+	}
+
+	const ContactListType& ppPairs()const
+	{
+		return ppPairs_();
+	}
+
+	ContactListType& pwPairs()
+	{
+		return pwPairs_();
+	}
+
+	const ContactListType& pwPairs()const
+	{
+		return pwPairs_();
+	}
+
+	virtual
+	bool sphereSphereInteraction(
+		real dt,
+		const ContactForceModel& cfModel)
+	{
+		// for default boundary, no thing to be done 
+		return true;
+	}
+
+	bool hearChanges
+	(
+		real t,
+		real dt,
+		uint32 iter,
+		const message& msg, 
+    	const anyList& varList
+	) override
+    {
+		
+		notImplementedFunction;
+		return true;
+	}
+
+	void fill(const std::any& val)override
+	{
+		notImplementedFunction;
+	}
+
+	static
+	uniquePtr<BoundarySphereInteractionType> create(
+		const boundaryBase& boundary,
+		const sphereParticles& sphPrtcls,
+		const GeometryMotionModel& geomMotion
+	);
+
+};
+
+}
+
+#include "boundarySphereInteraction.cpp"
+
+#endif //__boundarySphereInteraction_hpp__

src/Interaction/sphereInteraction/boundaries/boundarySphereInteractionList.cpp

@@ -0,0 +1,23 @@
+
+
+template <typename CFModel, typename gMModel>
+pFlow::boundarySphereInteractionList<CFModel, gMModel>::boundarySphereInteractionList
+(
+    const sphereParticles &sphPrtcls, 
+    const gMModel &geomMotion
+)
+:
+	ListPtr<boundarySphereInteraction<CFModel,gMModel>>(6),
+	boundaries_(sphPrtcls.pStruct().boundaries())
+{
+
+	for(uint32 i=0; i<6; i++)
+	{
+		this->set(
+			i,
+			boundarySphereInteraction<CFModel, gMModel>::create(
+				boundaries_[i],
+				sphPrtcls, 
+				geomMotion));
+	}	
+}

src/Interaction/sphereInteraction/boundaries/boundarySphereInteractionList.hpp

@@ -0,0 +1,40 @@
+#ifndef __boundarySphereInteractionList_hpp__
+#define __boundarySphereInteractionList_hpp__
+
+
+#include "boundaryList.hpp"
+#include "ListPtr.hpp"
+#include "boundarySphereInteraction.hpp"
+
+
+namespace pFlow
+{
+
+
+template<typename contactForceModel,typename geometryMotionModel>
+class boundarySphereInteractionList
+:
+    public ListPtr<boundarySphereInteraction<contactForceModel,geometryMotionModel>>
+{
+private:
+
+    const boundaryList&         boundaries_;
+
+public:
+
+    boundarySphereInteractionList(
+        const sphereParticles& sphPrtcls,
+		const geometryMotionModel& geomMotion
+    );
+
+    ~boundarySphereInteractionList()=default;
+
+};
+
+
+
+}
+
+#include "boundarySphereInteractionList.cpp"
+
+#endif //__boundarySphereInteractionList_hpp__

src/Interaction/sphereInteraction/boundaries/createBoundarySphereInteraction.hpp

@@ -0,0 +1,31 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+-----------------------------------------------------------------------------*/
+
+#include "boundarySphereInteraction.hpp"
+#include "periodicBoundarySphereInteraction.hpp"
+
+#define createBoundarySphereInteraction(ForceModel,GeomModel) 	\
+	template class pFlow::boundarySphereInteraction<			\
+	ForceModel,													\
+	GeomModel>;													\
+																\
+	template class pFlow::periodicBoundarySphereInteraction<	\
+	ForceModel,													\
+	GeomModel>;
+

src/Interaction/sphereInteraction/boundaries/periodicBoundarySphereInteraction/periodicBoundarySIKernels.hpp

@@ -0,0 +1,125 @@
+
+namespace pFlow::periodicBoundarySIKernels
+{
+
+template<typename ContactListType, typename ContactForceModel>
+void sphereSphereInteraction
+(
+    real dt,
+    const ContactListType&              cntctList,
+    const ContactForceModel&            forceModel,
+    const realx3&                       transferVec,
+    const deviceScatteredFieldAccess<realx3>& thisPoints,
+    const deviceScatteredFieldAccess<realx3>& mirrorPoints,
+    const deviceViewType1D<real>& diam,
+    const deviceViewType1D<uint32>& propId,
+    const deviceViewType1D<realx3>& vel,
+    const deviceViewType1D<realx3>& rVel,
+    const deviceViewType1D<realx3>& cForce,
+    const deviceViewType1D<realx3>& cTorque
+)
+{
+    
+    using ValueType = typename ContactListType::ValueType;
+    uint32 ss = cntctList.size();
+    uint32 lastItem = cntctList.loopCount();
+    if(lastItem == 0u)return;
+
+    Kokkos::parallel_for(
+        "pFlow::periodicBoundarySIKernels::sphereSphereInteraction",
+        deviceRPolicyDynamic(0,lastItem),
+        LAMBDA_HD(uint32 n)
+        {
+
+        if(!cntctList.isValid(n))return;
+
+            auto [i,j] = cntctList.getPair(n);
+            uint32 ind_i = thisPoints.index(i);
+            uint32 ind_j = mirrorPoints.index(j);
+
+            real Ri = 0.5*diam[ind_i];
+            real Rj = 0.5*diam[ind_j];
+            realx3 xi = thisPoints.field()[ind_i];
+            realx3 xj = mirrorPoints.field()[ind_j]+transferVec;
+            real dist = length(xj-xi);
+            real ovrlp = (Ri+Rj) - dist;
+            
+            if( ovrlp >0.0 )
+            {
+                
+                /*auto Vi = thisVel[i];
+                auto Vj = mirrorVel[j];
+                auto wi = thisRVel[i];
+                auto wj = mirrorRVel[j];
+                auto Nij = (xj-xi)/dist;
+                auto Vr = Vi - Vj + cross((Ri*wi+Rj*wj), Nij);*/
+
+                auto Nij = (xj-xi)/dist;
+                auto wi = rVel[ind_i];
+                auto wj = rVel[ind_j];
+                auto Vr = vel[ind_i] - vel[ind_j] + cross((Ri*wi+Rj*wj), Nij);
+                
+                auto history = cntctList.getValue(n);
+
+                int32 propId_i = propId[ind_i];
+                int32 propId_j = propId[ind_j];
+
+                realx3 FCn, FCt, Mri, Mrj, Mij, Mji;
+
+                // calculates contact force 
+                forceModel.contactForce(
+                    dt, i, j,
+                    propId_i, propId_j,
+                    Ri, Rj,
+                    ovrlp,
+                    Vr, Nij,
+                    history,
+                    FCn, FCt);
+
+                forceModel.rollingFriction(
+                    dt, i, j,
+                    propId_i, propId_j,
+                    Ri, Rj,
+                    wi, wj,
+                    Nij,
+                    FCn,
+                    Mri, Mrj);
+
+                auto M = cross(Nij,FCt);
+                Mij = Ri*M+Mri;
+                Mji = Rj*M+Mrj;
+                
+                auto FC = FCn + FCt;
+                
+
+                Kokkos::atomic_add(&cForce[ind_i].x_,FC.x_);
+                Kokkos::atomic_add(&cForce[ind_i].y_,FC.y_);
+                Kokkos::atomic_add(&cForce[ind_i].z_,FC.z_);
+
+                Kokkos::atomic_add(&cForce[ind_j].x_,-FC.x_);
+                Kokkos::atomic_add(&cForce[ind_j].y_,-FC.y_);
+                Kokkos::atomic_add(&cForce[ind_j].z_,-FC.z_);
+
+                Kokkos::atomic_add(&cTorque[ind_i].x_, Mij.x_);
+                Kokkos::atomic_add(&cTorque[ind_i].y_, Mij.y_);
+                Kokkos::atomic_add(&cTorque[ind_i].z_, Mij.z_);
+
+                Kokkos::atomic_add(&cTorque[ind_j].x_, Mji.x_);
+                Kokkos::atomic_add(&cTorque[ind_j].y_, Mji.y_);
+                Kokkos::atomic_add(&cTorque[ind_j].z_, Mji.z_);
+                
+
+                cntctList.setValue(n,history);
+
+            }
+            else
+            {
+                cntctList.setValue(n, ValueType());
+            }
+
+        });
+    Kokkos::fence();
+}
+
+
+} //pFlow::periodicBoundarySIKernels

src/Interaction/sphereInteraction/boundaries/periodicBoundarySphereInteraction/periodicBoundarySphereInteraction.cpp

@@ -0,0 +1,65 @@
+/*------------------------------- phasicFlow ---------------------------------
+	  O        C enter of
+	 O O       E ngineering and
+	O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions.
+
+  phasicFlow is distributed to help others in their research in the field of
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+
+#include "periodicBoundarySIKernels.hpp"
+
+template <typename cFM, typename gMM>
+pFlow::periodicBoundarySphereInteraction<cFM, gMM>::periodicBoundarySphereInteraction(
+	const boundaryBase &boundary,
+	const sphereParticles &sphPrtcls,
+	const GeometryMotionModel &geomMotion)
+	: boundarySphereInteraction<cFM,gMM>(boundary, sphPrtcls, geomMotion),
+	transferVec_(boundary.mirrorBoundary().displacementVectroToMirror())
+{
+	if(boundary.thisBoundaryIndex()%2==1)
+    {
+       masterInteraction_ = true;
+    }
+    else
+    {
+        masterInteraction_ = false;
+    }
+}
+
+template <typename cFM, typename gMM>
+bool pFlow::periodicBoundarySphereInteraction<cFM, gMM>::sphereSphereInteraction
+(
+	real dt,
+	const ContactForceModel &cfModel
+)
+{
+	if(!masterInteraction_) return true;
+	
+	pFlow::periodicBoundarySIKernels::sphereSphereInteraction(
+		dt,
+		this->ppPairs(),
+		cfModel,
+		transferVec_,
+		this->boundary().thisPoints(),
+		this->mirrorBoundary().thisPoints(),
+		this->sphParticles().diameter().deviceViewAll(),
+		this->sphParticles().propertyId().deviceViewAll(),
+		this->sphParticles().velocity().deviceViewAll(),
+		this->sphParticles().rVelocity().deviceViewAll(),
+		this->sphParticles().contactForce().deviceViewAll(),
+		this->sphParticles().contactTorque().deviceViewAll());
+
+	return true;
+}

src/Interaction/sphereInteraction/boundaries/periodicBoundarySphereInteraction/periodicBoundarySphereInteraction.hpp

@@ -0,0 +1,95 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+
+#ifndef __periodicBoundarySphereInteraction_hpp__
+#define __periodicBoundarySphereInteraction_hpp__
+
+#include "boundarySphereInteraction.hpp"
+
+namespace pFlow
+{
+
+template<typename contactForceModel,typename geometryMotionModel>
+class periodicBoundarySphereInteraction
+:
+    public boundarySphereInteraction<contactForceModel, geometryMotionModel>
+{
+public:
+
+    using PBSInteractionType = 
+        periodicBoundarySphereInteraction<contactForceModel,geometryMotionModel>;
+
+    using BSInteractionType = 
+        boundarySphereInteraction<contactForceModel, geometryMotionModel>;
+
+    using GeometryMotionModel 	= typename BSInteractionType::GeometryMotionModel;
+	
+	using ContactForceModel 	= typename BSInteractionType::ContactForceModel;
+
+	using MotionModel 			= typename geometryMotionModel::MotionModel;
+
+	using ModelStorage 			= typename ContactForceModel::contactForceStorage;
+	
+	using IdType 			    = typename BSInteractionType::IdType;
+
+	using IndexType    		    = typename BSInteractionType::IndexType;
+    
+    using ContactListType       = typename BSInteractionType::ContactListType; 
+
+private:
+
+    realx3  transferVec_;
+    
+    bool    masterInteraction_;
+public:
+
+    TypeInfoTemplate22("boundarySphereInteraction", "periodic",ContactForceModel, MotionModel);
+
+	
+    periodicBoundarySphereInteraction(
+        const boundaryBase& boundary,
+		const sphereParticles& sphPrtcls,
+		const GeometryMotionModel& geomMotion
+    );
+
+    add_vCtor
+    (
+        BSInteractionType,
+        PBSInteractionType,
+        boundaryBase
+    );
+    
+    ~periodicBoundarySphereInteraction()override = default;
+
+
+    
+
+    bool sphereSphereInteraction(
+        real dt,
+		const ContactForceModel& cfModel)override;
+	
+};
+
+}
+
+#include "periodicBoundarySphereInteraction.cpp"
+
+
+#endif //__periodicBoundarySphereInteraction_hpp__

src/Interaction/sphereInteraction/sphereInteraction/sphereInteraction.cpp

@@ -35,9 +35,18 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::createSphereInteraction()
 
 	uint32 nPrtcl = sphParticles_.size();
 
+	contactSearch_ = contactSearch::create(
+	subDict("contactSearch"),
+	sphParticles_.extendedDomain().domainBox(),
+	sphParticles_,
+	geometryMotion_,
+	timers());
+
 	ppContactList_ = makeUnique<ContactListType>(nPrtcl+1);
 	
-	pwContactList_ = makeUnique<ContactListType>(nPrtcl/4+1);
+	pwContactList_ = makeUnique<ContactListType>(nPrtcl/5+1);
+
+	
 
 	return true;
 }
@@ -127,19 +136,13 @@ pFlow::sphereInteraction<cFM,gMM, cLT>::sphereInteraction
 	interaction(control, prtcl, geom),
 	geometryMotion_(dynamic_cast<const GeometryMotionModel&>(geom)),
 	sphParticles_(dynamic_cast<const sphereParticles&>(prtcl)),
+	boundaryInteraction_(sphParticles_,geometryMotion_),
 	ppInteractionTimer_("sphere-sphere interaction", &this->timers()),
 	pwInteractionTimer_("sphere-wall interaction", &this->timers()),
-	contactListTimer_("contact list management", &this->timers()),
-	contactListTimer0_("contact list clear", &this->timers())
+	contactListMangementTimer_("contact-list management", &this->timers()),
+	boundaryInteractionTimer_("interaction for boundary", &this->timers())
 {
-	contactSearch_ = contactSearch::create(
-	subDict("contactSearch"),
-	prtcl.extendedDomain().domainBox(),
-	prtcl,
-	geom,
-	timers());
-
-
+	
 	if(!createSphereInteraction())
 	{
 		fatalExit;
@@ -163,14 +166,20 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::iterate()
 	//output<<"iter, t, dt "<< iter<<" "<< t << " "<<dt<<endl;
 	bool broadSearch = contactSearch_().enterBroadSearch(iter, t, dt);
 
-
+	
 	if(broadSearch)
 	{
-		contactListTimer0_.start();
+		contactListMangementTimer_.start();
 		ppContactList_().beforeBroadSearch();
 		pwContactList_().beforeBroadSearch();
-		contactListTimer0_.end();
+		contactListMangementTimer_.pause();
 	} 
+
+	for(uint32 i=0; i<6u; i++)
+	{
+		boundaryInteraction_[i].ppPairs().beforeBroadSearch();
+		boundaryInteraction_[i].pwPairs().beforeBroadSearch();
+	}
 	
 	if( sphParticles_.numActive()<=0)return true;
 	
@@ -187,14 +196,34 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::iterate()
 		fatalExit;
 	}
 	
-
+	for(uint32 i=0; i<6u; i++)
+	{
+		if( !contactSearch_().boundaryBroadSearch(
+			i,
+			iter,
+			t,
+			dt,
+			boundaryInteraction_[i].ppPairs(),
+			boundaryInteraction_[i].pwPairs()))
+		{
+			fatalErrorInFunction<<
+			"failed to perform broadSearch for boundary index "<<i<<endl;
+			return false;
+		}
+	}
 	
 	if(broadSearch && contactSearch_().performedBroadSearch())
 	{
-		contactListTimer_.start();
+		contactListMangementTimer_.resume();
 		ppContactList_().afterBroadSearch();
 		pwContactList_().afterBroadSearch();
-		contactListTimer_.end();
+		contactListMangementTimer_.end();
+	}
+
+	for(uint32 i=0; i<6u; i++)
+	{
+		boundaryInteraction_[i].ppPairs().afterBroadSearch();
+		boundaryInteraction_[i].pwPairs().afterBroadSearch();
 	}
 	
 	ppInteractionTimer_.start();
@@ -206,7 +235,14 @@ bool pFlow::sphereInteraction<cFM,gMM, cLT>::iterate()
 		sphereWallInteraction();
 	pwInteractionTimer_.end();
 
-	
+	boundaryInteractionTimer_.start();
+	for(uint32 i=0; i<6u; i++)
+	{
+		boundaryInteraction_[i].sphereSphereInteraction(
+			dt, 
+			this->forceModel_());
+	}
+	boundaryInteractionTimer_.end();
 	return true;
 }
 

src/Interaction/sphereInteraction/sphereInteraction/sphereInteraction.hpp

@@ -23,7 +23,11 @@ Licence:
 
 #include "interaction.hpp"
 #include "sphereParticles.hpp"
+#include "boundarySphereInteractionList.hpp"
 #include "sphereInteractionKernels.hpp"
+//#include "unsortedContactList.hpp"
+
+
 
 namespace pFlow
 {
@@ -45,6 +49,8 @@ public:
 	using MotionModel 			= typename geometryMotionModel::MotionModel;
 
 	using ModelStorage 			= typename ContactForceModel::contactForceStorage;
+
+	using BoundaryListType 		= boundarySphereInteractionList<ContactForceModel,GeometryMotionModel>;
 	
 	using IdType 			= uint32;
 
@@ -53,6 +59,9 @@ public:
 	using ContactListType 	= 
 			contactListType<ModelStorage, DefaultExecutionSpace, IdType>;
 
+	//using BoundaryContactListType = unsortedContactList<ModelStorage, DefaultExecutionSpace, IdType>;
+	
+
 
 private:
 	
@@ -62,6 +71,9 @@ private:
 	/// const reference to particles 
 	const sphereParticles& 				sphParticles_;
 
+	/// particle-particle and particle-wall interactions at boundaries 
+	BoundaryListType 					boundaryInteraction_;	
+
 	/// contact search object for pp and pw interactions 
 	uniquePtr<contactSearch> 			contactSearch_ = nullptr;
 
@@ -72,7 +84,8 @@ private:
 	uniquePtr<ContactListType> 			ppContactList_ = nullptr;
 
 	/// contact list for particle-wall interactions (keeps the history)
-	uniquePtr<ContactListType> 			pwContactList_ = nullptr;	
+	uniquePtr<ContactListType> 			pwContactList_ = nullptr;
+
 
 	/// timer for particle-particle interaction computations
 	Timer 		ppInteractionTimer_;
@@ -80,9 +93,13 @@ private:
 	/// timer for particle-wall interaction computations
 	Timer       pwInteractionTimer_;
 
-	Timer 		contactListTimer_;
+	/// timer for managing contact lists (only inernal points)
+	Timer 		contactListMangementTimer_;
 
-	Timer 		contactListTimer0_;
+	/// timer for boundary interaction time 
+	Timer 		boundaryInteractionTimer_;
+
+	
 
 	bool createSphereInteraction();
 

src/Interaction/sphereInteraction/sphereInteractions.cpp

@@ -1,277 +0,0 @@
-/*------------------------------- phasicFlow ---------------------------------
-      O        C enter of
-     O O       E ngineering and
-    O   O      M ultiscale modeling of
-   OOOOOOO     F luid flow       
-------------------------------------------------------------------------------
-  Copyright (C): www.cemf.ir
-  email: hamid.r.norouzi AT gmail.com
-------------------------------------------------------------------------------  
-Licence:
-  This file is part of phasicFlow code. It is a free software for simulating 
-  granular and multiphase flows. You can redistribute it and/or modify it under
-  the terms of GNU General Public License v3 or any other later versions. 
- 
-  phasicFlow is distributed to help others in their research in the field of 
-  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-
------------------------------------------------------------------------------*/
-
-#include "sphereInteraction.hpp"
-
-#include "geometryMotions.hpp"
-
-#include "contactForceModels.hpp"
-#include "unsortedContactList.hpp"
-#include "sortedContactList.hpp"
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedLinearNormalRolling,
-	pFlow::stationaryGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedLinearNormalRolling,
-	pFlow::stationaryGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedLinearNormalRolling,
-	pFlow::stationaryGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedLinearNormalRolling,
-	pFlow::stationaryGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedLinearNormalRolling,
-	pFlow::rotationAxisMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedLinearNormalRolling,
-	pFlow::rotationAxisMotionGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedLinearNormalRolling,
-	pFlow::rotationAxisMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedLinearNormalRolling,
-	pFlow::rotationAxisMotionGeometry,
-	pFlow::sortedContactList>;
-
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedLinearNormalRolling,
-	pFlow::vibratingMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedLinearNormalRolling,
-	pFlow::vibratingMotionGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedLinearNormalRolling,
-	pFlow::vibratingMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedLinearNormalRolling,
-	pFlow::vibratingMotionGeometry,
-	pFlow::sortedContactList>;
-
-
-/*template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedLinearNormalRolling,
-	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedLinearNormalRolling,
-	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedLinearNormalRolling,
-	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedLinearNormalRolling,
-	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::sortedContactList>;*/
-
-/// non-linear models 
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearNormalRolling,
-	pFlow::stationaryGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearNormalRolling,
-	pFlow::stationaryGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearNormalRolling,
-	pFlow::stationaryGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearNormalRolling,
-	pFlow::stationaryGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearNormalRolling,
-	pFlow::rotationAxisMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearNormalRolling,
-	pFlow::rotationAxisMotionGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearNormalRolling,
-	pFlow::rotationAxisMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearNormalRolling,
-	pFlow::rotationAxisMotionGeometry,
-	pFlow::sortedContactList>;
-
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearNormalRolling,
-	pFlow::vibratingMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearNormalRolling,
-	pFlow::vibratingMotionGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearNormalRolling,
-	pFlow::vibratingMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearNormalRolling,
-	pFlow::vibratingMotionGeometry,
-	pFlow::sortedContactList>;
-
-/*template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearNormalRolling,
-	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearNormalRolling,
-	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearNormalRolling,
-	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearNormalRolling,
-	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::sortedContactList>;*/
-
-
-// - nonLinearMod models
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearModNormalRolling,
-	pFlow::stationaryGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearModNormalRolling,
-	pFlow::stationaryGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearModNormalRolling,
-	pFlow::stationaryGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearModNormalRolling,
-	pFlow::stationaryGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearModNormalRolling,
-	pFlow::rotationAxisMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearModNormalRolling,
-	pFlow::rotationAxisMotionGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearModNormalRolling,
-	pFlow::rotationAxisMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearModNormalRolling,
-	pFlow::rotationAxisMotionGeometry,
-	pFlow::sortedContactList>;
-
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearModNormalRolling,
-	pFlow::vibratingMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearModNormalRolling,
-	pFlow::vibratingMotionGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearModNormalRolling,
-	pFlow::vibratingMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearModNormalRolling,
-	pFlow::vibratingMotionGeometry,
-	pFlow::sortedContactList>;
-
-
-/*template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearModNormalRolling,
-	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::limitedNonLinearModNormalRolling,
-	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::sortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearModNormalRolling,
-	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::unsortedContactList>;
-
-template class pFlow::sphereInteraction<
-	pFlow::cfModels::nonLimitedNonLinearModNormalRolling,
-	pFlow::multiRotationAxisMotionGeometry,
-	pFlow::sortedContactList>;
-*/

src/Interaction/sphereInteraction/sphereInteractionsLinearModels.cpp

@@ -0,0 +1,59 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+
+#include "sphereInteraction.hpp"
+#include "geometryMotions.hpp"
+#include "contactForceModels.hpp"
+#include "unsortedContactList.hpp"
+#include "sortedContactList.hpp"
+#include "createBoundarySphereInteraction.hpp"
+
+
+
+#define createInteraction(ForceModel,GeomModel) 	\
+													\
+	template class pFlow::sphereInteraction< 		\
+		ForceModel,									\
+		GeomModel,									\
+		pFlow::unsortedContactList>;				\
+													\
+	template class pFlow::sphereInteraction< 		\
+		ForceModel,									\
+		GeomModel,									\
+		pFlow::sortedContactList>;					\
+	createBoundarySphereInteraction(ForceModel, GeomModel)
+
+
+// stationaryGeometry
+createInteraction(pFlow::cfModels::limitedLinearNormalRolling, pFlow::stationaryGeometry);
+createInteraction(pFlow::cfModels::nonLimitedLinearNormalRolling,pFlow::stationaryGeometry);
+
+// rotationAxisMotionGeometry
+createInteraction(pFlow::cfModels::limitedLinearNormalRolling, pFlow::rotationAxisMotionGeometry);
+createInteraction(pFlow::cfModels::nonLimitedLinearNormalRolling,pFlow::rotationAxisMotionGeometry);
+
+// vibratingMotionGeometry
+createInteraction(pFlow::cfModels::limitedLinearNormalRolling, pFlow::vibratingMotionGeometry);
+createInteraction(pFlow::cfModels::nonLimitedLinearNormalRolling,pFlow::vibratingMotionGeometry);
+
+// multiRotationAxisMotionGeometry
+//createInteraction(pFlow::cfModels::limitedLinearNormalRolling, pFlow::multiRotationAxisMotionGeometry);
+//createInteraction(pFlow::cfModels::nonLimitedLinearNormalRolling,pFlow::multiRotationAxisMotionGeometry);
+

src/Interaction/sphereInteraction/sphereInteractionsNonLinearModModels.cpp

@@ -0,0 +1,58 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+
+#include "sphereInteraction.hpp"
+#include "geometryMotions.hpp"
+#include "contactForceModels.hpp"
+#include "unsortedContactList.hpp"
+#include "sortedContactList.hpp"
+#include "createBoundarySphereInteraction.hpp"
+
+
+
+#define createInteraction(ForceModel,GeomModel) 	\
+													\
+	template class pFlow::sphereInteraction< 		\
+		ForceModel,									\
+		GeomModel,									\
+		pFlow::unsortedContactList>;				\
+													\
+	template class pFlow::sphereInteraction< 		\
+		ForceModel,									\
+		GeomModel,									\
+		pFlow::sortedContactList>;					\
+	createBoundarySphereInteraction(ForceModel, GeomModel)
+
+
+// stationaryGeometry
+createInteraction(pFlow::cfModels::limitedNonLinearModNormalRolling, pFlow::stationaryGeometry);
+createInteraction(pFlow::cfModels::nonLimitedNonLinearModNormalRolling,pFlow::stationaryGeometry);
+
+// rotationAxisMotionGeometry
+createInteraction(pFlow::cfModels::limitedNonLinearModNormalRolling, pFlow::rotationAxisMotionGeometry);
+createInteraction(pFlow::cfModels::nonLimitedNonLinearModNormalRolling,pFlow::rotationAxisMotionGeometry);
+
+// vibratingMotionGeometry
+createInteraction(pFlow::cfModels::limitedNonLinearModNormalRolling, pFlow::vibratingMotionGeometry);
+createInteraction(pFlow::cfModels::nonLimitedNonLinearModNormalRolling,pFlow::vibratingMotionGeometry);
+
+// multiRotationAxisMotionGeometry
+//createInteraction(pFlow::cfModels::limitedNonLinearModNormalRolling, pFlow::multiRotationAxisMotionGeometry);
+//createInteraction(pFlow::cfModels::nonLimitedNonLinearModNormalRolling,pFlow::multiRotationAxisMotionGeometry);

src/Interaction/sphereInteraction/sphereInteractionsNonLinearModels.cpp

@@ -0,0 +1,58 @@
+/*------------------------------- phasicFlow ---------------------------------
+      O        C enter of
+     O O       E ngineering and
+    O   O      M ultiscale modeling of
+   OOOOOOO     F luid flow       
+------------------------------------------------------------------------------
+  Copyright (C): www.cemf.ir
+  email: hamid.r.norouzi AT gmail.com
+------------------------------------------------------------------------------  
+Licence:
+  This file is part of phasicFlow code. It is a free software for simulating 
+  granular and multiphase flows. You can redistribute it and/or modify it under
+  the terms of GNU General Public License v3 or any other later versions. 
+ 
+  phasicFlow is distributed to help others in their research in the field of 
+  granular and multiphase flows, but WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+-----------------------------------------------------------------------------*/
+
+#include "sphereInteraction.hpp"
+#include "geometryMotions.hpp"
+#include "contactForceModels.hpp"
+#include "unsortedContactList.hpp"
+#include "sortedContactList.hpp"
+#include "createBoundarySphereInteraction.hpp"
+
+
+
+#define createInteraction(ForceModel,GeomModel) 	\
+													\
+	template class pFlow::sphereInteraction< 		\
+		ForceModel,									\
+		GeomModel,									\
+		pFlow::unsortedContactList>;				\
+													\
+	template class pFlow::sphereInteraction< 		\
+		ForceModel,									\
+		GeomModel,									\
+		pFlow::sortedContactList>;					\
+	createBoundarySphereInteraction(ForceModel, GeomModel)
+
+
+// stationaryGeometry
+createInteraction(pFlow::cfModels::limitedNonLinearNormalRolling, pFlow::stationaryGeometry);
+createInteraction(pFlow::cfModels::nonLimitedNonLinearNormalRolling,pFlow::stationaryGeometry);
+
+// rotationAxisMotionGeometry
+createInteraction(pFlow::cfModels::limitedNonLinearNormalRolling, pFlow::rotationAxisMotionGeometry);
+createInteraction(pFlow::cfModels::nonLimitedNonLinearNormalRolling,pFlow::rotationAxisMotionGeometry);
+
+// vibratingMotionGeometry
+createInteraction(pFlow::cfModels::limitedNonLinearNormalRolling, pFlow::vibratingMotionGeometry);
+createInteraction(pFlow::cfModels::nonLimitedNonLinearNormalRolling,pFlow::vibratingMotionGeometry);
+
+// multiRotationAxisMotionGeometry
+//createInteraction(pFlow::cfModels::limitedNonLinearNormalRolling, pFlow::multiRotationAxisMotionGeometry);
+//createInteraction(pFlow::cfModels::nonLimitedNonLinearNormalRolling,pFlow::multiRotationAxisMotionGeometry);