doc/html updated for integration

.github/scripts/sync-wiki.py

@@ -1,153 +0,0 @@
-#!/usr/bin/env python3
-
-import os
-import re
-import yaml
-import sys
-
-# Constants
-REPO_URL = "https://github.com/PhasicFlow/phasicFlow"
-REPO_PATH = os.path.join(os.environ.get("GITHUB_WORKSPACE", ""), "repo")
-WIKI_PATH = os.path.join(os.environ.get("GITHUB_WORKSPACE", ""), "wiki")
-MAPPING_FILE = os.path.join(REPO_PATH, "doc/mdDocs/markdownList.yml")
-
-def load_mapping():
-    """Load the markdown to wiki page mapping file."""
-    try:
-        with open(MAPPING_FILE, 'r') as f:
-            data = yaml.safe_load(f)
-            return data.get('mappings', [])
-    except Exception as e:
-        print(f"Error loading mapping file: {e}")
-        return []
-
-def convert_relative_links(content, source_path):
-    """Convert relative links in markdown content to absolute URLs."""
-    # Find markdown links with regex pattern [text](url)
-    md_pattern = r'\[([^\]]+)\]\(([^)]+)\)'
-    
-    # Find HTML img tags
-    img_pattern = r'<img\s+src=[\'"]([^\'"]+)[\'"]'
-    
-    def replace_link(match):
-        link_text = match.group(1)
-        link_url = match.group(2)
-        
-        # Skip if already absolute URL or anchor
-        if link_url.startswith(('http://', 'https://', '#', 'mailto:')):
-            return match.group(0)
-        
-        # Get the directory of the source file
-        source_dir = os.path.dirname(source_path)
-        
-        # Create absolute path from repository root
-        if link_url.startswith('/'):
-            # If link starts with /, it's already relative to repo root
-            abs_path = link_url
-        else:
-            # Otherwise, it's relative to the file location
-            abs_path = os.path.normpath(os.path.join(source_dir, link_url))
-            if not abs_path.startswith('/'):
-                abs_path = '/' + abs_path
-        
-        # Convert to GitHub URL
-        github_url = f"{REPO_URL}/blob/main{abs_path}"
-        return f"[{link_text}]({github_url})"
-    
-    def replace_img_src(match):
-        img_src = match.group(1)
-        
-        # Skip if already absolute URL
-        if img_src.startswith(('http://', 'https://')):
-            return match.group(0)
-        
-        # Get the directory of the source file
-        source_dir = os.path.dirname(source_path)
-        
-        # Create absolute path from repository root
-        if img_src.startswith('/'):
-            # If link starts with /, it's already relative to repo root
-            abs_path = img_src
-        else:
-            # Otherwise, it's relative to the file location
-            abs_path = os.path.normpath(os.path.join(source_dir, img_src))
-            if not abs_path.startswith('/'):
-                abs_path = '/' + abs_path
-        
-        # Convert to GitHub URL (use raw URL for images)
-        github_url = f"{REPO_URL}/raw/main{abs_path}"
-        return f'<img src="{github_url}"'
-    
-    # Replace all markdown links
-    content = re.sub(md_pattern, replace_link, content)
-    
-    # Replace all img src tags
-    content = re.sub(img_pattern, replace_img_src, content)
-    
-    return content
-
-def process_file(source_file, target_wiki_page):
-    """Process a markdown file and copy its contents to a wiki page."""
-    source_path = os.path.join(REPO_PATH, source_file)
-    target_path = os.path.join(WIKI_PATH, f"{target_wiki_page}.md")
-    
-    print(f"Processing {source_path} -> {target_path}")
-    
-    try:
-        # Check if source exists
-        if not os.path.exists(source_path):
-            print(f"Source file not found: {source_path}")
-            return False
-        
-        # Read source content
-        with open(source_path, 'r') as f:
-            content = f.read()
-        
-        # Convert relative links
-        content = convert_relative_links(content, source_file)
-        
-        # Write to wiki page
-        with open(target_path, 'w') as f:
-            f.write(content)
-        
-        return True
-    
-    except Exception as e:
-        print(f"Error processing {source_file}: {e}")
-        return False
-
-def main():
-    # Check if wiki directory exists
-    if not os.path.exists(WIKI_PATH):
-        print(f"Wiki path not found: {WIKI_PATH}")
-        sys.exit(1)
-    
-    # Load mapping
-    mappings = load_mapping()
-    if not mappings:
-        print("No mappings found in the mapping file")
-        sys.exit(1)
-    
-    print(f"Found {len(mappings)} mappings to process")
-    
-    # Process each mapping
-    success_count = 0
-    for mapping in mappings:
-        source = mapping.get('source')
-        target = mapping.get('target')
-        
-        if not source or not target:
-            print(f"Invalid mapping: {mapping}")
-            continue
-        
-        if process_file(source, target):
-            success_count += 1
-    
-    print(f"Successfully processed {success_count} of {len(mappings)} files")
-    
-    # Exit with error if any file failed
-    if success_count < len(mappings):
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()

.github/workflows/sync-wiki.yml

@@ -1,60 +0,0 @@
-name: Sync-Wiki
-
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - "**/*.md"
-      - ".github/workflows/sync-wiki.yml"
-      - "doc/mdDocs/markdownList.yml"
-      - ".github/scripts/sync-wiki.py"
-  workflow_dispatch:
-
-jobs:
-  sync-wiki:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v3
-        with:
-          path: repo
-      - name: Checkout Wiki
-        uses: actions/checkout@v3
-        with:
-          repository: ${{ github.repository }}.wiki
-          path: wiki
-        continue-on-error: true
-      - name: Create Wiki Directory if Not Exists
-        run: |
-          if [ ! -d "wiki" ]; then
-            mkdir -p wiki
-            cd wiki
-            git init
-            git config user.name "${{ github.actor }}"
-            git config user.email "${{ github.actor }}@users.noreply.github.com"
-            git remote add origin "https://github.com/${{ github.repository }}.wiki.git"
-          fi
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: '3.10'
-      - name: Install dependencies
-        run: pip install pyyaml
-      - name: Sync markdown files to Wiki
-        run: |
-          python $GITHUB_WORKSPACE/repo/.github/scripts/sync-wiki.py
-        env:
-          GITHUB_REPOSITORY: ${{ github.repository }}
-      - name: Push changes to wiki
-        run: |
-          cd wiki
-          git config user.name "${{ github.actor }}"
-          git config user.email "${{ github.actor }}@users.noreply.github.com"
-          git add .
-          if git status --porcelain | grep .; then
-            git commit -m "Auto sync wiki from main repository"
-            git push --set-upstream https://${{ github.actor }}:${{ github.token }}@github.com/${{ github.repository }}.wiki.git master -f
-          else
-            echo "No changes to commit"
-          fi

.gitignore

@@ -1,12 +1,6 @@
-# files 
-.clang-format
-.vscode
-.dependencygraph
-
 # Prerequisites
 *.d
 
-
 # Compiled Object files
 *.slo
 *.lo
@@ -37,18 +31,13 @@
 *.out
 *.app
 
-# Exclude specific directories wherever they appear
+# directories
 build/**
 include/**
 bin/**
 lib/**
-**/build/
-**/include/
-**/bin/
-**/lib/
 test*/**
 **/**notnow
-doc/code-documentation/
 doc/DTAGS
 # all possible time folders
 **/[0-9]
@@ -65,5 +54,3 @@ doc/DTAGS
 **/[0-9]*.[0-9][0-9][0-9][0-9][0-9][0-9][0-9]
 **/[0-9]*.[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]
 **/VTK
-
-

CMakeLists.txt

@@ -1,64 +1,75 @@
 cmake_minimum_required(VERSION 3.16 FATAL_ERROR)
 
 # set the project name and version
-project(phasicFlow VERSION 1.0 )
+project(phasicFlow VERSION 0.1 )
 
-set(CMAKE_CXX_STANDARD 20 CACHE STRING "" FORCE)
+set(CMAKE_CXX_STANDARD 17 CACHE STRING "" FORCE)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_INSTALL_PREFIX ${phasicFlow_SOURCE_DIR} CACHE PATH "Install path of phasicFlow" FORCE)
-set(CMAKE_BUILD_TYPE Release CACHE STRING "build type")
-set(BUILD_SHARED_LIBS ON CACHE BOOL "Build using shared libraries" FORCE)
+set(CMAKE_BUILD_TYPE Release CACHE STRING "build type" FORCE)
+
+message(STATUS ${CMAKE_INSTALL_PREFIX})
+
+mark_as_advanced(FORCE var Kokkos_ENABLE_CUDA_LAMBDA)
+mark_as_advanced(FORCE var Kokkos_ENABLE_OPENMP)
+mark_as_advanced(FORCE var Kokkos_ENABLE_SERIAL)
+mark_as_advanced(FORCE var Kokkos_ENABLE_CUDA_LAMBDA)
 mark_as_advanced(FORCE var BUILD_SHARED_LIBS)
 
-message(STATUS "Install prefix is:" ${CMAKE_INSTALL_PREFIX})
-
-include(cmake/globals.cmake)
-
-option(pFlow_STD_Parallel_Alg "Use TTB std parallel algorithms" ON)
+option(USE_STD_PARALLEL_ALG "Use TTB std parallel algorithms" ON)
 option(pFlow_Build_Serial "Build phasicFlow and backends for serial execution" OFF)
 option(pFlow_Build_OpenMP "Build phasicFlow and backends for OpenMP execution" OFF)
 option(pFlow_Build_Cuda   "Build phasicFlow and backends for Cuda execution" OFF)
-option(pFlow_Build_Double "Build phasicFlow with double precision floating-oint variables" ON)
-option(pFlow_Build_MPI    "Build for MPI parallelization. This will enable multi-gpu run, CPU run on clusters (distributed memory machine). Use this combination Cuda+MPI, OpenMP + MPI or Serial+MPI " OFF)
+option(pFlow_Build_Double "Build phasicFlow with double precision variables" ON)
 
-#for installing the required packages
-include(cmake/preReq.cmake)
+set(BUILD_SHARED_LIBS ON CACHE BOOL "Build using shared libraries" FORCE)
 
 if(pFlow_Build_Serial)
 	set(Kokkos_ENABLE_SERIAL ON CACHE BOOL "Serial execution" FORCE) 
 	set(Kokkos_ENABLE_OPENMP OFF CACHE BOOL "OpenMP execution" FORCE)
 	set(Kokkos_ENABLE_CUDA OFF CACHE BOOL "Cuda execution" FORCE)
 	set(Kokkos_ENABLE_CUDA_LAMBDA OFF CACHE BOOL "Cuda execution" FORCE)
-	set(Kokkos_ENABLE_CUDA_CONSTEXPR OFF CACHE BOOL "Enable constexpr on cuda code" FORCE)
 elseif(pFlow_Build_OpenMP )
 	set(Kokkos_ENABLE_SERIAL ON CACHE BOOL "Serial execution" FORCE) 
 	set(Kokkos_ENABLE_OPENMP ON CACHE BOOL "OpenMP execution" FORCE)
 	set(Kokkos_ENABLE_CUDA OFF CACHE BOOL "Cuda execution" FORCE)
 	set(Kokkos_ENABLE_CUDA_LAMBDA OFF CACHE BOOL "Cuda execution" FORCE)
-	set(Kokkos_DEFAULT_HOST_PARALLEL_EXECUTION_SPACE Serial CACHE STRING "" FORCE)
-	set(Kokkos_DEFAULT_DEVICE_PARALLEL_EXECUTION_SPACE OpenMP CACHE STRING "" FORCE)
-	set(Kokkos_ENABLE_CUDA_CONSTEXPR OFF CACHE BOOL "Enable constexpr on cuda code" FORCE)
+	set(Kokkos_DEFAULT_HOST_PARALLEL_EXECUTION_SPACE SERIAL CACHE STRING "" FORCE)
 elseif(pFlow_Build_Cuda)
 	set(Kokkos_ENABLE_SERIAL ON CACHE BOOL "Serial execution" FORCE) 
 	set(Kokkos_ENABLE_OPENMP OFF CACHE BOOL "OpenMP execution" FORCE)
 	set(Kokkos_ENABLE_CUDA ON CACHE BOOL "Cuda execution" FORCE)
 	set(Kokkos_ENABLE_CUDA_LAMBDA ON CACHE BOOL "Cuda execution" FORCE)
-	set(Kokkos_ENABLE_CUDA_CONSTEXPR ON CACHE BOOL "Enable constexpr on cuda code" FORCE)
 endif()
 
-if(pFlow_Build_MPI)
-	find_package(MPI REQUIRED)
-endif()
+
+
+include(cmake/globals.cmake)
+message(STATUS "Valid file extensions are ${validFiles}")
 
 include(cmake/makeLibraryGlobals.cmake)
 include(cmake/makeExecutableGlobals.cmake)
 
 configure_file(phasicFlowConfig.H.in phasicFlowConfig.H)
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 #add a global include directory 
 include_directories(src/setHelpers src/demComponent "${PROJECT_BINARY_DIR}")
 
+#main subdirectories of the code 
+set(Kokkos_Source_DIR)
+
+if(DEFINED ENV{Kokkos_DIR})
+   set(Kokkos_Source_DIR $ENV{Kokkos_DIR})
+#  add_subdirectory($ENV{Kokkos_DIR} ${phasicFlow_BINARY_DIR}/kokkos)
+#  message(STATUS "Kokkos directory is $ENV{Kokkos_DIR}")
+else()
+#  add_subdirectory($ENV{HOME}/Kokkos/kokkos ${phasicFlow_BINARY_DIR}/kokkos)
+  set(Kokkos_Source_DIR $ENV{HOME}/Kokkos/kokkos)
+endif()
+
+message(STATUS "Kokkos source directory is ${Kokkos_Source_DIR}")
+add_subdirectory(${Kokkos_Source_DIR} ${phasicFlow_BINARY_DIR}/kokkos)
+
 add_subdirectory(src)
 
 add_subdirectory(solvers)
@@ -66,9 +77,12 @@ add_subdirectory(solvers)
 add_subdirectory(utilities)
 
 add_subdirectory(DEMSystems)
+#add_subdirectory(testIO)
+
 
 install(FILES "${PROJECT_BINARY_DIR}/phasicFlowConfig.H"
-  DESTINATION include)
+  DESTINATION include
+)
 
 include(InstallRequiredSystemLibraries)
 set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")

DEMSystems/CMakeLists.txt

@@ -1,11 +1,9 @@
 
 set(SourceFiles 
-domainDistribute/domainDistribute.cpp
 DEMSystem/DEMSystem.cpp
-sphereDEMSystem/sphereFluidParticles.cpp
 sphereDEMSystem/sphereDEMSystem.cpp
-grainDEMSystem/grainFluidParticles.cpp
-grainDEMSystem/grainDEMSystem.cpp
+sphereDEMSystem/sphereFluidParticles.cpp
+domainDistribute/domainDistribute.cpp
 )
 
 set(link_libs Kokkos::kokkos phasicFlow Particles Geometry Property Interaction Interaction Utilities)

DEMSystems/DEMSystem/DEMSystem.cpp

@@ -33,14 +33,14 @@ pFlow::DEMSystem::DEMSystem(
 	ControlDict_()
 {
   
-	REPORT(0)<<"Initializing host/device execution spaces . . . \n";
-	REPORT(1)<<"Host execution space is "<< Green_Text(DefaultHostExecutionSpace::name())<<END_REPORT;
-	REPORT(1)<<"Device execution space is "<<Green_Text(DefaultExecutionSpace::name())<<END_REPORT;
+  REPORT(0)<<"Initializing host/device execution spaces . . . \n";
+	REPORT(1)<<"Host execution space is "<< greenText(DefaultHostExecutionSpace::name())<<endREPORT;
+	REPORT(1)<<"Device execution space is "<<greenText(DefaultExecutionSpace::name())<<endREPORT;
 
  	// initialize Kokkos
 	Kokkos::initialize( argc, argv ); 
 
-	REPORT(0)<<"\nCreating Control repository . . ."<<END_REPORT;
+	REPORT(0)<<"\nCreating Control repository . . ."<<endREPORT;
 	Control_ = makeUnique<systemControl>(
 		ControlDict_.startTime(),
 		ControlDict_.endTime(),
@@ -66,13 +66,12 @@ pFlow::uniquePtr<pFlow::DEMSystem>
 		word  demSystemName,
 		const std::vector<box>& domains, 
 		int argc, 
-		char* argv[],
-		bool requireRVel
+		char* argv[]
 		)
 {
 	if( wordvCtorSelector_.search(demSystemName) )
 	{
-		return wordvCtorSelector_[demSystemName] (demSystemName, domains, argc, argv, requireRVel);
+		return wordvCtorSelector_[demSystemName] (demSystemName, domains, argc, argv);
 	}
 	else
 	{
@@ -88,3 +87,4 @@ pFlow::uniquePtr<pFlow::DEMSystem>
 
 	return nullptr;
 }
+

DEMSystems/DEMSystem/DEMSystem.hpp

@@ -25,7 +25,6 @@ Licence:
 
 #include "types.hpp"
 #include "span.hpp"
-#include "box.hpp"
 #include "virtualConstructor.hpp"
 #include "uniquePtr.hpp"
 #include "systemControl.hpp"
@@ -61,7 +60,6 @@ public:
 
 	DEMSystem(const DEMSystem&)=delete;
 
-	/// @brief no assignment 
 	DEMSystem& operator = (const DEMSystem&)=delete;
 
 	create_vCtor(
@@ -71,15 +69,13 @@ public:
 			word  demSystemName,
 			const std::vector<box>& domains, 
 			int argc, 
-			char* argv[],
-			bool requireRVel
+			char* argv[]
 		),
 		(
 			demSystemName,
 			domains, 
 			argc, 
-			argv,
-			requireRVel
+			argv
 		));
 
 	realx3 g()const
@@ -98,7 +94,7 @@ public:
 		return Control_();
 	}
 
-	auto inline constexpr usingDouble()const
+	auto inline constexpr usingDoulle()const
 	{
 		return pFlow::usingDouble__;
 	}
@@ -115,37 +111,19 @@ public:
 	int32 numParInDomain(int32 di)const = 0;
 	
 	virtual
-	std::vector<int32> numParInDomains()const = 0;
+	std::vector<int32> numParInDomain()const = 0;
 
 	virtual 
-	span<const int32> parIndexInDomain(int32 domIndx)const = 0;
+	span<const int32> parIndexInDomain(int32 di)const = 0;
 
 	virtual
-	span<real> diameter() = 0;
-	
-	virtual 
-	span<uint32> particleId() = 0;
-
-	virtual 
-	span<real> courseGrainFactor() = 0;
+	span<real> parDiameter() = 0; 
 
 	virtual
-	span<realx3> acceleration()=0;
+	span<realx3> parVelocity() = 0;
 
 	virtual
-	span<realx3> velocity() = 0;
-
-	virtual
-	span<realx3> position() = 0;
-
-	virtual
-	span<realx3> rAcceleration()=0;
-
-	virtual
-	span<realx3> rVelocity() = 0;
-
-	virtual
-	span<realx3> rPosition() = 0;
+	span<realx3> parPosition() = 0;
 
 	virtual
 	span<realx3> parFluidForce() = 0;
@@ -175,18 +153,20 @@ public:
 	bool iterate(real upToTime) = 0;
 	
 	
+
 	static 
 	uniquePtr<DEMSystem>
 		create(
 			word  demSystemName,
 			const std::vector<box>& domains, 
 			int argc, 
-			char* argv[],
-			bool requireRVel=false);
+			char* argv[]);
+
+
 
 };
 
 
 } // pFlow
 
-#endif // __DEMSystem_hpp__
+#endif // __DEMSystem_hpp__

DEMSystems/domainDistribute/domainDistribute.cpp

@@ -33,7 +33,7 @@ void pFlow::domainDistribute::clcDomains(const std::vector<box>& domains)
 
 
 pFlow::domainDistribute::domainDistribute(
-	const std::vector<box>& domains,
+	const Vector<box>& domains,
 	real maxBoundingBox)
 :
 numDomains_(domains.size()),
@@ -47,10 +47,10 @@ maxBoundingBoxSize_(maxBoundingBox)
 }
 
 bool pFlow::domainDistribute::locateParticles(
-		ViewType1D<realx3,HostSpace> points, const pFlagTypeHost& mask)
+		ViewType1D<realx3,HostSpace> points, includeMask mask)
 {
 	
-	const rangeU32 activeRange = mask.activeRange();
+	range activeRange = mask.activeRange();
 
 
 	for(int32 di=0; di<numDomains_; di++)
@@ -59,7 +59,7 @@ bool pFlow::domainDistribute::locateParticles(
 	}
 
 	
-	for(int32 i=activeRange.start(); i<activeRange.end(); i++)
+	for(int32 i=activeRange.first; i<activeRange.second; i++)
 	{
 		if(mask(i))
 		{

DEMSystems/domainDistribute/domainDistribute.hpp

@@ -43,16 +43,19 @@ protected:
 	
 	int32Vector_H 							numParInDomain_;
 
+
 	real maxBoundingBoxSize_;
 
 	real domainExtension_ = 1.0;
 
+	using includeMask = typename pointStructure::activePointsHost;
+
 	void clcDomains(const std::vector<box>& domains);
 
 public:
 
 	domainDistribute(
-		const std::vector<box>& domains,
+		const Vector<box>& domains,
 		real maxBoundingBox);
 
 	~domainDistribute()=default;
@@ -75,7 +78,7 @@ public:
 	{
 		return
 		span<const int32>(
-			particlesInDomains_[di].hostViewAll().data(),
+			particlesInDomains_[di].hostVectorAll().data(),
 			numParInDomain_[di]
 			);
 	}
@@ -88,7 +91,7 @@ public:
 
 	//template<typename includeMask>
 	bool locateParticles(
-		ViewType1D<realx3,HostSpace> points, const pFlagTypeHost& mask);
+		ViewType1D<realx3,HostSpace> points, includeMask mask);
 	
 };
 

DEMSystems/grainDEMSystem/grainDEMSystem.cpp

@@ -1,280 +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 "grainDEMSystem.hpp"
-#include "vocabs.hpp"
-
-bool pFlow::grainDEMSystem::loop()
-{
-
-	do 
-	{
-		//
-		if(! insertion_().insertParticles( 
-			Control().time().currentIter(),
-			Control().time().currentTime(),
-			Control().time().dt()	) )
-		{
-			fatalError<<
-			"particle insertion failed in grainDEMSystem.\n";
-			return false;
-		}	
-
-		geometry_->beforeIteration();
-		
-		interaction_->beforeIteration();
-
-		particles_->beforeIteration();
-		
-		
-		interaction_->iterate();
-
-		particles_->iterate();
-
-		geometry_->iterate();
-
-		particles_->afterIteration();
-		
-		geometry_->afterIteration();
-
-	}while(Control()++);
-
-	return true;
-}
-
-pFlow::grainDEMSystem::grainDEMSystem(
-		word  demSystemName,
-		const std::vector<box>& domains,
-		int argc, 
-		char* argv[],
-		bool requireRVel)
-:
-	DEMSystem(demSystemName, domains, argc, argv),
-	requireRVel_(requireRVel)
-{ 
-	
-	REPORT(0)<<"\nReading proprties . . . "<<END_REPORT;
-	property_ = makeUnique<property>(
-		propertyFile__,
-    	Control().caseSetup().path());
-
-	REPORT(0)<< "\nCreating surface geometry for grainDEMSystem . . . "<<END_REPORT;
-	geometry_ = geometry::create(Control(), Property());
-
-	REPORT(0)<<"Reading shape dictionary ..."<<END_REPORT;
-	grains_ = makeUnique<grainShape>(
-		pFlow::shapeFile__,
-		&Control().caseSetup(),
-		Property() );	
-
-	REPORT(0)<<"\nReading grain particles . . ."<<END_REPORT;
-	particles_ = makeUnique<grainFluidParticles>(Control(), grains_());
-
-
-	insertion_ = makeUnique<grainInsertion>( 
-		particles_(), 
-		particles_().grains());
-	
-	REPORT(0)<<"\nCreating interaction model for grain-grain contact and grain-wall contact . . ."<<END_REPORT;
-	interaction_ = interaction::create(
-		Control(),
-		Particles(),
-		Geometry());
-
-	auto maxD = maxBounndingSphereSize();
-
-	particleDistribution_ = makeUnique<domainDistribute>(domains, maxD);
-
-}
-
-
-pFlow::grainDEMSystem::~grainDEMSystem()
-{
-	
-}
-
-bool pFlow::grainDEMSystem::updateParticleDistribution(
-	real extentFraction,
-	const std::vector<box> domains)
-{
-
-	if(!particleDistribution_->changeDomainsSize(
-		extentFraction,
-		maxBounndingSphereSize(),
-		domains))
-	{
-		fatalErrorInFunction<<
-		"cannot change the domain size"<<endl;
-		return false;
-	}
-
-	if(!particleDistribution_->locateParticles(
-			positionHost_, 
-			particles_->pStruct().activePointsMaskHost()))
-	{
-		fatalErrorInFunction<<
-		"error in locating particles among sub-domains"<<endl;
-		return false;
-	}
-
-	return true;
-}
-
-pFlow::int32 
-	pFlow::grainDEMSystem::numParInDomain(int32 di)const
-{
-	return particleDistribution_().numParInDomain(di);
-}
-
-std::vector<pFlow::int32> 
-	pFlow::grainDEMSystem::numParInDomains()const
-{
-	const auto& distribute = particleDistribution_();
-	int32 numDomains = distribute.numDomains();
-	std::vector<int32> nums(numDomains);
-	for(int32 i=0; i<numDomains; i++)
-	{
-		nums[i] = distribute.numParInDomain(i);
-	}
-
-	return nums;
-}
-
-pFlow::span<const pFlow::int32> 
-pFlow::grainDEMSystem::parIndexInDomain(int32 di)const
-{
-	return particleDistribution_->particlesInDomain(di);
-}
-
-pFlow::span<pFlow::uint32> pFlow::grainDEMSystem::particleId()
-{
-	return span<uint32>(particleIdHost_.data(), particleIdHost_.size());
-}
-
-
-pFlow::span<pFlow::real> pFlow::grainDEMSystem::diameter() 
-{	
-	return span<real>(diameterHost_.data(), diameterHost_.size());
-}
-
-pFlow::span<pFlow::real> pFlow::grainDEMSystem::courseGrainFactor()
-{
-    return span<real>(particles_->courseGrainFactorHost().data(), particles_->courseGrainFactorHost().size());
-}
-
-pFlow::span<pFlow::realx3> pFlow::grainDEMSystem::acceleration()
-{
-    return span<realx3>(nullptr, 0);
-}
-
-pFlow::span<pFlow::realx3> pFlow::grainDEMSystem::velocity()  
-{
-	return span<realx3>(velocityHost_.data(), velocityHost_.size());
-}
-
-pFlow::span<pFlow::realx3> pFlow::grainDEMSystem::position()  
-{
-	return span<realx3>(positionHost_.data(), positionHost_.size());
-}
-
-pFlow::span<pFlow::realx3> pFlow::grainDEMSystem::rAcceleration()
-{
-    return span<realx3>(nullptr, 0);
-}
-
-pFlow::span<pFlow::realx3> pFlow::grainDEMSystem::rVelocity()
-{
-    return span<realx3>(rVelocityHost_.data(), rVelocityHost_.size());
-}
-
-pFlow::span<pFlow::realx3> pFlow::grainDEMSystem::rPosition()
-{
-    return span<realx3>(nullptr, 0);
-}
-
-pFlow::span<pFlow::realx3> pFlow::grainDEMSystem::parFluidForce() 
-{
-	auto& hVec =  particles_->fluidForceHost();
-	
-	return span<realx3>(hVec.data(), hVec.size());
-}
-
-pFlow::span<pFlow::realx3> pFlow::grainDEMSystem::parFluidTorque() 
-{
-	auto& hVec =  particles_->fluidTorqueHost();
-	return span<realx3>(hVec.data(), hVec.size());
-}
-
-bool pFlow::grainDEMSystem::sendFluidForceToDEM() 
-{
-	particles_->fluidForceHostUpdatedSync();
-	return true;
-}
-
-bool pFlow::grainDEMSystem::sendFluidTorqueToDEM()
-{
-	particles_->fluidTorqueHostUpdatedSync();
-	return true;
-}
-
-bool pFlow::grainDEMSystem::beforeIteration()
-{
-	velocityHost_ = std::as_const(particles_()).velocity().hostView();
-	positionHost_ = std::as_const(particles_()).pointPosition().hostView();
-	diameterHost_ = particles_->diameter().hostView();
-	particleIdHost_ = particles_->particleId().hostView();
-
-	if(requireRVel_)
-		rVelocityHost_ = std::as_const(particles_()).rVelocity().hostView();
-	
-
-	return true;
-}
-
-
-bool pFlow::grainDEMSystem::iterate(
-	real upToTime, 
-	real timeToWrite, 
-	word timeName) 
-{
-
-	Control().time().setStopAt(upToTime);
-	Control().time().setOutputToFile(timeToWrite, timeName);
-	
-	return loop();
-
-	return true;
-}
-
-bool pFlow::grainDEMSystem::iterate(real upToTime)
-{
-	Control().time().setStopAt(upToTime);
-	return loop();
-	return true;
-}
-
-pFlow::real 
-	pFlow::grainDEMSystem::maxBounndingSphereSize()const
-{
-	real minD, maxD;
-	particles_->boundingSphereMinMax(minD, maxD);
-
-	return maxD;
-}

DEMSystems/grainDEMSystem/grainDEMSystem.hpp

@@ -1,169 +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.
-
------------------------------------------------------------------------------*/
-
-#ifndef __grainDEMSystem_hpp__
-#define __grainDEMSystem_hpp__
-
-#include "DEMSystem.hpp"
-#include "property.hpp"
-#include "uniquePtr.hpp"
-#include "geometry.hpp"
-#include "grainFluidParticles.hpp"
-#include "interaction.hpp"
-#include "Insertions.hpp"
-#include "domainDistribute.hpp"
-
-
-namespace pFlow
-{
-
-class grainDEMSystem
-:
-	public DEMSystem
-{
-protected:
-	
-	// protected members 
-
-	uniquePtr<property> 			property_ = nullptr;
-
-	uniquePtr<geometry> 			geometry_ = nullptr;
-
-	uniquePtr<grainShape> 			grains_   = nullptr;
-
-	uniquePtr<grainFluidParticles>  particles_ = nullptr;
-
-	uniquePtr<grainInsertion> 		insertion_ = nullptr;
-
-	uniquePtr<interaction> 			interaction_ = nullptr;
-
-	uniquePtr<domainDistribute> 	particleDistribution_=nullptr;
-
-	// to be used for CPU communications 
-	ViewType1D<realx3, HostSpace> 	velocityHost_;
-
-	ViewType1D<realx3, HostSpace> 	positionHost_;
-
-	ViewType1D<real, HostSpace> 	diameterHost_;
-
-	ViewType1D<uint32, HostSpace> 	particleIdHost_;
-
-	bool 							requireRVel_ = false;
-
-	ViewType1D<realx3, HostSpace> 	rVelocityHost_;
-
-
-//  protected member functions
-	auto& Property()
-	{
-		return property_();
-	}
-
-	auto& Geometry()
-	{
-		return geometry_();
-	}
-
-	auto& Particles()
-	{
-		return particles_();
-	}
-
-	auto& Interaction()
-	{
-		return interaction_();
-	} 
-
-	bool loop();
-
-public:
-
-	TypeInfo("grainDEMSystem");
-
-	grainDEMSystem(
-		word  demSystemName,
-		const std::vector<box>& domains,
-		int argc, 
-		char* argv[],
-		bool requireRVel=false);
-
-	virtual ~grainDEMSystem();
-
-	grainDEMSystem(const grainDEMSystem&)=delete;
-
-	grainDEMSystem& operator = (const grainDEMSystem&)=delete;
-
-	add_vCtor(
-		DEMSystem,
-		grainDEMSystem,
-		word);
-
-
-	bool updateParticleDistribution(real extentFraction, const std::vector<box> domains) override;
-	 
-	int32 numParInDomain(int32 di)const override;
-	
-	std::vector<int32> numParInDomains()const override;
-
-	span<const int32> parIndexInDomain(int32 di)const override;
-
-	span<uint32> particleId() override;
-
-	span<real> diameter() override;
-
-	span<real> courseGrainFactor() override;
-
-	span<realx3> acceleration() override;
-
-	span<realx3> velocity() override;
-
-	span<realx3> position() override;
-
-	span<realx3> rAcceleration() override;
-
-	span<realx3> rVelocity() override;
-
-	span<realx3> rPosition() override;
-
-	span<realx3> parFluidForce() override;
-
-	span<realx3> parFluidTorque() override;
-
-	bool sendFluidForceToDEM() override;
-
-	bool sendFluidTorqueToDEM() override;
-
-	bool beforeIteration() override;
-
-	bool iterate(
-		real upToTime, 
-		real timeToWrite, 
-		word timeName) override;
-
-	bool iterate(real upToTime) override;
-	
-	real maxBounndingSphereSize()const override;
-
-};
-
-
-} // pFlow
-
-#endif

DEMSystems/grainDEMSystem/grainFluidParticles.cpp

@@ -1,107 +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 "grainFluidParticles.hpp"
-#include "grainFluidParticlesKernels.hpp"
-
-void pFlow::grainFluidParticles::checkHostMemory()
-{
-	if(fluidForce_.size()!=fluidForceHost_.size())
-	{
-		resizeNoInit(fluidForceHost_, fluidForce_.size());
-		resizeNoInit(fluidTorqueHost_, fluidTorque_.size());
-	}
-
-	// copy the data (if required) from device to host
-	courseGrainFactorHost_ = coarseGrainFactor().hostView();
-}
-
-pFlow::grainFluidParticles::grainFluidParticles(
-    systemControl &control,
-    const grainShape& grains)
-    : grainParticles(control, grains),
-      fluidForce_(
-          objectFile(
-              "fluidForce",
-              "",
-              objectFile::READ_IF_PRESENT,
-              objectFile::WRITE_ALWAYS),
-          dynPointStruct(),
-          zero3),
-      fluidTorque_(
-          objectFile(
-              "fluidTorque",
-              "",
-              objectFile::READ_IF_PRESENT,
-              objectFile::WRITE_NEVER),
-          dynPointStruct(),
-          zero3)
-{
-	checkHostMemory();
-} 
-
-bool pFlow::grainFluidParticles::beforeIteration()
-{
-	grainParticles::beforeIteration();
-	checkHostMemory();
-	return true;
-}
-
-
-bool pFlow::grainFluidParticles::iterate() 
-{
-	const auto ti = this->TimeInfo();
-	accelerationTimer().start();
-		pFlow::grainFluidParticlesKernels::acceleration(
-			control().g(),
-			mass().deviceViewAll(),
-			contactForce().deviceViewAll(),
-			fluidForce_.deviceViewAll(),
-			I().deviceViewAll(),
-			contactTorque().deviceViewAll(),
-			fluidTorque_.deviceViewAll(),
-			pStruct().activePointsMaskDevice(),
-			acceleration().deviceViewAll(),
-			rAcceleration().deviceViewAll()
-			);
-	accelerationTimer().end();
-	
-	intCorrectTimer().start();
-	
-		dynPointStruct().correct(ti.dt());
-	
-		rVelIntegration().correct(ti.dt(), rVelocity(), rAcceleration());
-	
-	intCorrectTimer().end();
-	
-	return true;
-}
-
-void pFlow::grainFluidParticles::fluidForceHostUpdatedSync()
-{
-	copy(fluidForce_.deviceView(), fluidForceHost_);
-	return;
-}
-
-void pFlow::grainFluidParticles::fluidTorqueHostUpdatedSync()
-{
-	copy(fluidTorque_.deviceView(), fluidTorqueHost_);
-	return;
-}

DEMSystems/grainDEMSystem/grainFluidParticles.hpp

@@ -1,105 +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.
-
------------------------------------------------------------------------------*/
-
-/*! 
-   @class pFlow::grainFluidParticles
-    
-   @brief Class for managing grain particles with fluid interactions 
-   
-   This is a top-level class that contains the essential components for
-   defining grain prticles with fluid interactions in a DEM simulation.
- */
-
-#ifndef __grainFluidParticles_hpp__
-#define __grainFluidParticles_hpp__ 
-
-#include "grainParticles.hpp"
-
-
-namespace pFlow
-{
-
-class grainFluidParticles
-:
-	public grainParticles 
-{
-protected:
-	
-	/// pointField of rotational acceleration of particles on device  
-	realx3PointField_D 		fluidForce_;
-
-	hostViewType1D<realx3> 	fluidForceHost_;
-
-	realx3PointField_D 		fluidTorque_;
-
-	hostViewType1D<realx3>	fluidTorqueHost_;
-
-	hostViewType1D<real> 	courseGrainFactorHost_;
-
-
-	void checkHostMemory();
-
-public:
-
-	/// construct from systemControl and property 
-	grainFluidParticles(systemControl &control, const grainShape& grains);
-
-	~grainFluidParticles() override = default;
-	
-	/// before iteration step 
-	bool beforeIteration() override;
-	
-	/// iterate particles 
-	bool iterate() override;	
-
-	auto& fluidForce()
-	{
-		return fluidForce_;
-	}
-
-	auto& fluidTorque()
-	{
-		return fluidTorque_;
-	}
-
-	auto& fluidForceHost()
-	{
-		return fluidForceHost_; 
-	}
-
-	auto& fluidTorqueHost()
-	{
-		return fluidTorqueHost_;
-	}
-
-	auto& courseGrainFactorHost()
-	{
-		return courseGrainFactorHost_;
-	}
-
-	void fluidForceHostUpdatedSync();
-
-	void fluidTorqueHostUpdatedSync();
-	
-}; //grainFluidParticles
-
-} // pFlow
-
-#endif //__sphereFluidParticles_hpp__

DEMSystems/grainDEMSystem/grainFluidParticlesKernels.hpp

@@ -1,79 +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.
-
------------------------------------------------------------------------------*/
-
-#ifndef __grainFluidParticlesKernels_hpp__
-#define __grainFluidParticlesKernels_hpp__
-
-namespace pFlow::grainFluidParticlesKernels
-{
-
-using rpAcceleration = Kokkos::RangePolicy<
-			DefaultExecutionSpace,
-			Kokkos::Schedule<Kokkos::Static>,
-			Kokkos::IndexType<int32>
-			>;
-
-template<typename IncludeFunctionType>
-void acceleration( 
-	realx3		g,
-	deviceViewType1D<real>  	mass,
-	deviceViewType1D<realx3>  	force,
-	deviceViewType1D<realx3>  	fluidForce,
-	deviceViewType1D<real>  	I,
-	deviceViewType1D<realx3>  	torque,
-	deviceViewType1D<realx3>  	fluidTorque,
-	IncludeFunctionType 		incld,
-	deviceViewType1D<realx3> 	lAcc,
-	deviceViewType1D<realx3> 	rAcc
-	)
-{
-
-	auto activeRange = incld.activeRange();
-	if(incld.isAllActive())
-	{
-		Kokkos::parallel_for(
-		"pFlow::grainParticlesKernels::acceleration",
-		rpAcceleration(activeRange.first, activeRange.second),
-		LAMBDA_HD(int32 i){
-				lAcc[i] = (force[i]+fluidForce[i])/mass[i] + g;
-				rAcc[i] = (torque[i]+fluidTorque[i])/I[i];
-		});
-	}
-	else
-	{
-		Kokkos::parallel_for(
-		"pFlow::grainParticlesKernels::acceleration",
-		rpAcceleration(activeRange.first, activeRange.second),
-		LAMBDA_HD(int32 i){
-			if(incld(i))
-			{
-				lAcc[i] = (force[i]+fluidForce[i])/mass[i] + g;
-				rAcc[i] = (torque[i]+fluidTorque[i])/I[i];
-			}
-		});
-
-	}
-	
-	Kokkos::fence();
-}
-
-}
-
-#endif 

DEMSystems/sphereDEMSystem/sphereDEMSystem.cpp

@@ -19,7 +19,6 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 #include "sphereDEMSystem.hpp"
-#include "vocabs.hpp"
 
 bool pFlow::sphereDEMSystem::loop()
 {
@@ -27,15 +26,16 @@ bool pFlow::sphereDEMSystem::loop()
 	do 
 	{
 		//
+		
 		if(! insertion_().insertParticles( 
-			Control().time().currentIter(),
 			Control().time().currentTime(),
 			Control().time().dt()	) )
 		{
 			fatalError<<
-			"particle insertion failed in sphereDEMSystem.\n";
+			"particle insertion failed in sphereDFlow solver.\n";
 			return false;
-		}	
+		}
+		
 
 		geometry_->beforeIteration();
 		
@@ -63,37 +63,29 @@ pFlow::sphereDEMSystem::sphereDEMSystem(
 		word  demSystemName,
 		const std::vector<box>& domains,
 		int argc, 
-		char* argv[],
-		bool requireRVel)
+		char* argv[])
 :
-	DEMSystem(demSystemName, domains, argc, argv),
-	requireRVel_(requireRVel)
+	DEMSystem(demSystemName, domains, argc, argv)
 { 
 	
-	REPORT(0)<<"\nReading proprties . . . "<<END_REPORT;
+	REPORT(0)<<"\nReading proprties . . . "<<endREPORT;
 	property_ = makeUnique<property>(
-		propertyFile__,
-    	Control().caseSetup().path());
-		
+    	Control().caseSetup().path()+propertyFile__);
 
-	REPORT(0)<< "\nCreating surface geometry for sphereDEMSystem . . . "<<END_REPORT;
+	REPORT(0)<< "\nCreating surface geometry for sphereDEMSystem . . . "<<endREPORT;
 	geometry_ = geometry::create(Control(), Property());
 
-	REPORT(0)<<"Reading shapes dictionary..."<<END_REPORT;
-	spheres_ = makeUnique<sphereShape>(
-		pFlow::shapeFile__, 
-		&Control().caseSetup(), 
-		Property());
 
-	REPORT(0)<<"\nReading sphere particles . . ."<<END_REPORT;
-	particles_ = makeUnique<sphereFluidParticles>(Control(), spheres_());
+	REPORT(0)<<"\nReading sphere particles . . ."<<endREPORT;
+	particles_ = makeUnique<sphereFluidParticles>(Control(), Property());
 
 
-	insertion_ = makeUnique<sphereInsertion>( 
+	insertion_ = makeUnique<sphereInsertion>(
+		Control().caseSetup().path()+insertionFile__, 
 		particles_(), 
-		particles_().spheres());
+		particles_().shapes());
 	
-	REPORT(0)<<"\nCreating interaction model for sphere-sphere contact and sphere-wall contact . . ."<<END_REPORT;
+	REPORT(0)<<"\nCreating interaction model for sphere-sphere contact and sphere-wall contact . . ."<<endREPORT;
 	interaction_ = interaction::create(
 		Control(),
 		Particles(),
@@ -106,7 +98,6 @@ pFlow::sphereDEMSystem::sphereDEMSystem(
 
 }
 
-
 pFlow::sphereDEMSystem::~sphereDEMSystem()
 {
 	
@@ -128,8 +119,8 @@ bool pFlow::sphereDEMSystem::updateParticleDistribution(
 	}
 
 	if(!particleDistribution_->locateParticles(
-			positionHost_, 
-			particles_->pStruct().activePointsMaskHost()))
+			parPosition_, 
+			particles_->pStruct().activePointsMaskH()))
 	{
 		fatalErrorInFunction<<
 		"error in locating particles among sub-domains"<<endl;
@@ -146,7 +137,7 @@ pFlow::int32
 }
 
 std::vector<pFlow::int32> 
-	pFlow::sphereDEMSystem::numParInDomains()const
+	pFlow::sphereDEMSystem::numParInDomain()const
 {
 	const auto& distribute = particleDistribution_();
 	int32 numDomains = distribute.numDomains();
@@ -165,61 +156,31 @@ pFlow::sphereDEMSystem::parIndexInDomain(int32 di)const
 	return particleDistribution_->particlesInDomain(di);
 }
 
-pFlow::span<pFlow::uint32> pFlow::sphereDEMSystem::particleId()
-{
-    return span<uint32>();
-}
-
-pFlow::span<pFlow::real> pFlow::sphereDEMSystem::diameter() 
+pFlow::span<pFlow::real> pFlow::sphereDEMSystem::parDiameter() 
 {	
-	return span<real>(diameterHost_.data(), diameterHost_.size());
+	return span<real>(parDiameter_.data(), parDiameter_.size());
 }
 
-pFlow::span<pFlow::real> pFlow::sphereDEMSystem::courseGrainFactor()
+pFlow::span<pFlow::realx3> pFlow::sphereDEMSystem::parVelocity()  
 {
-    return span<real>(nullptr, 0);
+	return span<realx3>(parVelocity_.data(), parVelocity_.size());
 }
 
-pFlow::span<pFlow::realx3> pFlow::sphereDEMSystem::acceleration()
+pFlow::span<pFlow::realx3> pFlow::sphereDEMSystem::parPosition()  
 {
-    return span<realx3>(nullptr, 0);
-}
-
-pFlow::span<pFlow::realx3> pFlow::sphereDEMSystem::velocity()  
-{
-	return span<realx3>(velocityHost_.data(), velocityHost_.size());
-}
-
-pFlow::span<pFlow::realx3> pFlow::sphereDEMSystem::position()  
-{
-	return span<realx3>(positionHost_.data(), positionHost_.size());
-}
-
-pFlow::span<pFlow::realx3> pFlow::sphereDEMSystem::rAcceleration()
-{
-    return span<realx3>(nullptr, 0);
-}
-
-pFlow::span<pFlow::realx3> pFlow::sphereDEMSystem::rVelocity()
-{
-    return span<realx3>(rVelocityHost_.data(), rVelocityHost_.size());
-}
-
-pFlow::span<pFlow::realx3> pFlow::sphereDEMSystem::rPosition()
-{
-    return span<realx3>(nullptr, 0);
+	return span<realx3>(parPosition_.data(), parPosition_.size());
 }
 
 pFlow::span<pFlow::realx3> pFlow::sphereDEMSystem::parFluidForce() 
 {
-	auto& hVec =  particles_->fluidForceHost();
+	auto& hVec =  particles_->fluidForceHostAll();
 	
 	return span<realx3>(hVec.data(), hVec.size());
 }
 
 pFlow::span<pFlow::realx3> pFlow::sphereDEMSystem::parFluidTorque() 
 {
-	auto& hVec =  particles_->fluidTorqueHost();
+	auto& hVec =  particles_->fluidTorqueHostAll();
 	return span<realx3>(hVec.data(), hVec.size());
 }
 
@@ -237,15 +198,9 @@ bool pFlow::sphereDEMSystem::sendFluidTorqueToDEM()
 
 bool pFlow::sphereDEMSystem::beforeIteration()
 {
-	velocityHost_ = std::as_const(particles_()).velocity().hostView();
-	positionHost_ = std::as_const(particles_()).pointPosition().hostView();
-	diameterHost_ = particles_->diameter().hostView();
-	particleIdHost_ = particles_->particleId().hostView();
-
-	if(requireRVel_)
-		rVelocityHost_ = std::as_const(particles_()).rVelocity().hostView();
-	
-
+	parVelocity_ = particles_->dynPointStruct().velocityHostAll();
+	parPosition_ = particles_->dynPointStruct().pointPositionHostAll();
+	parDiameter_ = particles_->diameter().hostVectorAll();
 	return true;
 }
 

DEMSystems/sphereDEMSystem/sphereDEMSystem.hpp

@@ -42,33 +42,24 @@ protected:
 	
 	// protected members 
 
-	uniquePtr<property> 			property_ = nullptr;
+	uniquePtr<property> 		property_ = nullptr;
 
-	uniquePtr<geometry> 			geometry_ = nullptr;
+	uniquePtr<geometry> 		geometry_ = nullptr;
 
-	uniquePtr<sphereShape> 			spheres_  = nullptr;
+	uniquePtr<sphereFluidParticles> 	particles_ = nullptr;
 
-	uniquePtr<sphereFluidParticles> particles_ = nullptr;
+	uniquePtr<sphereInsertion> 	insertion_ = nullptr;
 
-	uniquePtr<sphereInsertion> 		insertion_ = nullptr;
+	uniquePtr<interaction> 		interaction_ = nullptr;
 
-	uniquePtr<interaction> 			interaction_ = nullptr;
-
-	uniquePtr<domainDistribute> 	particleDistribution_=nullptr;
+	uniquePtr<domainDistribute> particleDistribution_=nullptr;
 
 	// to be used for CPU communications 
-	ViewType1D<realx3, HostSpace> 	velocityHost_;
+	ViewType1D<realx3, HostSpace>  parVelocity_;
 
-	ViewType1D<realx3, HostSpace> 	positionHost_;
-
-	ViewType1D<real, HostSpace> 	diameterHost_;
-
-	ViewType1D<uint32, HostSpace> 	particleIdHost_;
-
-	bool 							requireRVel_ = false;
-
-	ViewType1D<realx3, HostSpace> 	rVelocityHost_;
+	ViewType1D<realx3, HostSpace>  parPosition_;
 
+	ViewType1D<real, HostSpace> parDiameter_;
 
 //  protected member functions
 	auto& Property()
@@ -101,8 +92,7 @@ public:
 		word  demSystemName,
 		const std::vector<box>& domains,
 		int argc, 
-		char* argv[],
-		bool requireRVel=false);
+		char* argv[]);
 
 	virtual ~sphereDEMSystem();
 
@@ -120,27 +110,15 @@ public:
 	 
 	int32 numParInDomain(int32 di)const override;
 	
-	std::vector<int32> numParInDomains()const override;
+	std::vector<int32> numParInDomain()const override;
 
 	span<const int32> parIndexInDomain(int32 di)const override;
 
-	span<uint32> particleId() override;
+	span<real> parDiameter() override;
 
-	span<real> diameter() override;
+	span<realx3> parVelocity() override;
 
-	span<real> courseGrainFactor() override;
-
-	span<realx3> acceleration() override;
-
-	span<realx3> velocity() override;
-
-	span<realx3> position() override;
-
-	span<realx3> rAcceleration() override;
-
-	span<realx3> rVelocity() override;
-
-	span<realx3> rPosition() override;
+	span<realx3> parPosition() override;
 
 	span<realx3> parFluidForce() override;
 

DEMSystems/sphereDEMSystem/sphereFluidParticles.cpp

@@ -21,85 +21,85 @@ Licence:
 #include "sphereFluidParticles.hpp"
 #include "sphereFluidParticlesKernels.hpp"
 
-void pFlow::sphereFluidParticles::checkHostMemory()
-{
-	if(fluidForce_.size()!=fluidForceHost_.size())
-	{
-		resizeNoInit(fluidForceHost_, fluidForce_.size());
-		resizeNoInit(fluidTorqueHost_, fluidTorque_.size());
-	}
-}
 
 pFlow::sphereFluidParticles::sphereFluidParticles(
-    systemControl &control,
-    const sphereShape& shpShape)
-    : sphereParticles(control, shpShape),
-      fluidForce_(
-          objectFile(
-              "fluidForce",
-              "",
-              objectFile::READ_IF_PRESENT,
-              objectFile::WRITE_ALWAYS),
-          dynPointStruct(),
-          zero3),
-      fluidTorque_(
-          objectFile(
-              "fluidTorque",
-              "",
-              objectFile::READ_IF_PRESENT,
-              objectFile::WRITE_NEVER),
-          dynPointStruct(),
-          zero3)
-{
-	checkHostMemory();
-} 
+	systemControl &control,
+	const property& prop
+)
+:
+	sphereParticles(control, prop),
+	fluidForce_(
+		this->time().emplaceObject<realx3PointField_HD>(
+			objectFile(
+				"fluidForce",
+				"",
+				objectFile::READ_IF_PRESENT,
+				objectFile::WRITE_ALWAYS
+				),
+			pStruct(),
+			zero3
+			)
+		),
+	fluidTorque_(
+		this->time().emplaceObject<realx3PointField_HD>(
+			objectFile(
+				"fluidTorque",
+				"",
+				objectFile::READ_IF_PRESENT,
+				objectFile::WRITE_ALWAYS
+				),
+			pStruct(),
+			zero3
+			)
+		)
+{} 
 
 bool pFlow::sphereFluidParticles::beforeIteration()
 {
 	sphereParticles::beforeIteration();
-	checkHostMemory();
-
 	return true;
 }
 
 
 bool pFlow::sphereFluidParticles::iterate() 
 {
-	const auto ti = this->TimeInfo();
-	accelerationTimer().start();
+
+	accelerationTimer_.start();
 		pFlow::sphereFluidParticlesKernels::acceleration(
 			control().g(),
-			mass().deviceViewAll(),
-			contactForce().deviceViewAll(),
-			fluidForce_.deviceViewAll(),
-			I().deviceViewAll(),
-			contactTorque().deviceViewAll(),
-			fluidTorque_.deviceViewAll(),
-			pStruct().activePointsMaskDevice(),
-			acceleration().deviceViewAll(),
-			rAcceleration().deviceViewAll()
+			mass().deviceVectorAll(),
+			contactForce().deviceVectorAll(),
+			fluidForce().deviceVectorAll(),
+			I().deviceVectorAll(),
+			contactTorque().deviceVectorAll(),
+			fluidTorque().deviceVectorAll(),
+			pStruct().activePointsMaskD(),
+			accelertion().deviceVectorAll(),
+			rAcceleration().deviceVectorAll()
 			);
-	accelerationTimer().end();
+	accelerationTimer_.end();
 	
-	intCorrectTimer().start();
+	intCorrectTimer_.start();
 	
-		dynPointStruct().correct(ti.dt());
+		dynPointStruct_.correct(this->dt(), accelertion_);
 	
-		rVelIntegration().correct(ti.dt(), rVelocity(), rAcceleration());
+		rVelIntegration_().correct(this->dt(), rVelocity_, rAcceleration_);
 	
-	intCorrectTimer().end();
+	intCorrectTimer_.end();
 	
 	return true;
 }
 
 void pFlow::sphereFluidParticles::fluidForceHostUpdatedSync()
 {
-	copy(fluidForce_.deviceView(), fluidForceHost_);
+	fluidForce_.modifyOnHost();
+	fluidForce_.syncViews();
 	return;
 }
 
 void pFlow::sphereFluidParticles::fluidTorqueHostUpdatedSync()
 {
-	copy(fluidTorque_.deviceView(), fluidTorqueHost_);
+	fluidTorque_.modifyOnHost();
+	fluidTorque_.syncViews();
 	return;
 }

DEMSystems/sphereDEMSystem/sphereFluidParticles.hpp

@@ -43,17 +43,12 @@ class sphereFluidParticles
 protected:
 	
 	/// pointField of rotational acceleration of particles on device  
-	realx3PointField_D 		fluidForce_;
+	realx3PointField_HD& 	fluidForce_;
 
-	hostViewType1D<realx3> 	fluidForceHost_;
+	realx3PointField_HD& 	fluidTorque_;
 
-	realx3PointField_D 		fluidTorque_;
 
-	hostViewType1D<realx3>	fluidTorqueHost_;
-
-	void checkHostMemory();
-
-	/*void zeroFluidForce_H()
+	void zeroFluidForce_H()
 	{
 		fluidForce_.fillHost(zero3);
 	}
@@ -61,12 +56,12 @@ protected:
 	void zeroFluidTorque_H()
 	{
 		fluidTorque_.fillHost(zero3);
-	}*/
+	}
 
 public:
 
 	/// construct from systemControl and property 
-	sphereFluidParticles(systemControl &control, const sphereShape& shpShape);
+	sphereFluidParticles(systemControl &control, const property& prop);
 	
 	/// before iteration step 
 	bool beforeIteration() override;
@@ -86,16 +81,17 @@ public:
 	}
 
 
-	auto& fluidForceHost()
+	auto& fluidForceHostAll()
 	{
-		return fluidForceHost_; 
+		return fluidForce_.hostVectorAll();
 	}
 
-	auto& fluidTorqueHost()
+	auto& fluidTorqueHostAll()
 	{
-		return fluidTorqueHost_;
+		return fluidTorque_.hostVectorAll();
 	}
 
+
 	void fluidForceHostUpdatedSync();
 
 	void fluidTorqueHostUpdatedSync();

DEMSystems/sphereDEMSystem/sphereFluidParticlesKernels.hpp

@@ -46,7 +46,7 @@ void acceleration(
 {
 
 	auto activeRange = incld.activeRange();
-	if(incld.isAllActive())
+	if(incld.allActive())
 	{
 		Kokkos::parallel_for(
 		"pFlow::sphereParticlesKernels::acceleration",

README.md

@@ -1,76 +1,24 @@
-<div align="center">
-  <img src="doc/phasicFlow_logo_github.png" style="width: 400px;" alt="PhasicFlow Logo">
+<div align ="center">
+<img src="doc/phasicFlow_logo_github.png" style="width: 400px;">
 </div>
 
-## **PhasicFlow: High-Performance Discrete Element Method Simulations**
 
-PhasicFlow is a robust, open-source C++ framework designed for the efficient simulation of granular materials using the Discrete Element Method (DEM). Leveraging parallel computing paradigms, PhasicFlow is capable of executing simulations on shared-memory multi-core architectures, including CPUs and NVIDIA GPUs (CUDA-enabled). The core parallelization strategy focuses on loop-level parallelism, enabling significant performance gains on modern hardware. Users can seamlessly transition between serial execution on standard PCs, parallel execution on multi-core CPUs (OpenMP), and accelerated simulations on GPUs. Currently, PhasicFlow supports simulations involving up to 80 million particles on a single desktop workstation. Detailed performance benchmarks are available on the [PhasicFlow Wiki](https://github.com/PhasicFlow/phasicFlow/wiki/Performance-of-phasicFlow).
+**PhasicFlow** is a parallel C++ code for performing DEM simulations. It can run on shared-memory multi-core computational units such as multi-core CPUs or GPUs (for now it works on CUDA-enabled GPUs). The parallelization method mainly relies on loop-level parallelization on a shared-memory computational unit. You can build and run PhasicFlow in serial mode on regular PCs, in parallel mode for multi-core CPUs, or build it for a GPU device to off-load computations to a GPU. In its current statues you can simulate millions of particles (up to 32M particles tested) on a single desktop computer. You can see the [performance tests of PhasicFlow](https://github.com/PhasicFlow/phasicFlow/wiki/Performance-of-phasicFlow) in the wiki page. 
 
-**Scalable Parallelism: MPI Integration**
+## How to build?
+You can build PhasicFlow for CPU and GPU executions. [Here is a complete step-by-step procedure](https://github.com/PhasicFlow/phasicFlow/wiki/How-to-Build-PhasicFlow).
 
-Ongoing development includes the integration of MPI-based parallelization with dynamic load balancing. This enhancement will extend PhasicFlow's capabilities to distributed memory environments, such as multi-GPU workstations and high-performance computing clusters. Upon completion, PhasicFlow will offer six distinct execution modes:
+## Online code documentation
+You can find a full documentation of the code, its features, and other related materials on [online documentation of the code](https://phasicflow.github.io/phasicFlow/)
 
-1.  **Serial Execution:** Single-core CPU.
-2.  **Shared-Memory Parallelism:** Multi-core CPU (OpenMP).
-3.  **GPU Acceleration:** NVIDIA GPU (CUDA).
-4.  **Distributed-Memory Parallelism:** MPI.
-5.  **Hybrid Parallelism:** MPI + OpenMP.
-6.  **Multi-GPU Parallelism:** MPI + CUDA.
+## How to use PhasicFlow?
+You can navigate into [tutorials folder](./tutorials) in the phasicFlow folder to see some simulation case setups. If you need more detailed discription, visit our [wiki page tutorials](https://github.com/PhasicFlow/phasicFlow/wiki/Tutorials).  
 
-## **Build and Installation**
-
-PhasicFlow can be compiled for both CPU and GPU execution.
-
-* **Current Development (v-1.0):** Comprehensive build instructions are available [here](https://github.com/PhasicFlow/phasicFlow/wiki/How-to-build-PhasicFlow%E2%80%90v%E2%80%901.0).
-* **Latest Release (v-0.1):** Detailed build instructions are available [here](https://github.com/PhasicFlow/phasicFlow/wiki/How-to-Build-PhasicFlow).
-
-## **Comprehensive Documentation**
-
-In-depth documentation, including code structure, features, and usage guidelines, is accessible via the [online documentation portal](https://phasicflow.github.io/phasicFlow/).
-
-### **Tutorials and Examples**
-
-Practical examples and simulation setups are provided in the [tutorials directory](./tutorials). For detailed explanations and step-by-step guides, please refer to the [tutorial section on the PhasicFlow Wiki](https://github.com/PhasicFlow/phasicFlow/wiki/Tutorials).
-
-## Contributing to PhasicFlow
-We welcome contributions to PhasicFlow! Whether you're a developer or a new user, there are many ways to get involved. Here's how you can help:
-1. Bug Reports
-2. Suggestions for better user experience
-3. Feature request and algorithm improvements
-4. Tutorials, Simulation Case Setups and documentation
-5. Direct Code Contributions
-
-For more details on how you can contribute to PhasicFlow see [this page](https://github.com/PhasicFlow/phasicFlow/wiki/How-to-contribute-to-PhasicFlow). 
-
-## **PhasicFlowPlus: Coupled CFD-DEM Simulations**
-
-PhasicFlowPlus is an extension of PhasicFlow that facilitates the simulation of particle-fluid systems using resolved and unresolved CFD-DEM methods. The repository for PhasicFlowPlus can be found [here](https://github.com/PhasicFlow/PhasicFlowPlus).
-
-## How to cite PhasicFlow?
-
-If you are using PhasicFlow in your research or industrial work, cite the following [article](https://www.sciencedirect.com/science/article/pii/S0010465523001662):
-
-```
-@article
-{
-  NOROUZI2023108821,
-  title = {PhasicFlow: A parallel, multi-architecture open-source code for DEM simulations},
-  journal = {Computer Physics Communications},
-  volume = {291},
-  pages = {108821},
-  year = {2023},
-  issn = {0010-4655},
-  doi = {https://doi.org/10.1016/j.cpc.2023.108821},
-  url = {https://www.sciencedirect.com/science/article/pii/S0010465523001662},
-  author = {H.R. Norouzi},
-  keywords = {Discrete element method, Parallel computing, CUDA, GPU, OpenMP, Granular flow}
-}
-```
+## [PhasicFlowPlus](https://github.com/PhasicFlow/PhasicFlowPlus)
+PhasicFlowPlus is and extension to PhasicFlow for simulating particle-fluid systems using resolved and unresolved CFD-DEM. [See the repository of this package.](https://github.com/PhasicFlow/PhasicFlowPlus)
 
 
-## **Dependencies**
+## Supporting packages
+* [Kokkos](https://github.com/kokkos/kokkos) from National Technology & Engineering Solutions of Sandia, LLC (NTESS)
+* [CLI11 1.8](https://github.com/CLIUtils/CLI11) from University of Cincinnati.
 
-PhasicFlow relies on the following external libraries:
-
-* **Kokkos:** A community-led performance portability ecosystem within the Linux Foundation's High-Performance Software Foundation (HPSF). ([https://github.com/kokkos/kokkos](https://github.com/kokkos/kokkos))
-* **CLI11 1.8:** A command-line interface parser developed by the University of Cincinnati. ([https://github.com/CLIUtils/CLI11](https://github.com/CLIUtils/CLI11))

benchmarks/helicalMixer/helicalMixer_1m/caseSetup/interaction

@@ -1,53 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName interaction;
-objectType dicrionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-materials   (glassMat wallMat); // a list of materials names
-
-densities   (2500.0 2500);      // density of materials [kg/m3]
-
-contactListType   sortedContactList;
-
-model
-{
-   contactForceModel    nonLinearLimited;
-   
-   rollingFrictionModel normal;
-
-   Yeff (1.0e6 1.0e6  // Young modulus [Pa]
-               1.0e6);
-   
-   Geff (0.8e6 0.8e6  // Shear modulus [Pa]
-               0.8e6);
-
-   nu    (0.25 0.25  // Poisson's ratio [-]
-               0.25);
-
-   en (0.97  0.85   // coefficient of normal restitution
-             1.00);
-
-   mu (0.65  0.65   // dynamic friction 
-             0.65);
-
-   mur (0.1  0.1    // rolling friction 
-             0.1);
-        
-}
-
-contactSearch
-{
-    method         NBS;  
-
-    updateInterval   10;
-
-    sizeRatio       1.1;
-
-    cellExtent     0.55;
-
-    adjustableBox   Yes;     
-}

benchmarks/helicalMixer/helicalMixer_1m/caseSetup/particleInsertion

@@ -1,72 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  particleInsertion;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-active  yes;          // is insertion active?
-
-particleInlet1
-{
-   regionType     box; // type of insertion region
-   
-   rate           250000;  // insertion rate (particles/s)
-   
-   timeControl    simulationTime;
-   
-   startTime      0;      // (s)
-   
-   endTime        2.0;    // (s)
-   
-   insertionInterval    0.05;  //s  
-
-   boxInfo 
-   {
-        min (-0.17 0.23 0.46); // (m,m,m)
-        max ( 0.17 0.24 0.88); // (m,m,m)
-   }
-   
-   setFields
-   {
-        velocity    realx3 (0.0 -0.3 0.0); // initial velocity of inserted particles 
-   }
-   
-   mixture
-   {
-        smallParticle 1; // mixture composition of inserted particles 
-   }
-}
-
-particleInlet2
-{
-    regionType     box; // type of insertion region
-
-    rate           250000;  // insertion rate (particles/s)
-
-    timeControl    simulationTime;
-
-    startTime      0;      // (s)
-
-    endTime        2.0;    // (s)
-
-    insertionInterval    0.05;  //s  
-
-    boxInfo 
-    {
-        min ( -0.17 0.23 0.02); // (m,m,m)
-        max (  0.17 0.24 0.44); // (m,m,m)
-    }
-
-    setFields
-    {
-        velocity    realx3 (0.0 -0.3 0.0); // initial velocity of inserted particles 
-    }
-   
-   mixture
-   {
-        largeParticle 1; // mixture composition of inserted particles 
-   }
-}

benchmarks/helicalMixer/helicalMixer_1m/caseSetup/shapes

@@ -1,12 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  shapes;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-names       (smallParticle largeParticle);  // names of shapes 
-diameters   (0.004 0.00401);                // diameter of shapes 
-materials   (glassMat glassMat);            // material names for shapes 

benchmarks/helicalMixer/helicalMixer_1m/cleanThisCase

@@ -1,7 +0,0 @@
-#!/bin/sh
-cd ${0%/*} || exit 1    # Run from this directory
-
-ls | grep -P "^(([0-9]+\.?[0-9]*)|(\.[0-9]+))$" | xargs -d"\n" rm -rf
-rm -rf VTK 
-rm -rf stl
-#------------------------------------------------------------------------------

benchmarks/helicalMixer/helicalMixer_1m/runThisCase

@@ -1,32 +0,0 @@
-#!/bin/sh
-
-set -e  # Exit immediately if a command exits with a non-zero status
-cd ${0%/*} || exit 1    # Run from this directory
-
-echo "\n<--------------------------------------------------------------------->"
-echo "0) Copying stl files"
-echo "\n<--------------------------------------------------------------------->"
-mkdir -p stl
-cp -rfv $pFlow_PROJECT_DIR/resources/stls/helicalMixer/* ./stl/
-
-echo "\n<--------------------------------------------------------------------->"
-echo "1) Creating particles"
-echo "<--------------------------------------------------------------------->\n"
-particlesPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "2) Creating geometry"
-echo "<--------------------------------------------------------------------->\n"
-geometryPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "3) Running the case"
-echo "<--------------------------------------------------------------------->\n"
-sphereGranFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "4) Converting to VtK"
-echo "<--------------------------------------------------------------------->\n"
-pFlowToVTK -f diameter id velocity --binary
-
-#------------------------------------------------------------------------------

benchmarks/helicalMixer/helicalMixer_1m/settings/domainDict

@@ -1,49 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName  domainDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-// Simulation domain
-globalBox                                        
-{
-    min (-0.19  -0.19 -0.02);
-    max ( 0.19   0.26  0.92);
-}
-
-boundaries
-{
-    
-    left
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    right
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    bottom
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    top
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    rear
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    front
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-}

benchmarks/helicalMixer/helicalMixer_1m/settings/geometryDict

@@ -1,60 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */
-objectName  geometryDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-// motion model: rotating object around an axis
-motionModel rotatingAxis; 
-
-rotatingAxisInfo
-{
-    rotAxis 
-    {
-        // end points of axis
-        p1          (0 0 0);
-        p2          (0 0 1);
-        
-        // rotation speed (rad/s) => 30 rpm
-        omega       3.1428;      
-
-        // interval for rotation of axis 
-        startTime   2.5;
-        endTime     100;
-    }
-}
-
-surfaces
-{
-    
-    helix
-    {
-        type     stlWall;       // type of the wall
-        file     helix2.stl;    // file name in stl folder
-        material wallMat;       // material name of this wall
-        motion   rotAxis;       // motion component name 
-    }
-
-    shell
-    {
-        type     stlWall;       // type of the wall
-        file     shell2.stl;    // file name in stl folder      
-        material wallMat;       // material name of this wall
-        motion   none;          // motion component name 
-    }
-        
-    plug
-    {
-        type    planeWall;
-        p1      (-0.075 -0.185 0.375);
-        p2      ( 0.075 -0.185 0.375);
-        p3      ( 0.075 -0.185 0.525);
-        p4      (-0.075 -0.185 0.525);
-        material wallMat;
-        motion   none; 
-    }
-     
-}

benchmarks/helicalMixer/helicalMixer_1m/settings/particlesDict

@@ -1,27 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  particlesDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-setFields
-{
-    defaultValue 
-    {
-        velocity        realx3  (0 0 0);        // linear velocity (m/s)
-        acceleration    realx3  (0 0 0);        // linear acceleration (m/s2)
-        rVelocity       realx3  (0 0 0);        // rotational velocity (rad/s)
-        shapeName       word    smallParticle;  // name of the particle shape 
-    }
-
-    selectors
-    {}
-}
-
-positionParticles
-{
-    method empty;     // creates the required fields with zero particles (empty). 
-}

benchmarks/helicalMixer/helicalMixer_1m/settings/settingsDict

@@ -1,37 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName  settingsDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-run         		helicalMixer;
-
-dt                  0.00001;      // time step for integration (s)
-
-startTime           0;            // start time for simulation
-
-endTime             7.5;          // end time for simulation
-
-saveInterval        0.05;         // time interval for saving the simulation
-
-timePrecision       4;            // maximum number of digits for time folder
-
-g                 	(0 -9.8 0);   // gravity vector (m/s2)
-
-// save necessary (i.e., required) data on disk
-includeObjects 		(diameter);                       
-
-// exclude unnecessary data from saving on disk
-excludeObjects 		(); 
-
-integrationMethod   	AdamsBashforth2; // integration method
-
-integrationHistory      off;             // Do not save integration history on the disk 
-
-writeFormat             binary;          // data writting format (ascii or binary)
-
-timersReport            Yes;             // report timers (Yes or No)
-
-timersReportInterval    0.05;            // time interval for reporting timers

benchmarks/helicalMixer/helicalMixer_250K/caseSetup/interaction

@@ -1,53 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName interaction;
-objectType dicrionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-materials   (glassMat wallMat); // a list of materials names
-
-densities   (2500.0 2500);      // density of materials [kg/m3]
-
-contactListType   sortedContactList;
-
-model
-{
-   contactForceModel    nonLinearLimited;
-   
-   rollingFrictionModel normal;
-
-   Yeff (1.0e6 1.0e6  // Young modulus [Pa]
-               1.0e6);
-   
-   Geff (0.8e6 0.8e6  // Shear modulus [Pa]
-               0.8e6);
-
-   nu    (0.25 0.25  // Poisson's ratio [-]
-               0.25);
-
-   en (0.97  0.85   // coefficient of normal restitution
-             1.00);
-
-   mu (0.65  0.65   // dynamic friction 
-             0.65);
-
-   mur (0.1  0.1    // rolling friction 
-             0.1);
-        
-}
-
-contactSearch
-{
-    method         NBS;  
-
-    updateInterval   10;
-
-    sizeRatio       1.1;
-
-    cellExtent     0.55;
-
-    adjustableBox   Yes;     
-}

benchmarks/helicalMixer/helicalMixer_250K/caseSetup/particleInsertion

@@ -1,72 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  particleInsertion;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-active  yes;          // is insertion active?
-
-particleInlet1
-{
-   regionType     box; // type of insertion region
-   
-   rate           62500;  // insertion rate (particles/s)
-   
-   timeControl    simulationTime;
-   
-   startTime      0;      // (s)
-   
-   endTime        2.0;    // (s)
-   
-   insertionInterval    0.05;  //s  
-
-   boxInfo 
-   {
-        min (-0.17 0.23 0.46); // (m,m,m)
-        max ( 0.17 0.24 0.88); // (m,m,m)
-   }
-   
-   setFields
-   {
-        velocity    realx3 (0.0 -0.3 0.0); // initial velocity of inserted particles 
-   }
-   
-   mixture
-   {
-        smallParticle 1; // mixture composition of inserted particles 
-   }
-}
-
-particleInlet2
-{
-    regionType     box; // type of insertion region
-
-    rate           62500;  // insertion rate (particles/s)
-
-    timeControl    simulationTime;
-
-    startTime      0;      // (s)
-
-    endTime        2.0;    // (s)
-
-    insertionInterval    0.05;  //s  
-
-    boxInfo 
-    {
-        min ( -0.17 0.23 0.02); // (m,m,m)
-        max (  0.17 0.24 0.44); // (m,m,m)
-    }
-
-    setFields
-    {
-        velocity    realx3 (0.0 -0.3 0.0); // initial velocity of inserted particles 
-    }
-   
-   mixture
-   {
-        largeParticle 1; // mixture composition of inserted particles 
-   }
-}

benchmarks/helicalMixer/helicalMixer_250K/caseSetup/shapes

@@ -1,12 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  shapes;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-names       (smallParticle largeParticle);  // names of shapes 
-diameters   (0.006 0.00601);                // diameter of shapes 
-materials   (glassMat glassMat);            // material names for shapes 

benchmarks/helicalMixer/helicalMixer_250K/cleanThisCase

@@ -1,8 +0,0 @@
-#!/bin/sh
-cd ${0%/*} || exit 1    # Run from this directory
-
-ls | grep -P "^(([0-9]+\.?[0-9]*)|(\.[0-9]+))$" | xargs -d"\n" rm -rf
-rm -rf VTK
-rm -rf stl 
-
-#------------------------------------------------------------------------------

benchmarks/helicalMixer/helicalMixer_250K/runThisCase

@@ -1,30 +0,0 @@
-#!/bin/sh
-set -e  # Exit immediately if a command exits with a non-zero status
-cd ${0%/*} || exit 1    # Run from this directory
-
-echo "\n<--------------------------------------------------------------------->"
-echo "0) Copying stl files"
-echo "\n<--------------------------------------------------------------------->"
-mkdir -p stl
-cp -rfv $pFlow_PROJECT_DIR/resources/stls/helicalMixer/* ./stl/
-echo "\n<--------------------------------------------------------------------->"
-echo "1) Creating particles"
-echo "<--------------------------------------------------------------------->\n"
-particlesPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "2) Creating geometry"
-echo "<--------------------------------------------------------------------->\n"
-geometryPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "3) Running the case"
-echo "<--------------------------------------------------------------------->\n"
-sphereGranFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "4) Converting to VtK"
-echo "<--------------------------------------------------------------------->\n"
-pFlowToVTK -f diameter id velocity --binary
-
-#------------------------------------------------------------------------------

benchmarks/helicalMixer/helicalMixer_250K/settings/domainDict

@@ -1,49 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName  domainDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-// Simulation domain
-globalBox                                        
-{
-    min (-0.19  -0.19 -0.02);
-    max ( 0.19   0.26  0.92);
-}
-
-boundaries
-{
-    
-    left
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    right
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    bottom
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    top
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    rear
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    front
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-}

benchmarks/helicalMixer/helicalMixer_250K/settings/geometryDict

@@ -1,60 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */
-objectName  geometryDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-// motion model: rotating object around an axis
-motionModel rotatingAxis; 
-
-rotatingAxisInfo
-{
-    rotAxis 
-    {
-        // end points of axis
-        p1          (0 0 0);
-        p2          (0 0 1);
-        
-        // rotation speed (rad/s) => 30 rpm
-        omega       3.1428;      
-
-        // interval for rotation of axis 
-        startTime   2.5;
-        endTime     100;
-    }
-}
-
-surfaces
-{
-    
-    helix
-    {
-        type     stlWall;       // type of the wall
-        file     helix2.stl;    // file name in stl folder
-        material wallMat;       // material name of this wall
-        motion   rotAxis;       // motion component name 
-    }
-
-    shell
-    {
-        type     stlWall;       // type of the wall
-        file     shell2.stl;    // file name in stl folder      
-        material wallMat;       // material name of this wall
-        motion   none;          // motion component name 
-    }
-        
-    plug
-    {
-        type    planeWall;
-        p1      (-0.075 -0.185 0.375);
-        p2      ( 0.075 -0.185 0.375);
-        p3      ( 0.075 -0.185 0.525);
-        p4      (-0.075 -0.185 0.525);
-        material wallMat;
-        motion   none; 
-    }
-     
-}

benchmarks/helicalMixer/helicalMixer_250K/settings/particlesDict

@@ -1,27 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  particlesDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-setFields
-{
-    defaultValue 
-    {
-        velocity        realx3  (0 0 0);        // linear velocity (m/s)
-        acceleration    realx3  (0 0 0);        // linear acceleration (m/s2)
-        rVelocity       realx3  (0 0 0);        // rotational velocity (rad/s)
-        shapeName       word    smallParticle;  // name of the particle shape 
-    }
-
-    selectors
-    {}
-}
-
-positionParticles
-{
-    method empty;     // creates the required fields with zero particles (empty). 
-}

benchmarks/helicalMixer/helicalMixer_250K/settings/settingsDict

@@ -1,37 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName  settingsDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-run         		helicalMixer;
-
-dt                  0.00001;      // time step for integration (s)
-
-startTime           0;            // start time for simulation
-
-endTime             7.5;          // end time for simulation
-
-saveInterval        0.05;         // time interval for saving the simulation
-
-timePrecision       4;            // maximum number of digits for time folder
-
-g                 	(0 -9.8 0);   // gravity vector (m/s2)
-
-// save necessary (i.e., required) data on disk
-includeObjects 		(diameter);                       
-
-// exclude unnecessary data from saving on disk
-excludeObjects 		(); 
-
-integrationMethod   	AdamsBashforth2; // integration method
-
-integrationHistory      off;             // Do not save integration history on the disk 
-
-writeFormat             binary;          // data writting format (ascii or binary)
-
-timersReport            Yes;             // report timers (Yes or No)
-
-timersReportInterval    0.05;            // time interval for reporting timers

benchmarks/helicalMixer/helicalMixer_2m/caseSetup/interaction

@@ -1,53 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName interaction;
-objectType dicrionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-materials   (glassMat wallMat); // a list of materials names
-
-densities   (2500.0 2500);      // density of materials [kg/m3]
-
-contactListType   sortedContactList;
-
-model
-{
-   contactForceModel    nonLinearLimited;
-   
-   rollingFrictionModel normal;
-
-   Yeff (1.0e6 1.0e6  // Young modulus [Pa]
-               1.0e6);
-   
-   Geff (0.8e6 0.8e6  // Shear modulus [Pa]
-               0.8e6);
-
-   nu    (0.25 0.25  // Poisson's ratio [-]
-               0.25);
-
-   en (0.97  0.85   // coefficient of normal restitution
-             1.00);
-
-   mu (0.65  0.65   // dynamic friction 
-             0.65);
-
-   mur (0.1  0.1    // rolling friction 
-             0.1);
-        
-}
-
-contactSearch
-{
-    method         NBS;  
-
-    updateInterval   10;
-
-    sizeRatio       1.1;
-
-    cellExtent     0.55;
-
-    adjustableBox   Yes;     
-}

benchmarks/helicalMixer/helicalMixer_2m/caseSetup/particleInsertion

@@ -1,72 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  particleInsertion;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-active  yes;          // is insertion active?
-
-particleInlet1
-{
-   regionType     box; // type of insertion region
-   
-   rate           500000;  // insertion rate (particles/s)
-   
-   timeControl    simulationTime;
-   
-   startTime      0;      // (s)
-   
-   endTime        2.0;    // (s)
-   
-   insertionInterval    0.05;  //s  
-
-   boxInfo 
-   {
-        min (-0.17 0.23 0.46); // (m,m,m)
-        max ( 0.17 0.24 0.88); // (m,m,m)
-   }
-   
-   setFields
-   {
-        velocity    realx3 (0.0 -0.3 0.0); // initial velocity of inserted particles 
-   }
-   
-   mixture
-   {
-        smallParticle 1; // mixture composition of inserted particles 
-   }
-}
-
-particleInlet2
-{
-    regionType     box; // type of insertion region
-
-    rate           500000;  // insertion rate (particles/s)
-
-    timeControl    simulationTime;
-
-    startTime      0;      // (s)
-
-    endTime        2.0;    // (s)
-
-    insertionInterval    0.05;  //s  
-
-    boxInfo 
-    {
-        min ( -0.17 0.23 0.02); // (m,m,m)
-        max (  0.17 0.24 0.44); // (m,m,m)
-    }
-
-    setFields
-    {
-        velocity    realx3 (0.0 -0.3 0.0); // initial velocity of inserted particles 
-    }
-   
-   mixture
-   {
-        largeParticle 1; // mixture composition of inserted particles 
-   }
-}

benchmarks/helicalMixer/helicalMixer_2m/caseSetup/shapes

@@ -1,12 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  shapes;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-names       (smallParticle largeParticle);  // names of shapes 
-diameters   (0.003 0.00301);                // diameter of shapes 
-materials   (glassMat glassMat);            // material names for shapes 

benchmarks/helicalMixer/helicalMixer_2m/cleanThisCase

@@ -1,7 +0,0 @@
-#!/bin/sh
-cd ${0%/*} || exit 1    # Run from this directory
-
-ls | grep -P "^(([0-9]+\.?[0-9]*)|(\.[0-9]+))$" | xargs -d"\n" rm -rf
-rm -rf VTK 
-rm -rf stl
-#------------------------------------------------------------------------------

benchmarks/helicalMixer/helicalMixer_2m/runThisCase

@@ -1,32 +0,0 @@
-#!/bin/sh
-
-set -e  # Exit immediately if a command exits with a non-zero status
-cd ${0%/*} || exit 1    # Run from this directory
-
-echo "\n<--------------------------------------------------------------------->"
-echo "0) Copying stl files"
-echo "\n<--------------------------------------------------------------------->"
-mkdir -p stl
-cp -rfv $pFlow_PROJECT_DIR/resources/stls/helicalMixer/* ./stl/
-
-echo "\n<--------------------------------------------------------------------->"
-echo "1) Creating particles"
-echo "<--------------------------------------------------------------------->\n"
-particlesPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "2) Creating geometry"
-echo "<--------------------------------------------------------------------->\n"
-geometryPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "3) Running the case"
-echo "<--------------------------------------------------------------------->\n"
-sphereGranFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "4) Converting to VtK"
-echo "<--------------------------------------------------------------------->\n"
-pFlowToVTK -f diameter id velocity --binary
-
-#------------------------------------------------------------------------------

benchmarks/helicalMixer/helicalMixer_2m/settings/domainDict

@@ -1,49 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName  domainDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-// Simulation domain
-globalBox                                        
-{
-    min (-0.19  -0.19 -0.02);
-    max ( 0.19   0.26  0.92);
-}
-
-boundaries
-{
-    
-    left
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    right
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    bottom
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    top
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    rear
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    front
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-}

benchmarks/helicalMixer/helicalMixer_2m/settings/geometryDict

@@ -1,60 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */
-objectName  geometryDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-// motion model: rotating object around an axis
-motionModel rotatingAxis; 
-
-rotatingAxisInfo
-{
-    rotAxis 
-    {
-        // end points of axis
-        p1          (0 0 0);
-        p2          (0 0 1);
-        
-        // rotation speed (rad/s) => 30 rpm
-        omega       3.1428;      
-
-        // interval for rotation of axis 
-        startTime   2.5;
-        endTime     100;
-    }
-}
-
-surfaces
-{
-    
-    helix
-    {
-        type     stlWall;       // type of the wall
-        file     helix2.stl;    // file name in stl folder
-        material wallMat;       // material name of this wall
-        motion   rotAxis;       // motion component name 
-    }
-
-    shell
-    {
-        type     stlWall;       // type of the wall
-        file     shell2.stl;    // file name in stl folder      
-        material wallMat;       // material name of this wall
-        motion   none;          // motion component name 
-    }
-        
-    plug
-    {
-        type    planeWall;
-        p1      (-0.075 -0.185 0.375);
-        p2      ( 0.075 -0.185 0.375);
-        p3      ( 0.075 -0.185 0.525);
-        p4      (-0.075 -0.185 0.525);
-        material wallMat;
-        motion   none; 
-    }
-     
-}

benchmarks/helicalMixer/helicalMixer_2m/settings/particlesDict

@@ -1,27 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  particlesDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-setFields
-{
-    defaultValue 
-    {
-        velocity        realx3  (0 0 0);        // linear velocity (m/s)
-        acceleration    realx3  (0 0 0);        // linear acceleration (m/s2)
-        rVelocity       realx3  (0 0 0);        // rotational velocity (rad/s)
-        shapeName       word    smallParticle;  // name of the particle shape 
-    }
-
-    selectors
-    {}
-}
-
-positionParticles
-{
-    method empty;     // creates the required fields with zero particles (empty). 
-}

benchmarks/helicalMixer/helicalMixer_2m/settings/settingsDict

@@ -1,37 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName  settingsDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-run         		helicalMixer;
-
-dt                  0.00001;      // time step for integration (s)
-
-startTime           0;            // start time for simulation
-
-endTime             7.5;          // end time for simulation
-
-saveInterval        0.05;         // time interval for saving the simulation
-
-timePrecision       4;            // maximum number of digits for time folder
-
-g                 	(0 -9.8 0);   // gravity vector (m/s2)
-
-// save necessary (i.e., required) data on disk
-includeObjects 		(diameter);                       
-
-// exclude unnecessary data from saving on disk
-excludeObjects 		(); 
-
-integrationMethod   	AdamsBashforth2; // integration method
-
-integrationHistory      off;             // Do not save integration history on the disk 
-
-writeFormat             binary;          // data writting format (ascii or binary)
-
-timersReport            Yes;             // report timers (Yes or No)
-
-timersReportInterval    0.05;            // time interval for reporting timers

benchmarks/helicalMixer/helicalMixer_4m/caseSetup/interaction

@@ -1,53 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName interaction;
-objectType dicrionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-materials   (glassMat wallMat); // a list of materials names
-
-densities   (2500.0 2500);      // density of materials [kg/m3]
-
-contactListType   sortedContactList;
-
-model
-{
-   contactForceModel    nonLinearLimited;
-   
-   rollingFrictionModel normal;
-
-   Yeff (1.0e6 1.0e6  // Young modulus [Pa]
-               1.0e6);
-   
-   Geff (0.8e6 0.8e6  // Shear modulus [Pa]
-               0.8e6);
-
-   nu    (0.25 0.25  // Poisson's ratio [-]
-               0.25);
-
-   en (0.97  0.85   // coefficient of normal restitution
-             1.00);
-
-   mu (0.65  0.65   // dynamic friction 
-             0.65);
-
-   mur (0.1  0.1    // rolling friction 
-             0.1);
-        
-}
-
-contactSearch
-{
-    method         NBS;  
-
-    updateInterval   10;
-
-    sizeRatio       1.1;
-
-    cellExtent     0.55;
-
-    adjustableBox   Yes;     
-}

benchmarks/helicalMixer/helicalMixer_4m/caseSetup/particleInsertion

@@ -1,72 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  particleInsertion;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-active  yes;          // is insertion active?
-
-particleInlet1
-{
-   regionType     box; // type of insertion region
-   
-   rate           1000000;  // insertion rate (particles/s)
-   
-   timeControl    simulationTime;
-   
-   startTime      0;      // (s)
-   
-   endTime        2.0;    // (s)
-   
-   insertionInterval    0.05;  //s  
-
-   boxInfo 
-   {
-        min (-0.17 0.23 0.46); // (m,m,m)
-        max ( 0.17 0.24 0.88); // (m,m,m)
-   }
-   
-   setFields
-   {
-        velocity    realx3 (0.0 -0.3 0.0); // initial velocity of inserted particles 
-   }
-   
-   mixture
-   {
-        smallParticle 1; // mixture composition of inserted particles 
-   }
-}
-
-particleInlet2
-{
-    regionType     box; // type of insertion region
-
-    rate           1000000;  // insertion rate (particles/s)
-
-    timeControl    simulationTime;
-
-    startTime      0;      // (s)
-
-    endTime        2.0;    // (s)
-
-    insertionInterval    0.05;  //s  
-
-    boxInfo 
-    {
-        min ( -0.17 0.23 0.02); // (m,m,m)
-        max (  0.17 0.24 0.44); // (m,m,m)
-    }
-
-    setFields
-    {
-        velocity    realx3 (0.0 -0.3 0.0); // initial velocity of inserted particles 
-    }
-   
-   mixture
-   {
-        largeParticle 1; // mixture composition of inserted particles 
-   }
-}

benchmarks/helicalMixer/helicalMixer_4m/caseSetup/shapes

@@ -1,12 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  shapes;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-names       (smallParticle largeParticle);  // names of shapes 
-diameters   (0.002 0.00201);                // diameter of shapes 
-materials   (glassMat glassMat);            // material names for shapes 

benchmarks/helicalMixer/helicalMixer_4m/cleanThisCase

@@ -1,7 +0,0 @@
-#!/bin/sh
-cd ${0%/*} || exit 1    # Run from this directory
-
-ls | grep -P "^(([0-9]+\.?[0-9]*)|(\.[0-9]+))$" | xargs -d"\n" rm -rf
-rm -rf VTK 
-rm -rf stl
-#------------------------------------------------------------------------------

benchmarks/helicalMixer/helicalMixer_4m/runThisCase

@@ -1,32 +0,0 @@
-#!/bin/sh
-
-set -e  # Exit immediately if a command exits with a non-zero status
-cd ${0%/*} || exit 1    # Run from this directory
-
-echo "\n<--------------------------------------------------------------------->"
-echo "0) Copying stl files"
-echo "\n<--------------------------------------------------------------------->"
-mkdir -p stl
-cp -rfv $pFlow_PROJECT_DIR/resources/stls/helicalMixer/* ./stl/
-
-echo "\n<--------------------------------------------------------------------->"
-echo "1) Creating particles"
-echo "<--------------------------------------------------------------------->\n"
-particlesPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "2) Creating geometry"
-echo "<--------------------------------------------------------------------->\n"
-geometryPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "3) Running the case"
-echo "<--------------------------------------------------------------------->\n"
-sphereGranFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "4) Converting to VtK"
-echo "<--------------------------------------------------------------------->\n"
-pFlowToVTK -f diameter id velocity --binary
-
-#------------------------------------------------------------------------------

benchmarks/helicalMixer/helicalMixer_4m/settings/domainDict

@@ -1,49 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName  domainDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-// Simulation domain
-globalBox                                        
-{
-    min (-0.19  -0.19 -0.02);
-    max ( 0.19   0.26  0.92);
-}
-
-boundaries
-{
-    
-    left
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    right
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    bottom
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    top
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    rear
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    front
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-}

benchmarks/helicalMixer/helicalMixer_4m/settings/geometryDict

@@ -1,60 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */
-objectName  geometryDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-// motion model: rotating object around an axis
-motionModel rotatingAxis; 
-
-rotatingAxisInfo
-{
-    rotAxis 
-    {
-        // end points of axis
-        p1          (0 0 0);
-        p2          (0 0 1);
-        
-        // rotation speed (rad/s) => 30 rpm
-        omega       3.1428;      
-
-        // interval for rotation of axis 
-        startTime   2.5;
-        endTime     100;
-    }
-}
-
-surfaces
-{
-    
-    helix
-    {
-        type     stlWall;       // type of the wall
-        file     helix2.stl;    // file name in stl folder
-        material wallMat;       // material name of this wall
-        motion   rotAxis;       // motion component name 
-    }
-
-    shell
-    {
-        type     stlWall;       // type of the wall
-        file     shell2.stl;    // file name in stl folder      
-        material wallMat;       // material name of this wall
-        motion   none;          // motion component name 
-    }
-        
-    plug
-    {
-        type    planeWall;
-        p1      (-0.075 -0.185 0.375);
-        p2      ( 0.075 -0.185 0.375);
-        p3      ( 0.075 -0.185 0.525);
-        p4      (-0.075 -0.185 0.525);
-        material wallMat;
-        motion   none; 
-    }
-     
-}

benchmarks/helicalMixer/helicalMixer_4m/settings/particlesDict

@@ -1,27 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  particlesDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-setFields
-{
-    defaultValue 
-    {
-        velocity        realx3  (0 0 0);        // linear velocity (m/s)
-        acceleration    realx3  (0 0 0);        // linear acceleration (m/s2)
-        rVelocity       realx3  (0 0 0);        // rotational velocity (rad/s)
-        shapeName       word    smallParticle;  // name of the particle shape 
-    }
-
-    selectors
-    {}
-}
-
-positionParticles
-{
-    method empty;     // creates the required fields with zero particles (empty). 
-}

benchmarks/helicalMixer/helicalMixer_4m/settings/settingsDict

@@ -1,37 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName  settingsDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-run         		helicalMixer;
-
-dt                  0.00001;      // time step for integration (s)
-
-startTime           0;            // start time for simulation
-
-endTime             7.5;          // end time for simulation
-
-saveInterval        0.05;         // time interval for saving the simulation
-
-timePrecision       4;            // maximum number of digits for time folder
-
-g                 	(0 -9.8 0);   // gravity vector (m/s2)
-
-// save necessary (i.e., required) data on disk
-includeObjects 		(diameter);                       
-
-// exclude unnecessary data from saving on disk
-excludeObjects 		(); 
-
-integrationMethod   	AdamsBashforth2; // integration method
-
-integrationHistory      off;             // Do not save integration history on the disk 
-
-writeFormat             binary;          // data writting format (ascii or binary)
-
-timersReport            Yes;             // report timers (Yes or No)
-
-timersReportInterval    0.05;            // time interval for reporting timers

benchmarks/helicalMixer/helicalMixer_500k/caseSetup/interaction

@@ -1,53 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName interaction;
-objectType dicrionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-materials   (glassMat wallMat); // a list of materials names
-
-densities   (2500.0 2500);      // density of materials [kg/m3]
-
-contactListType   sortedContactList;
-
-model
-{
-   contactForceModel    nonLinearLimited;
-   
-   rollingFrictionModel normal;
-
-   Yeff (1.0e6 1.0e6  // Young modulus [Pa]
-               1.0e6);
-   
-   Geff (0.8e6 0.8e6  // Shear modulus [Pa]
-               0.8e6);
-
-   nu    (0.25 0.25  // Poisson's ratio [-]
-               0.25);
-
-   en (0.97  0.85   // coefficient of normal restitution
-             1.00);
-
-   mu (0.65  0.65   // dynamic friction 
-             0.65);
-
-   mur (0.1  0.1    // rolling friction 
-             0.1);
-        
-}
-
-contactSearch
-{
-    method         NBS;  
-
-    updateInterval   10;
-
-    sizeRatio       1.1;
-
-    cellExtent     0.55;
-
-    adjustableBox   Yes;     
-}

benchmarks/helicalMixer/helicalMixer_500k/caseSetup/particleInsertion

@@ -1,72 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  particleInsertion;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-active  yes;          // is insertion active?
-
-particleInlet1
-{
-   regionType     box; // type of insertion region
-   
-   rate           125000;  // insertion rate (particles/s)
-   
-   timeControl    simulationTime;
-   
-   startTime      0;      // (s)
-   
-   endTime        2.0;    // (s)
-   
-   insertionInterval    0.05;  //s  
-
-   boxInfo 
-   {
-        min (-0.17 0.23 0.46); // (m,m,m)
-        max ( 0.17 0.24 0.88); // (m,m,m)
-   }
-   
-   setFields
-   {
-        velocity    realx3 (0.0 -0.3 0.0); // initial velocity of inserted particles 
-   }
-   
-   mixture
-   {
-        smallParticle 1; // mixture composition of inserted particles 
-   }
-}
-
-particleInlet2
-{
-    regionType     box; // type of insertion region
-
-    rate           125000;  // insertion rate (particles/s)
-
-    timeControl    simulationTime;
-
-    startTime      0;      // (s)
-
-    endTime        2.0;    // (s)
-
-    insertionInterval    0.05;  //s  
-
-    boxInfo 
-    {
-        min ( -0.17 0.23 0.02); // (m,m,m)
-        max (  0.17 0.24 0.44); // (m,m,m)
-    }
-
-    setFields
-    {
-        velocity    realx3 (0.0 -0.3 0.0); // initial velocity of inserted particles 
-    }
-   
-   mixture
-   {
-        largeParticle 1; // mixture composition of inserted particles 
-   }
-}

benchmarks/helicalMixer/helicalMixer_500k/caseSetup/shapes

@@ -1,12 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  shapes;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-names       (smallParticle largeParticle);  // names of shapes 
-diameters   (0.005 0.00501);                // diameter of shapes 
-materials   (glassMat glassMat);            // material names for shapes 

benchmarks/helicalMixer/helicalMixer_500k/cleanThisCase

@@ -1,7 +0,0 @@
-#!/bin/sh
-cd ${0%/*} || exit 1    # Run from this directory
-
-ls | grep -P "^(([0-9]+\.?[0-9]*)|(\.[0-9]+))$" | xargs -d"\n" rm -rf
-rm -rf VTK 
-rm -rf stl
-#------------------------------------------------------------------------------

benchmarks/helicalMixer/helicalMixer_500k/runThisCase

@@ -1,32 +0,0 @@
-#!/bin/sh
-
-set -e  # Exit immediately if a command exits with a non-zero status
-cd ${0%/*} || exit 1    # Run from this directory
-
-echo "\n<--------------------------------------------------------------------->"
-echo "0) Copying stl files"
-echo "\n<--------------------------------------------------------------------->"
-mkdir -p stl
-cp -rfv $pFlow_PROJECT_DIR/resources/stls/helicalMixer/* ./stl/
-
-echo "\n<--------------------------------------------------------------------->"
-echo "1) Creating particles"
-echo "<--------------------------------------------------------------------->\n"
-particlesPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "2) Creating geometry"
-echo "<--------------------------------------------------------------------->\n"
-geometryPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "3) Running the case"
-echo "<--------------------------------------------------------------------->\n"
-sphereGranFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "4) Converting to VtK"
-echo "<--------------------------------------------------------------------->\n"
-pFlowToVTK -f diameter id velocity --binary
-
-#------------------------------------------------------------------------------

benchmarks/helicalMixer/helicalMixer_500k/settings/domainDict

@@ -1,49 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName  domainDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-// Simulation domain
-globalBox                                        
-{
-    min (-0.19  -0.19 -0.02);
-    max ( 0.19   0.26  0.92);
-}
-
-boundaries
-{
-    
-    left
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    right
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    bottom
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    top
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    rear
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-
-    front
-    {
-        type     exit;        // other options: periodic, reflective 
-    }
-}

benchmarks/helicalMixer/helicalMixer_500k/settings/geometryDict

@@ -1,60 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */
-objectName  geometryDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-// motion model: rotating object around an axis
-motionModel rotatingAxis; 
-
-rotatingAxisInfo
-{
-    rotAxis 
-    {
-        // end points of axis
-        p1          (0 0 0);
-        p2          (0 0 1);
-        
-        // rotation speed (rad/s) => 30 rpm
-        omega       3.1428;      
-
-        // interval for rotation of axis 
-        startTime   2.5;
-        endTime     100;
-    }
-}
-
-surfaces
-{
-    
-    helix
-    {
-        type     stlWall;       // type of the wall
-        file     helix2.stl;    // file name in stl folder
-        material wallMat;       // material name of this wall
-        motion   rotAxis;       // motion component name 
-    }
-
-    shell
-    {
-        type     stlWall;       // type of the wall
-        file     shell2.stl;    // file name in stl folder      
-        material wallMat;       // material name of this wall
-        motion   none;          // motion component name 
-    }
-        
-    plug
-    {
-        type    planeWall;
-        p1      (-0.075 -0.185 0.375);
-        p2      ( 0.075 -0.185 0.375);
-        p3      ( 0.075 -0.185 0.525);
-        p4      (-0.075 -0.185 0.525);
-        material wallMat;
-        motion   none; 
-    }
-     
-}

benchmarks/helicalMixer/helicalMixer_500k/settings/particlesDict

@@ -1,27 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-objectName  particlesDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-
-setFields
-{
-    defaultValue 
-    {
-        velocity        realx3  (0 0 0);        // linear velocity (m/s)
-        acceleration    realx3  (0 0 0);        // linear acceleration (m/s2)
-        rVelocity       realx3  (0 0 0);        // rotational velocity (rad/s)
-        shapeName       word    smallParticle;  // name of the particle shape 
-    }
-
-    selectors
-    {}
-}
-
-positionParticles
-{
-    method empty;     // creates the required fields with zero particles (empty). 
-}

benchmarks/helicalMixer/helicalMixer_500k/settings/settingsDict

@@ -1,37 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName  settingsDict;
-objectType  dictionary;
-fileFormat  ASCII;
-/*---------------------------------------------------------------------------*/
-run         		helicalMixer;
-
-dt                  0.00001;      // time step for integration (s)
-
-startTime           0;            // start time for simulation
-
-endTime             7.5;          // end time for simulation
-
-saveInterval        0.05;         // time interval for saving the simulation
-
-timePrecision       4;            // maximum number of digits for time folder
-
-g                 	(0 -9.8 0);   // gravity vector (m/s2)
-
-// save necessary (i.e., required) data on disk
-includeObjects 		(diameter);                       
-
-// exclude unnecessary data from saving on disk
-excludeObjects 		(); 
-
-integrationMethod   	AdamsBashforth2; // integration method
-
-integrationHistory      off;             // Do not save integration history on the disk 
-
-writeFormat             binary;          // data writting format (ascii or binary)
-
-timersReport            Yes;             // report timers (Yes or No)
-
-timersReportInterval    0.05;            // time interval for reporting timers

benchmarks/helicalMixer/readme.md

@@ -1,101 +0,0 @@
-# Helical Mixer Benchmark (phasicFlow v-1.0)
-
-## Overview
-
-This benchmark compares the performance of phasicFlow with a well-stablished commercial DEM software for simulating a helical mixer with varying particle counts (250k to 4M particles). The benchmark measures both computational efficiency and memory usage across different hardware configurations.
-
-**Summary of Results:**
-
-- phasicFlow achieves similar performance to the commercial DEM software on the same hardware.
-- phasicFlow shows a 30% performance improvement when using the NVIDIA RTX A4000 compared to the RTX 4050Ti.
-- Memory usage is approximately 50% lower in phasicFlow compared to the commercial software, with phasicFlow using about 0.7 GB of memory per million particles, while the commercial software uses about 1.5 GB per million particles.
-
-## Simulation Setup
-
-<div align="center">
-    <img src="./images/commericalDEMsnapshot.png"/>
-    <div align="center">  
-        <p>Figure 1. Commercial DEM simulation snapshot</p>
-    </div>
-</div>
-
-<div align="center">
-    <img src="./images/phasicFlow_snapshot.png"/>
-    <div align="center">  
-        <p>Figure 2. phasicFlow simulation snapshot and visualized using Paraview</p>
-    </div>
-</div>
-
-### Hardware Specifications
-
-<div align="center">
-    Table 1. Hardware specifications used for benchmarking.
-</div>
-
-|  System     |           CPU            |             GPU              | Operating System |
-| :---------: | :----------------------: | :--------------------------: | :--------------: |
-|   Laptop    | Intel i9-13900HX 2.2 GHz | NVIDIA GeForce RTX 4050Ti 6G | Windows 11 24H2  |
-| Workstation | Intel Xeon 4210 2.2 GHz  |     NVIDIA RTX A4000 16G     |   Ubuntu 22.04   |
-
-### Simulation Parameters
-
-<div align="center">
-    Table 2. Parameters for helical mixer simulations.
-</div>
-
-| Case     | Particle Diameter | Particle Count | 
-| :-------: | :---------------: | :--------------: | 
-| 250k     | 6 mm              | 250,000        | 
-| 500k     | 5 mm              | 500,000        | 
-| 1M       | 4 mm              | 1,000,000      | 
-| 2M       | 3 mm              | 2,000,000      | 
-| 4M       | 2 mm              | 4,000,000      |
-
-The time step for all simulations was set to 1.0e-5 seconds and the simulation ran for 7.5 seconds.
-
-## Performance Comparison
-
-### Execution Time
-
-<div align="center">
-    Table 3. Total calculation time (minutes) for different configurations.
-</div>
-
-|     Software      | 250k   | 500k   | 1M     | 2M     | 4M     | 
-| :---------------: | :----: | :-----: | :-----: | :-----: | :-----: |
-| phasicFlow-4050Ti | 110 min | 215 min | 413 min | - | -       | 
-| Commercial DEM-4050Ti | 111 min | 210 min | 415 min | - | -       | 
-| phasicFlow-A4000  | 82 min | 150 min  | 300 min | 613 min | 1236 min |
-
-The execution time scales linearly with particle count. phasicFlow demonstrates approximately:
-
-- the computing speed is basically the same as well-established commercial DEM software on the same hardware
-- 30% performance improvement when using the NVIDIA RTX A4000 compared to the RTX 4050Ti
-
-<div align="center">
-    <img src="./images/performance.png"/>
-    <p>Figure 3. Calculation time comparison between phasicFlow and the well-established commercial DEM software.</p>
-</div>
-
-### Memory Usage
-
-<div align="center">
-    Table 4. Memory consumption for different configurations.
-</div>
-
-|     Software      | 250k   | 500k   | 1M      | 2M      | 4M      | 
-| :---------------: | :-----: | :-----: | :-----: | :-----: | :-----: | 
-| phasicFlow-4050Ti | 260 MB  | 404 MB  | 710 MB  | - | -       | 
-| Commercial DEM-4050Ti | 460 MB | 920 MB | 1574 MB | - | -       | 
-| phasicFlow-A4000  | 352 MB  | 496 MB  | 802 MB  | 1376 MB | 2310 MB |
-
-Memory efficiency comparison:
-
-- phasicFlow uses approximately 0.7 GB of memory per million particles
-- Commercial DEM software uses approximately 1.5 GB of memory per million particles
-- phasicFlow shows ~50% lower memory consumption compared to the commercial alternative
-- The memory usage scales linearly with particle count in both software packages. But due to memory limitations on GPUs, it is possible to run larger simulation on GPUs with phasicFlow.
-
-## Run Your Own Benchmarks
-
-The simulation case setup files are available in this folder for users interested in performing similar benchmarks on their own hardware. These files can be used to reproduce the tests and compare performance across different systems.

benchmarks/helicalMixer_4MParticles/caseSetup/interaction

@@ -0,0 +1,59 @@
+/* -------------------------------*- C++ -*--------------------------------- *\ 
+|  phasicFlow File                                                            | 
+|  copyright: www.cemf.ir                                                     | 
+\* ------------------------------------------------------------------------- */ 
+
+objectName interaction;
+objectType dicrionary;
+
+materials   (glassMat wallMat); // a list of materials names
+densities   (2500.0 2500);      // density of materials [kg/m3]
+
+contactListType   sortedContactList;
+
+model
+{
+   contactForceModel nonLinearLimited;
+   rollingFrictionModel normal;
+
+   Yeff (1.0e6 1.0e6  // Young modulus [Pa]
+               1.0e6);
+   
+   Geff (0.8e6 0.8e6  // Shear modulus [Pa]
+               0.8e6);
+
+   nu    (0.25 0.25  // Poisson's ratio [-]
+               0.25);
+
+   en (0.97  0.85   // coefficient of normal restitution
+             1.00);
+
+   et (1.0   1.0    // coefficient of tangential restitution 
+             1.0);
+
+   mu (0.65  0.65   // dynamic friction 
+             0.65);
+
+   mur (0.1  0.1    // rolling friction 
+             0.1);
+        
+}
+
+contactSearch
+{
+   method         NBS;           
+   wallMapping    cellMapping;   
+
+   NBSInfo
+   {
+      updateFrequency 10;        // each 20 timesteps, update neighbor list 
+      sizeRatio      1.1;       // bounding box size to particle diameter (max)
+   }
+
+   cellMappingInfo
+   {
+      updateFrequency 10;        // each 20 timesteps, update neighbor list  
+      cellExtent     0.6;        // bounding box for particle-wall search (> 0.5)
+   }
+
+}

benchmarks/helicalMixer_4MParticles/caseSetup/particleInsertion

@@ -0,0 +1,67 @@
+/* -------------------------------*- C++ -*--------------------------------- *\ 
+|  phasicFlow File                                                            | 
+|  copyright: www.cemf.ir                                                     | 
+\* ------------------------------------------------------------------------- */ 
+
+objectName particleInsertion;
+objectType dicrionary;
+
+
+active  yes;          // is insertion active?
+
+collisionCheck No;   // not implemented for yes
+
+
+
+particleInlet1
+{
+   type		      boxRegion; // type of insertion region
+   rate 	         1000000;  // insertion rate (particles/s)
+   startTime 	   0;      // (s)
+   endTime   	   2.0;    // (s)
+   interval       0.05;  //s  
+
+   boxRegionInfo 
+   {
+   	min ( -0.17 0.23 0.46); // (m,m,m)
+   	max (  0.17 0.24 0.88); // (m,m,m)
+   }
+   
+   setFields
+   {
+     velocity    realx3 (0.0 -0.3 0.0); // initial velocity of inserted particles 
+   }
+   
+   mixture
+   {
+      smallParticle 1; // mixture composition of inserted particles 
+      
+   }
+}
+
+particleInlet2
+{
+   type           boxRegion; // type of insertion region
+   rate           1000000;  // insertion rate (particles/s)
+   startTime      0;      // (s)
+   endTime        2.0;    // (s)
+   interval       0.05;  //s  
+
+   boxRegionInfo 
+   {
+      min ( -0.17 0.23 0.02); // (m,m,m)
+      max (  0.17 0.24 0.44); // (m,m,m)
+   }
+   
+   setFields
+   {
+     velocity    realx3 (0.0 -0.3 0.0); // initial velocity of inserted particles 
+   }
+   
+   mixture
+   {
+      largeParticle 1; // mixture composition of inserted particles 
+      
+   }
+}
+

benchmarks/helicalMixer_4MParticles/caseSetup/sphereShape

@@ -0,0 +1,11 @@
+/* -------------------------------*- C++ -*--------------------------------- *\ 
+|  phasicFlow File                                                            | 
+|  copyright: www.cemf.ir                                                     | 
+\* ------------------------------------------------------------------------- */ 
+
+objectName 	sphereDict;
+objectType 	sphereShape;
+
+names 		(smallParticle largeParticle); 	// names of shapes 
+diameters 	(0.002 0.00201);				// diameter of shapes 
+materials	(glassMat glassMat);		// material names for shapes 

benchmarks/helicalMixer_4MParticles/runThisCase

@@ -0,0 +1,23 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+echo "\n<--------------------------------------------------------------------->"
+echo "1) Creating particles"
+echo "<--------------------------------------------------------------------->\n"
+particlesPhasicFlow
+
+echo "\n<--------------------------------------------------------------------->"
+echo "2) Creating geometry"
+echo "<--------------------------------------------------------------------->\n"
+geometryPhasicFlow
+
+echo "\n<--------------------------------------------------------------------->"
+echo "3) Running the case"
+echo "<--------------------------------------------------------------------->\n"
+sphereGranFlow
+
+echo "\n<--------------------------------------------------------------------->"
+echo "4) Converting to VtK"
+echo "<--------------------------------------------------------------------->\n"
+pFlowToVTK -f diameter id velocity
+
+#------------------------------------------------------------------------------

benchmarks/helicalMixer_4MParticles/settings/geometryDict

@@ -0,0 +1,56 @@
+/* -------------------------------*- C++ -*--------------------------------- *\ 
+|  phasicFlow File                                                            | 
+|  copyright: www.cemf.ir                                                     | 
+\* ------------------------------------------------------------------------- */  
+
+objectName 	geometryDict;
+objectType 	dictionary;
+
+// motion model: rotating object around an axis
+motionModel rotatingAxisMotion; 
+
+surfaces
+{
+	
+	helix
+	{
+		type 	 stlWall;   // type of the wall
+		file 	 helix2.stl;	// file name in stl folder
+		material wallMat;   // material name of this wall
+		motion 	 rotAxis;	// motion component name 
+	}
+
+	
+	shell
+	{
+		type 	 stlWall;  	// type of the wall
+		file 	 shell2.stl;	// file name in stl folder		
+		material wallMat;   // material name of this wall
+		motion 	 none;		// motion component name 
+	}
+
+		
+	plug
+	{
+		type 	planeWall;
+		p1 (-0.075 -0.185 0.375);
+		p2 ( 0.075 -0.185 0.375);
+		p3 ( 0.075 -0.185 0.525);
+		p4 (-0.075 -0.185 0.525);
+		material wallMat;   // material name of this wall
+		motion 	 none;		// motion component name 
+	}
+	
+	
+}
+
+// information for rotatingAxisMotion motion model 
+rotatingAxisMotionInfo
+{
+	rotAxis 
+	{
+		p1 ( 0 0 0);
+		p2 ( 0 0 1);
+		omega 0; //3.1428; 		// rotation speed (rad/s) => 30 rpm
+	}
+}

benchmarks/helicalMixer_4MParticles/settings/particlesDict

@@ -0,0 +1,31 @@
+/* -------------------------------*- C++ -*--------------------------------- *\ 
+|  phasicFlow File                                                            | 
+|  copyright: www.cemf.ir                                                     | 
+\* ------------------------------------------------------------------------- */  
+
+objectName 	particlesDict;
+objectType 	dictionary;
+
+setFields
+{
+	defaultValue 
+	{
+		velocity 		realx3 	(0 0 0); 		// linear velocity (m/s)
+		acceleration 	realx3 	(0 0 0); 		// linear acceleration (m/s2)
+		rotVelocity 	realx3 	(0 0 0);  		// rotational velocity (rad/s)
+		shapeName 		word	smallParticle; 	// name of the particle shape 
+	}
+
+	selectors
+	{}
+}
+
+// positions particles 
+positionParticles
+{
+	method empty;     		// creates the required fields with zero particles (empty). 
+
+	maxNumberOfParticles 	4100000; // maximum number of particles in the simulation
+	mortonSorting 			Yes;    // perform initial sorting based on morton code?   
+
+}

benchmarks/helicalMixer_4MParticles/settings/settingsDict

@@ -0,0 +1,36 @@
+/* -------------------------------*- C++ -*--------------------------------- *\ 
+|  phasicFlow File                                                            | 
+|  copyright: www.cemf.ir                                                     | 
+\* ------------------------------------------------------------------------- */  
+objectName 	settingsDict;
+objectType 	dictionary;;
+
+run 			inclinedScrewConveyor;
+
+dt 				0.00001; 	// time step for integration (s)
+
+startTime 		2.9; 			// start time for simulation 
+
+endTime 		7;			// end time for simulation 
+
+saveInterval 	0.05; 		// time interval for saving the simulation
+
+timePrecision   3;			// maximum number of digits for time folder 
+
+g 				(0 -9.8 0); // gravity vector (m/s2) 
+
+/*
+	Simulation domain 
+	every particles that goes outside this domain is deleted.
+*/
+domain 
+{
+	min (-0.19  -0.19 -0.02);
+	max ( 0.19   0.26  0.92);
+}
+
+integrationMethod 		AdamsBashforth2; 	// integration method 
+
+timersReport 			Yes;  	// report timers?
+
+timersReportInterval   	0.01;	// time interval for reporting timers

benchmarks/readme.md

@@ -1,9 +0,0 @@
-
-# Benchmarks
-
-Benchmakrs has been done on two different simulations: simulation with simple geometry (rotating drum) and a simulation with complex geometry (helical mixer). These benchmarks are used to show how PhasicFlow performs in different scenarios.
-
-- [rotating drum](./rotatingDrum/)
-- [helical mixer](./helicalMixer/)
-
-**Note:** If you have performed benchmarks with PhasicFlow using other hardware or software other than PhasicFlow, we would be happy to include them in this section. Please open an issue for more arrangements or send a pull request with the benchmarks results.

benchmarks/rotatingDrum/readme.md

@@ -1,102 +0,0 @@
-# Rotating Drum Benchmark (phasicFlow v-1.0)
-
-## Overview
-
-This benchmark compares the performance of phasicFlow with a well-stablished commercial DEM software for simulating a rotating drum with varying particle counts (250k to 8M particles). The benchmark measures both computational efficiency and memory usage across different hardware configurations.
-
-**Summary of Results:**
-
-- phasicFlow achieves approximately 20% faster calculation than the commercial DEM software on the same hardware.
-- phasicFlow shows a 30% performance improvement when using the NVIDIA RTX A4000 compared to the RTX 4050Ti.
-- Memory usage is approximately 42% lower in phasicFlow compared to the commercial software, with phasicFlow using about 0.7 GB of memory per million particles, while the commercial software uses about 1.2 GB per million particles
-
-## Simulation Setup
-
-<div align="center">
-    <img src="./images/commericalDEMsnapshot.png"/>
-    <div align="center">  
-        <p>Figure 1. Commercial DEM simulation snapshot</p>
-    </div>
-</div>
-
-<div align="center">
-    <img src="./images/phasicFlow_snapshot.png"/>
-    <div align="center">  
-        <p>Figure 2. phasicFlow simulation snapshot and visualized using Paraview</p>
-    </div>
-</div>
-
-### Hardware Specifications
-
-<div align="center">
-    Table 1. Hardware specifications used for benchmarking.
-</div>
-
-|  System     |           CPU            |             GPU              | Operating System |
-| :---------: | :----------------------: | :--------------------------: | :--------------: |
-|   Laptop    | Intel i9-13900HX 2.2 GHz | NVIDIA GeForce RTX 4050Ti 6G | Windows 11 24H2  |
-| Workstation | Intel Xeon 4210 2.2 GHz  |     NVIDIA RTX A4000 16G     |   Ubuntu 22.04   |
-
-### Simulation Parameters
-
-<div align="center">
-    Table 2. Parameters for rotating drum simulations.
-</div>
-
-| Case     | Particle Diameter | Particle Count | Drum Length | Drum Radius |
-| :-------: | :---------------: | :--------------: | :------------------: | :------------------: |
-| 250k     | 6 mm              | 250,000        | 0.8 m       | 0.2 m       |
-| 500k     | 5 mm              | 500,000        | 0.8 m       | 0.2 m       |
-| 1M       | 4 mm              | 1,000,000      | 0.8 m       | 0.2 m       |
-| 2M       | 3 mm              | 2,000,000      | 1.2 m       | 0.2 m       |
-| 4M       | 3 mm              | 4,000,000      | 1.6 m       | 0.2 m       |
-| 8M       | 2 mm              | 8,000,000      | 1.6 m       | 0.2 m       |
-
-The time step for all simulations was set to 1.0e-5 seconds and the simulation ran for 4 seconds.
-
-## Performance Comparison
-
-### Execution Time
-
-<div align="center">
-    Table 3. Total calculation time (minutes) for different configurations.
-</div>
-
-|     Software      | 250k   | 500k   | 1M     | 2M     | 4M     | 8M      |
-| :---------------: | :----: | :-----: | :-----: | :-----: | :-----: | :------: |
-| phasicFlow-4050Ti | 54 min | 111 min | 216 min | 432 min | -       | -        |
-| Commercial DEM-4050Ti | 68 min | 136 min | 275 min | 570 min | -       | -        |
-| phasicFlow-A4000  | 38 min | 73 min  | 146 min | 293 min | 589 min | 1188 min |
-
-The execution time scales linearly with particle count. phasicFlow demonstrates approximately:
-
-- 20% faster calculation than the well-established commercial DEM software on the same hardware
-- 30% performance improvement when using the NVIDIA RTX A4000 compared to the RTX 4050Ti
-
-<div align="center">
-    <img src="./images/performance1.png"/>
-    <p>Figure 3. Calculation time comparison between phasicFlow and the well-established commercial DEM software.</p>
-</div>
-
-### Memory Usage
-
-<div align="center">
-    Table 4. Memory consumption for different configurations.
-</div>
-
-|     Software      | 250k   | 500k   | 1M      | 2M      | 4M      | 8M      |
-| :---------------: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: |
-| phasicFlow-4050Ti | 252 MB  | 412 MB  | 710 MB  | 1292 MB | -       | -       |
-| Commercial DEM-4050Ti | 485 MB | 897 MB | 1525 MB | 2724 MB | -       | -       |
-| phasicFlow-A4000  | 344 MB  | 480 MB  | 802 MB  | 1386 MB | 2590 MB | 4966 MB |
-
-Memory efficiency comparison:
-
-- phasicFlow uses approximately 0.7 GB of memory per million particles
-- Commercial DEM software uses approximately 1.2 GB of memory per million particles
-- phasicFlow shows ~42% lower memory consumption compared to the commercial alternative
-- The memory usage scales linearly with particle count in both software packages. But due to memory limitations on GPUs, it is possible to run larger simulation on GPUs with phasicFlow.
-
-## Run Your Own Benchmarks
-
-The simulation case setup files are available in this folder for users interested in performing similar benchmarks on their own hardware. These files can be used to reproduce the tests and compare performance across different systems.

benchmarks/rotatingDrum/rotatingDrum_1mParticles/caseSetup/interaction

@@ -1,60 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-
-objectName     interaction;
-objectType     dictionary;
-fileFormat     ASCII;
-
-/*---------------------------------------------------------------------------*/
-
-materials   (glassMat wallMat); // a list of materials names
-
-densities   (2500.0 2500);      // density of materials [kg/m3]
-
-contactListType   sortedContactList;
-
-contactSearch
-{
-    method         NBS;
-
-    updateInterval   20;
-
-    sizeRatio       1.1;
-
-    cellExtent     0.55;
-
-    adjustableBox   Yes;
-}
-
-model
-{
-    contactForceModel    nonLinearLimited;
-
-    rollingFrictionModel normal;
-    
-    /*
-       Property (glassMat-glassMat      glassMat-wallMat
-                                        wallMat-wallMat);
-    */
-
-    Yeff (1.0e6  1.0e6  
-                 1.0e6);                                    // Young modulus [Pa]
-   
-    Geff (0.8e6  0.8e6  
-                 0.8e6);                                    // Shear modulus [Pa]
-
-    nu   (0.25   0.25  
-                 0.25);                                     // Poisson's ratio [-]
-
-    en   (0.97   0.85   
-                 1.00);                                     // coefficient of normal restitution
-
-    mu   (0.65   0.65   
-                 0.65);                                     // dynamic friction 
-
-    mur  (0.1    0.1    
-                 0.1);                                      // rolling friction 
-}
-

benchmarks/rotatingDrum/rotatingDrum_1mParticles/caseSetup/shapes

@@ -1,15 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-
-objectName     shapes;
-objectType     dictionary;
-fileFormat     ASCII;
-/*---------------------------------------------------------------------------*/
-
-names          (glassBead);    // names of shapes 
-
-diameters      (0.004);        // diameter of shapes 
-
-materials      (glassMat);     // material names for shapes 

benchmarks/rotatingDrum/rotatingDrum_1mParticles/runThisCase

@@ -1,22 +0,0 @@
-#!/bin/sh
-set -e  # Exit immediately if a command exits with a non-zero status
-cd ${0%/*} || exit 1    # Run from this directory
-echo "\n<--------------------------------------------------------------------->"
-echo "1) Creating particles"
-echo "<--------------------------------------------------------------------->\n"
-particlesPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "2) Creating geometry"
-echo "<--------------------------------------------------------------------->\n"
-geometryPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "3) Running the case"
-echo "<--------------------------------------------------------------------->\n"
-sphereGranFlow
-
-
-
-
-#------------------------------------------------------------------------------

benchmarks/rotatingDrum/rotatingDrum_1mParticles/settings/domainDict

@@ -1,50 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName     domainDict;
-objectType     dictionary;
-fileFormat     ASCII;
-/*---------------------------------------------------------------------------*/
-globalBox                                        // Simulation domain: every particles that goes outside this domain will be deleted
-{
-    min (-0.2 -0.2  0.0);
-    max ( 0.2  0.2  0.8);
-}
-
-boundaries
-{
-    neighborListUpdateInterval 200;
-    
-    updateInterval              20;
-    
-    left
-    {
-        type    exit;                            // other options: periodic, reflective 
-    }
-
-    right
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-
-    bottom
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-
-    top
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-
-    rear
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-
-    front
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-}

benchmarks/rotatingDrum/rotatingDrum_1mParticles/settings/geometryDict

@@ -1,86 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-
-objectName     geometryDict;
-objectType     dictionary;
-fileFormat     ASCII;
-
-motionModel rotatingAxis;         // motion model: rotating object around an axis
-
-rotatingAxisInfo                  // information for rotatingAxisMotion motion model 
-{
-    rotAxis 
-    {
-        p1    (0.0 0.0 0.0);      // first point for the axis of rotation    
-        
-        p2    (0.0 0.0 1.0);      // second point for the axis of rotation    
-        
-        omega 1.256;              // rotation speed (rad/s) => 12 rpm
-    }
-}
-
-surfaces
-{
-    cylinder
-    {
-        type        cylinderWall;          // type of the wall
-        
-        p1          (0.0 0.0 0.0);         // begin point of cylinder axis
-           
-        p2          (0.0 0.0 0.8);         // end point of cylinder axis
-        
-        radius1     0.2;                   // radius at p1
-        
-        radius2     0.2;                   // radius at p2
-        
-        resolution  60;                    // number of divisions
-        
-        material    wallMat;               // material name of this wall
-        
-        motion      rotAxis;               // motion component name 
-    }
-
-    /*
-        This is a plane wall at the rear end of cylinder
-    */
-    
-    wall1
-    {
-        type      planeWall;               // type of the wall  
-        
-        p1        (-0.2 -0.2 0.0);         // first point of the wall
-        
-        p2        ( 0.2 -0.2 0.0);         // second point
-        
-        p3        ( 0.2  0.2 0.0);         // third point
-        
-        p4        (-0.2  0.2 0.0);         // fourth point 
-        
-        material  wallMat;                 // material name of the wall  
-        
-        motion    rotAxis;                 // motion component name 
-    }
-
-    /*
-        This is a plane wall at the front end of cylinder
-    */
-    
-    wall2
-    {
-        type      planeWall;               // type of the wall
-        
-        p1        (-0.2 -0.2 0.8);         // first point of the wall
-        
-        p2        ( 0.2 -0.2 0.8);         // second point
-        
-        p3        ( 0.2  0.2 0.8);         // third point
-        
-        p4        (-0.2  0.2 0.8);         // fourth point 
-        
-        material  wallMat;                 // material name of the wall  
-        
-        motion    rotAxis;                 // motion component name 
-    }
-}

benchmarks/rotatingDrum/rotatingDrum_1mParticles/settings/particlesDict

@@ -1,47 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-
-objectName     particlesDict;
-objectType     dictionary;
-fileFormat     ASCII;
-
-setFields
-{
-    defaultValue 
-    {
-        velocity         realx3     (0 0 0);     // linear velocity (m/s)
-        acceleration     realx3     (0 0 0);     // linear acceleration (m/s2)
-        rotVelocity      realx3     (0 0 0);     // rotational velocity (rad/s)
-        shapeName        word       glassBead;   // name of the particle shape 
-    }
-
-    selectors
-    {}
-}
-
-positionParticles
-{
-    method ordered;
-
-    orderedInfo
-    {
-        distance   0.004;           // minimum space between centers of particles
-        
-        numPoints  1000000;          // number of particles in the simulation 
-        
-        axisOrder  (z x y);         // axis order for filling the space with particles
-    }
-
-    regionType cylinder;            // other options: box and sphere    
-
-    cylinderInfo                    // cylinder for positioning particles 
-    {
-        p1     (0.0  0.0  0.01);    // lower corner point of the box 
-        
-        p2     (0.0  0.0  0.79);    // upper corner point of the box 
-        
-        radius 0.195;               // radius of cylinder 
-    }
-}

benchmarks/rotatingDrum/rotatingDrum_1mParticles/settings/settingsDict

@@ -1,34 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName    settingsDict;
-objectType    dictionary;
-fileFormat    ASCII;
-/*---------------------------------------------------------------------------*/
-run             rotatingDrum_1mParticles;
-
-dt              0.00001;      // time step for integration (s)
-
-startTime       0;            // start time for simulation 
-
-endTime         4;           // end time for simulation 
-
-saveInterval    0.2;          // time interval for saving the simulation
-
-timePrecision   5;            // maximum number of digits for time folder 
-
-g               (0 -9.8 0);   // gravity vector (m/s2) 
-
-includeObjects (diameter);                     // save necessary (i.e., required) data on disk
-
-// exclude unnecessary data from saving on disk
-excludeObjects (rVelocity.dy1 pStructPosition.dy1 pStructVelocity.dy1); 
-
-integrationMethod         AdamsBashforth2;     // integration method 
-
-writeFormat               binary;              // data writting format (ascii or binary)
-
-timersReport              Yes;      
-
-timersReportInterval      0.01;    

benchmarks/rotatingDrum/rotatingDrum_250kParticles/caseSetup/interaction

@@ -1,60 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-
-objectName     interaction;
-objectType     dictionary;
-fileFormat     ASCII;
-
-/*---------------------------------------------------------------------------*/
-
-materials   (glassMat wallMat); // a list of materials names
-
-densities   (2500.0 2500);      // density of materials [kg/m3]
-
-contactListType   sortedContactList;
-
-contactSearch
-{
-    method         NBS;
-
-    updateInterval   20;
-
-    sizeRatio       1.1;
-
-    cellExtent     0.55;
-
-    adjustableBox   Yes;
-}
-
-model
-{
-    contactForceModel    nonLinearLimited;
-
-    rollingFrictionModel normal;
-    
-    /*
-       Property (glassMat-glassMat      glassMat-wallMat
-                                        wallMat-wallMat);
-    */
-
-    Yeff (1.0e6  1.0e6  
-                 1.0e6);                                    // Young modulus [Pa]
-   
-    Geff (0.8e6  0.8e6  
-                 0.8e6);                                    // Shear modulus [Pa]
-
-    nu   (0.25   0.25  
-                 0.25);                                     // Poisson's ratio [-]
-
-    en   (0.97   0.85   
-                 1.00);                                     // coefficient of normal restitution
-
-    mu   (0.65   0.65   
-                 0.65);                                     // dynamic friction 
-
-    mur  (0.1    0.1    
-                 0.1);                                      // rolling friction 
-}
-

benchmarks/rotatingDrum/rotatingDrum_250kParticles/caseSetup/shapes

@@ -1,15 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-
-objectName     shapes;
-objectType     dictionary;
-fileFormat     ASCII;
-/*---------------------------------------------------------------------------*/
-
-names          (glassBead);    // names of shapes 
-
-diameters      (0.006);        // diameter of shapes 
-
-materials      (glassMat);     // material names for shapes 

benchmarks/rotatingDrum/rotatingDrum_250kParticles/runThisCase

@@ -1,22 +0,0 @@
-#!/bin/sh
-set -e  # Exit immediately if a command exits with a non-zero status
-cd ${0%/*} || exit 1    # Run from this directory
-echo "\n<--------------------------------------------------------------------->"
-echo "1) Creating particles"
-echo "<--------------------------------------------------------------------->\n"
-particlesPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "2) Creating geometry"
-echo "<--------------------------------------------------------------------->\n"
-geometryPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "3) Running the case"
-echo "<--------------------------------------------------------------------->\n"
-sphereGranFlow
-
-
-
-
-#------------------------------------------------------------------------------

benchmarks/rotatingDrum/rotatingDrum_250kParticles/settings/domainDict

@@ -1,50 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName     domainDict;
-objectType     dictionary;
-fileFormat     ASCII;
-/*---------------------------------------------------------------------------*/
-globalBox                                        // Simulation domain: every particles that goes outside this domain will be deleted
-{
-    min (-0.2 -0.2  0.0);
-    max ( 0.2  0.2  0.8);
-}
-
-boundaries
-{
-    neighborListUpdateInterval 200;
-    
-    updateInterval              20;
-    
-    left
-    {
-        type    exit;                            // other options: periodic, reflective 
-    }
-
-    right
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-
-    bottom
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-
-    top
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-
-    rear
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-
-    front
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-}

benchmarks/rotatingDrum/rotatingDrum_250kParticles/settings/geometryDict

@@ -1,86 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-
-objectName     geometryDict;
-objectType     dictionary;
-fileFormat     ASCII;
-
-motionModel rotatingAxis;         // motion model: rotating object around an axis
-
-rotatingAxisInfo                  // information for rotatingAxisMotion motion model 
-{
-    rotAxis 
-    {
-        p1    (0.0 0.0 0.0);      // first point for the axis of rotation    
-        
-        p2    (0.0 0.0 1.0);      // second point for the axis of rotation    
-        
-        omega 1.256;              // rotation speed (rad/s) => 12 rpm
-    }
-}
-
-surfaces
-{
-    cylinder
-    {
-        type        cylinderWall;          // type of the wall
-        
-        p1          (0.0 0.0 0.0);         // begin point of cylinder axis
-           
-        p2          (0.0 0.0 0.8);         // end point of cylinder axis
-        
-        radius1     0.2;                   // radius at p1
-        
-        radius2     0.2;                   // radius at p2
-        
-        resolution  60;                    // number of divisions
-        
-        material    wallMat;               // material name of this wall
-        
-        motion      rotAxis;               // motion component name 
-    }
-
-    /*
-        This is a plane wall at the rear end of cylinder
-    */
-    
-    wall1
-    {
-        type      planeWall;               // type of the wall  
-        
-        p1        (-0.2 -0.2 0.0);         // first point of the wall
-        
-        p2        ( 0.2 -0.2 0.0);         // second point
-        
-        p3        ( 0.2  0.2 0.0);         // third point
-        
-        p4        (-0.2  0.2 0.0);         // fourth point 
-        
-        material  wallMat;                 // material name of the wall  
-        
-        motion    rotAxis;                 // motion component name 
-    }
-
-    /*
-        This is a plane wall at the front end of cylinder
-    */
-    
-    wall2
-    {
-        type      planeWall;               // type of the wall
-        
-        p1        (-0.2 -0.2 0.8);         // first point of the wall
-        
-        p2        ( 0.2 -0.2 0.8);         // second point
-        
-        p3        ( 0.2  0.2 0.8);         // third point
-        
-        p4        (-0.2  0.2 0.8);         // fourth point 
-        
-        material  wallMat;                 // material name of the wall  
-        
-        motion    rotAxis;                 // motion component name 
-    }
-}

benchmarks/rotatingDrum/rotatingDrum_250kParticles/settings/particlesDict

@@ -1,47 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-
-objectName     particlesDict;
-objectType     dictionary;
-fileFormat     ASCII;
-
-setFields
-{
-    defaultValue 
-    {
-        velocity         realx3     (0 0 0);     // linear velocity (m/s)
-        acceleration     realx3     (0 0 0);     // linear acceleration (m/s2)
-        rotVelocity      realx3     (0 0 0);     // rotational velocity (rad/s)
-        shapeName        word       glassBead;   // name of the particle shape 
-    }
-
-    selectors
-    {}
-}
-
-positionParticles
-{
-    method ordered;
-
-    orderedInfo
-    {
-        distance   0.006;           // minimum space between centers of particles
-        
-        numPoints  250000;          // number of particles in the simulation 
-        
-        axisOrder  (z x y);         // axis order for filling the space with particles
-    }
-
-    regionType cylinder;            // other options: box and sphere    
-
-    cylinderInfo                    // cylinder for positioning particles 
-    {
-        p1     (0.0  0.0  0.01);    // lower corner point of the box 
-        
-        p2     (0.0  0.0  0.79);    // upper corner point of the box 
-        
-        radius 0.195;               // radius of cylinder 
-    }
-}

benchmarks/rotatingDrum/rotatingDrum_250kParticles/settings/settingsDict

@@ -1,34 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName    settingsDict;
-objectType    dictionary;
-fileFormat    ASCII;
-/*---------------------------------------------------------------------------*/
-run             rotatingDrum_250KParticles;
-
-dt              0.00001;      // time step for integration (s)
-
-startTime       0;            // start time for simulation 
-
-endTime         4;           // end time for simulation 
-
-saveInterval    0.2;          // time interval for saving the simulation
-
-timePrecision   5;            // maximum number of digits for time folder 
-
-g               (0 -9.8 0);   // gravity vector (m/s2) 
-
-includeObjects (diameter);                     // save necessary (i.e., required) data on disk
-
-// exclude unnecessary data from saving on disk
-excludeObjects (rVelocity.dy1 pStructPosition.dy1 pStructVelocity.dy1); 
-
-integrationMethod         AdamsBashforth2;     // integration method 
-
-writeFormat               binary;              // data writting format (ascii or binary)
-
-timersReport              Yes;      
-
-timersReportInterval      0.01;    

benchmarks/rotatingDrum/rotatingDrum_2mParticles/caseSetup/interaction

@@ -1,60 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-
-objectName     interaction;
-objectType     dictionary;
-fileFormat     ASCII;
-
-/*---------------------------------------------------------------------------*/
-
-materials   (glassMat wallMat); // a list of materials names
-
-densities   (2500.0 2500);      // density of materials [kg/m3]
-
-contactListType   sortedContactList;
-
-contactSearch
-{
-    method         NBS;
-
-    updateInterval   20;
-
-    sizeRatio       1.1;
-
-    cellExtent     0.55;
-
-    adjustableBox   Yes;
-}
-
-model
-{
-    contactForceModel    nonLinearLimited;
-
-    rollingFrictionModel normal;
-    
-    /*
-       Property (glassMat-glassMat      glassMat-wallMat
-                                        wallMat-wallMat);
-    */
-
-    Yeff (1.0e6  1.0e6  
-                 1.0e6);                                    // Young modulus [Pa]
-   
-    Geff (0.8e6  0.8e6  
-                 0.8e6);                                    // Shear modulus [Pa]
-
-    nu   (0.25   0.25  
-                 0.25);                                     // Poisson's ratio [-]
-
-    en   (0.97   0.85   
-                 1.00);                                     // coefficient of normal restitution
-
-    mu   (0.65   0.65   
-                 0.65);                                     // dynamic friction 
-
-    mur  (0.1    0.1    
-                 0.1);                                      // rolling friction 
-}
-

benchmarks/rotatingDrum/rotatingDrum_2mParticles/caseSetup/shapes

@@ -1,15 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */ 
-
-objectName     shapes;
-objectType     dictionary;
-fileFormat     ASCII;
-/*---------------------------------------------------------------------------*/
-
-names          (glassBead);    // names of shapes 
-
-diameters      (0.003);        // diameter of shapes 
-
-materials      (glassMat);     // material names for shapes 

benchmarks/rotatingDrum/rotatingDrum_2mParticles/runThisCase

@@ -1,22 +0,0 @@
-#!/bin/sh
-set -e  # Exit immediately if a command exits with a non-zero status
-cd ${0%/*} || exit 1    # Run from this directory
-echo "\n<--------------------------------------------------------------------->"
-echo "1) Creating particles"
-echo "<--------------------------------------------------------------------->\n"
-particlesPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "2) Creating geometry"
-echo "<--------------------------------------------------------------------->\n"
-geometryPhasicFlow
-
-echo "\n<--------------------------------------------------------------------->"
-echo "3) Running the case"
-echo "<--------------------------------------------------------------------->\n"
-sphereGranFlow
-
-
-
-
-#------------------------------------------------------------------------------

benchmarks/rotatingDrum/rotatingDrum_2mParticles/settings/domainDict

@@ -1,50 +0,0 @@
-/* -------------------------------*- C++ -*--------------------------------- *\ 
-|  phasicFlow File                                                            | 
-|  copyright: www.cemf.ir                                                     | 
-\* ------------------------------------------------------------------------- */  
-objectName     domainDict;
-objectType     dictionary;
-fileFormat     ASCII;
-/*---------------------------------------------------------------------------*/
-globalBox                                        // Simulation domain: every particles that goes outside this domain will be deleted
-{
-    min (-0.2 -0.2  0.0);
-    max ( 0.2  0.2  1.2);
-}
-
-boundaries
-{
-    neighborListUpdateInterval 200;
-    
-    updateInterval              20;
-    
-    left
-    {
-        type    exit;                            // other options: periodic, reflective 
-    }
-
-    right
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-
-    bottom
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-
-    top
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-
-    rear
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-
-    front
-    {
-        type     exit;                           // other options: periodic, reflective 
-    }
-}