bug fix for pFlowToVTK for issue #72 in Plus branch

fixed the error when insert particles from file with integer number

benchmarks/helicalMixer/caseSetup/particleInsertion

@@ -1,67 +0,0 @@
-/* -------------------------------*- 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/caseSetup/sphereShape

@@ -1,11 +0,0 @@
-/* -------------------------------*- 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/helicalMixer_1m/caseSetup/interaction

@@ -2,11 +2,13 @@
 |  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;
@@ -14,6 +16,7 @@ contactListType   sortedContactList;
 model
 {
    contactForceModel    nonLinearLimited;
+   
    rollingFrictionModel normal;
 
    Yeff (1.0e6 1.0e6  // Young modulus [Pa]
@@ -28,9 +31,6 @@ model
    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);
 
@@ -42,18 +42,12 @@ model
 contactSearch
 {
     method         NBS;  
-   wallMapping    cellMapping;   
 
-   NBSInfo
-   {
-      updateFrequency 10;        // each 20 timesteps, update neighbor list 
-      sizeRatio      1.1;       // bounding box size to particle diameter (max)
-   }
+    updateInterval   10;
 
-   cellMappingInfo
-   {
-      updateFrequency 10;        // each 20 timesteps, update neighbor list  
-      cellExtent     0.6;        // bounding box for particle-wall search (> 0.5)
-   }
+    sizeRatio       1.1;
 
+    cellExtent     0.55;
+
+    adjustableBox   Yes;     
 }

benchmarks/helicalMixer/helicalMixer_1m/caseSetup/particleInsertion

@@ -0,0 +1,72 @@
+/* -------------------------------*- 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

@@ -2,13 +2,11 @@
 |  phasicFlow File                                                            | 
 |  copyright: www.cemf.ir                                                     | 
 \* ------------------------------------------------------------------------- */ 
-objectName particleInsertion;
-objectType dicrionary;
+objectName  shapes;
+objectType  dictionary;
 fileFormat  ASCII;
 /*---------------------------------------------------------------------------*/
 
-active  no;          // is insertion active?
-
-collisionCheck No;   // not implemented for yes
-
-
+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

@@ -3,5 +3,5 @@ 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

@@ -0,0 +1,32 @@
+#!/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

@@ -0,0 +1,49 @@
+/* -------------------------------*- 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

@@ -0,0 +1,60 @@
+/* -------------------------------*- 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

@@ -0,0 +1,27 @@
+/* -------------------------------*- 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

@@ -0,0 +1,37 @@
+/* -------------------------------*- 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

@@ -0,0 +1,53 @@
+/* -------------------------------*- 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

@@ -0,0 +1,72 @@
+/* -------------------------------*- 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

@@ -0,0 +1,12 @@
+/* -------------------------------*- 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

@@ -0,0 +1,8 @@
+#!/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,5 +1,12 @@
 #!/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"
@@ -18,6 +25,6 @@ sphereGranFlow
 echo "\n<--------------------------------------------------------------------->"
 echo "4) Converting to VtK"
 echo "<--------------------------------------------------------------------->\n"
-pFlowToVTK -f diameter id velocity
+pFlowToVTK -f diameter id velocity --binary
 
 #------------------------------------------------------------------------------

benchmarks/helicalMixer/helicalMixer_250K/settings/domainDict

@@ -0,0 +1,49 @@
+/* -------------------------------*- 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

@@ -0,0 +1,60 @@
+/* -------------------------------*- 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

@@ -0,0 +1,27 @@
+/* -------------------------------*- 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

@@ -0,0 +1,37 @@
+/* -------------------------------*- 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

@@ -0,0 +1,53 @@
+/* -------------------------------*- 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

@@ -0,0 +1,72 @@
+/* -------------------------------*- 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

@@ -0,0 +1,12 @@
+/* -------------------------------*- 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

@@ -0,0 +1,7 @@
+#!/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

@@ -0,0 +1,32 @@
+#!/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

@@ -0,0 +1,49 @@
+/* -------------------------------*- 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

@@ -0,0 +1,60 @@
+/* -------------------------------*- 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

@@ -0,0 +1,27 @@
+/* -------------------------------*- 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

@@ -0,0 +1,37 @@
+/* -------------------------------*- 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

@@ -0,0 +1,53 @@
+/* -------------------------------*- 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

@@ -0,0 +1,72 @@
+/* -------------------------------*- 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

@@ -0,0 +1,12 @@
+/* -------------------------------*- 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

@@ -0,0 +1,7 @@
+#!/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

@@ -0,0 +1,32 @@
+#!/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

@@ -0,0 +1,49 @@
+/* -------------------------------*- 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

@@ -0,0 +1,60 @@
+/* -------------------------------*- 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

@@ -0,0 +1,27 @@
+/* -------------------------------*- 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

@@ -0,0 +1,37 @@
+/* -------------------------------*- 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

@@ -0,0 +1,53 @@
+/* -------------------------------*- 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

@@ -0,0 +1,72 @@
+/* -------------------------------*- 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

@@ -0,0 +1,12 @@
+/* -------------------------------*- 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

@@ -0,0 +1,7 @@
+#!/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

@@ -0,0 +1,32 @@
+#!/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

@@ -0,0 +1,49 @@
+/* -------------------------------*- 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

@@ -0,0 +1,60 @@
+/* -------------------------------*- 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

@@ -0,0 +1,27 @@
+/* -------------------------------*- 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

@@ -0,0 +1,37 @@
+/* -------------------------------*- 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 +1,101 @@
 # 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/settings/geometryDict

@@ -1,56 +0,0 @@
-/* -------------------------------*- 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/settings/particlesDict

@@ -1,31 +0,0 @@
-/* -------------------------------*- 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/settings/settingsDict

@@ -1,36 +0,0 @@
-/* -------------------------------*- 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,7 +1,9 @@
 
 # Benchmarks
 
-Benchmakrs has been done on two different simulations: a simulation with simple geometry (rotating drum) and a simulation with complex geometry (helical mixer).
+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/readme.md)
-- [helical mixer](./helicalMixer/readme.md)
+- [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

@@ -4,6 +4,12 @@
 
 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">

benchmarks/rotatingDrum/rotatingDrum_1mParticles/runThisCase

@@ -1,4 +1,5 @@
 #!/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"

benchmarks/rotatingDrum/rotatingDrum_250kParticles/runThisCase

@@ -1,4 +1,5 @@
 #!/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"

benchmarks/rotatingDrum/rotatingDrum_2mParticles/runThisCase

@@ -1,4 +1,5 @@
 #!/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"

benchmarks/rotatingDrum/rotatingDrum_4mParticles/runThisCase

@@ -1,4 +1,5 @@
 #!/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"

benchmarks/rotatingDrum/rotatingDrum_8mParticles/runThisCase

@@ -1,4 +1,5 @@
 #!/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"

src/Interaction/grainInteraction/grainInteraction/grainInteractionKernels.hpp

@@ -251,6 +251,8 @@ struct pwInteractionFunctor
 		realx3 xi = pos_[i];
 		
 		realx3x3 tri = triangles_(tj);
+		const realx3& normW = triangles_.normal(tj);
+
 		real ovrlp;
 		realx3 Nij, cp;
 
@@ -262,7 +264,7 @@ struct pwInteractionFunctor
 
 			int32 mInd	= wTriMotionIndex_[tj];
 			
-			auto Vw = motionModel_(mInd, cp);
+			auto Vw = motionModel_(mInd, cp, normW);
 			
 			//output<< "par-wall index "<< i<<" - "<< tj<<endl;
 			

src/Interaction/sphereInteraction/sphereInteraction/sphereInteractionKernels.hpp

@@ -238,7 +238,9 @@ struct pwInteractionFunctor
 		real Rj = 10000.0;
 		realx3 xi = pos_[i];
 		
-		realx3x3 tri = triangles_(tj); 
+		const realx3x3 tri = triangles_(tj);
+		const realx3& normW = triangles_.normal(tj); 
+
 		real ovrlp;
 		realx3 Nij, cp;
 
@@ -250,7 +252,7 @@ struct pwInteractionFunctor
 
 			int32 mInd	= wTriMotionIndex_[tj];
 			
-			auto Vw = motionModel_(mInd, cp);
+			auto Vw = motionModel_(mInd, cp, normW);
 			
 			//output<< "par-wall index "<< i<<" - "<< tj<<endl;
 			

src/MotionModel/MotionModel/MotionModel.hpp

@@ -85,15 +85,15 @@ public:
 		~ModelInterface()=default;
 
 		INLINE_FUNCTION_HD
-		realx3 pointVelocity(uint32 n, const realx3& p)const
+		realx3 pointVelocity(uint32 n, const realx3& p, const realx3& wallNormal)const
 		{
-			return components_[n].linVelocityPoint(p);
+			return components_[n].linVelocityPoint(p, wallNormal);
 		}
 
 		INLINE_FUNCTION_HD
-		realx3 operator()(uint32 n, const realx3& p)const
+		realx3 operator()(uint32 n, const realx3& p, const realx3& wallNormal)const
 		{
-			return pointVelocity(n,p);
+			return pointVelocity(n, p, wallNormal);
 		}
 
 		INLINE_FUNCTION_HD

src/MotionModel/entities/conveyorBelt/conveyorBelt.cpp

@@ -28,7 +28,7 @@ pFlow::conveyorBelt::conveyorBelt(const dictionary& dict)
   if(!read(dict))
 	{
 		fatalErrorInFunction<<
-		"  error in reading conveyorBelt from dictionary "<< dict.globalName()<<endl;
+		"  error in reading from dictionary "<< dict.globalName()<<endl;
 		fatalExit;
 	}
 }
@@ -37,7 +37,21 @@ FUNCTION_H
 bool pFlow::conveyorBelt::read(const dictionary& dict)
 {	
 
-	tangentVelocity_ 		= dict.getVal<realx3>("tangentVelocity");
+	linearVelocity_ 		= dict.getVal<real>("linearVelocity");
+    normal_             = dict.getVal<realx3>("normal");
+
+    if(normal_.length() > verySmallValue)
+    {
+        normal_.normalize();
+    }
+    else
+    {
+        fatalErrorInFunction<<
+            "  normal vector in "<< 
+            dict.globalName() << 
+            " cannot be zero vector "<<endl;
+        return false;
+    }
 	
 	return true;
 }
@@ -45,12 +59,19 @@ bool pFlow::conveyorBelt::read(const dictionary& dict)
 FUNCTION_H
 bool pFlow::conveyorBelt::write(dictionary& dict) const
 {
-	if( !dict.add("tangentVelocity", tangentVelocity_) )
+	if( !dict.add("linearVelocity", linearVelocity_) )
 	{
 		fatalErrorInFunction<<
 		"  error in writing tangentVelocity to dictionary "<< dict.globalName()<<endl;
 		return false;
 	}
+
+    if(!dict.add("normal", normal_))
+    {
+        fatalErrorInFunction<<
+        "  error in writing normal to dictionary "<< dict.globalName()<<endl;
+        return false;
+    }
 	return true;
 }
 
@@ -65,6 +86,7 @@ bool pFlow::conveyorBelt::read(iIstream& is)
 FUNCTION_H
 bool pFlow::conveyorBelt::write(iOstream& os)const
 {
-  os.writeWordEntry("tangentVelocity", tangentVelocity_);
+    os.writeWordEntry("linearVelocity", linearVelocity_);
+    os.writeWordEntry("normal", normal_);
     return true;
 }

src/MotionModel/entities/conveyorBelt/conveyorBelt.hpp

@@ -41,7 +41,12 @@ class conveyorBelt
 {
 private:
 
-	realx3  tangentVelocity_{0, 0, 0};
+    /// @brief  linear velocity of the conveyor belt
+    real  linearVelocity_{0};
+
+    /// normal vector of the velocity plane.
+    /// The velocity vector is tangent to this plane (velocity plane). 
+    realx3 normal_{1,0,0};
 
 public:
 
@@ -63,10 +68,16 @@ public:
     void setTime(real t)
     {}
 
-	INLINE_FUNCTION_HD
+    /*INLINE_FUNCTION_HD
     realx3 linVelocityPoint(const realx3 &)const
     {
         return tangentVelocity_;
+    }*/
+
+    INLINE_FUNCTION_HD
+    realx3 linVelocityPoint(const realx3 &, const realx3& wallNormal)const
+    {
+        return linearVelocity_ * cross(wallNormal, normal_);
     }
 
     INLINE_FUNCTION_HD

src/MotionModel/entities/multiRotatingAxis/multiRotatingAxis.hpp

@@ -120,7 +120,7 @@ public:
 
 		/// Tangential velocity at point p
 		INLINE_FUNCTION_HD
-		realx3 pointTangentialVel(const realx3& p)const
+		realx3 pointTangentialVel(const realx3& p, const realx3& wallNormal)const
 		{
 			realx3 parentVel(0);
 			auto parIndex = parentAxisIndex();
@@ -128,11 +128,11 @@ public:
 			while(parIndex != -1)
 			{
 				auto& ax = axisList_[parIndex];
-				parentVel += ax.linVelocityPoint(p);
+				parentVel += ax.linVelocityPoint(p, wallNormal);
 				parIndex = ax.parentAxisIndex();
 			}
 
-			return parentVel + rotatingAxis::linVelocityPoint(p);
+			return parentVel + rotatingAxis::linVelocityPoint(p, wallNormal);
 		}
 
 		/// Translate point p for dt seconds based on the axis information

src/MotionModel/entities/rotatingAxis/rotatingAxis.hpp

@@ -126,7 +126,7 @@ public:
 
 	/// Linear tangential velocity at point p
 	INLINE_FUNCTION_HD
-	realx3 linVelocityPoint(const realx3 &p)const;
+	realx3 linVelocityPoint(const realx3 &p, const realx3& wallNormal)const;
 
 	INLINE_FUNCTION_HD
 	realx3 transferPoint(const realx3 p, real dt)const;

src/MotionModel/entities/rotatingAxis/rotatingAxisI.hpp

@@ -20,7 +20,7 @@ Licence:
 -----------------------------------------------------------------------------*/
 
 INLINE_FUNCTION_HD
-pFlow::realx3 pFlow::rotatingAxis::linVelocityPoint(const realx3 &p)const
+pFlow::realx3 pFlow::rotatingAxis::linVelocityPoint(const realx3 &p, const realx3&)const
 {
 	
 	if(!inTimeRange()) return {0,0,0};

src/MotionModel/entities/stationary/stationary.hpp

@@ -60,7 +60,7 @@ public:
 	{}
 
 	INLINE_FUNCTION_HD
-	realx3 linVelocityPoint(const realx3 &)const
+	realx3 linVelocityPoint(const realx3 &, const realx3&)const
 	{
 		return realx3(0);
 	}

src/MotionModel/entities/vibrating/vibrating.hpp

@@ -117,7 +117,7 @@ public:
     }
 
     INLINE_FUNCTION_HD
-	realx3 linVelocityPoint(const realx3 &)const
+    realx3 linVelocityPoint(const realx3 &, const realx3&)const
     {
         return velocity_;
     }

src/PostprocessData/CMakeLists.txt

@@ -13,6 +13,7 @@ set(SourceFiles
     region/regionPoints/lineRegionPoints/lineRegionPoints.cpp
     region/regionPoints/centerPointsRegionPoints/centerPointsRegionPoints.cpp
     region/regionPoints/multipleSpheresRegionPoints/multipleSpheresRegionPoints.cpp
+    region/regionPoints/rectMeshRegionPoints/rectMeshRegionPoints.cpp
 
     # Postprocess components
     postprocessComponent/postprocessComponent/postprocessComponent.cpp
@@ -24,6 +25,8 @@ set(SourceFiles
     operation/PostprocessOperation/PostprocessOperationSum.cpp
     operation/PostprocessOperation/PostprocessOperationAverage.cpp
     operation/PostprocessOperation/PostprocessOperationAvMassVelocity.cpp
+    operation/PostprocessOperation/PostprocessOperationSolidVolFraction.cpp
+    operation/PostprocessOperation/PostprocessOperationBulkDensity.cpp 
        
     operation/includeMask/includeMask.cpp
     operation/includeMask/IncludeMasks.cpp

src/PostprocessData/operation/PostprocessOperation/PostprocessOperationAvMassVelocity.hpp

@@ -23,106 +23,10 @@ Licence:
 
 /*!
  * @class PostprocessOperationAvMassVelocity
- * @brief A class for averaging field values within specified regions during post-processing.
+ * @brief Calculates mass-weighted average velocity of particles in the regions
  * 
- * @details
- * The PostprocessOperationAvMassVelocity class is a specialized post-processing operation that 
- * calculates the average of field values within specified regions. It inherits from the 
- * postprocessOperation base class and implements a weighted averaging operation that 
- * can be applied to scalar (real), vector (realx3), and tensor (realx4) fields.
  *
- * The average operation follows the mathematical formula:
- * \f[
- *    \text{result} = \frac{\sum_{j \in \text{includeMask}} w_j \cdot \phi_j \cdot \text{field}_j}
- *                        {\sum_{i \in \text{processRegion}} w_i \cdot \phi_i}
- * \f]
- * 
- * Where:
- * - \f$ i \f$ represents all particles within the specified processing region
- * - \f$ j \f$ belongs to a subset of \f$ i \f$ based on an includeMask
- * - \f$ w_i \f$ is the weight factor for particle \f$ i \f$
- * - \f$ \phi_i \f$ is the value from the phi field for particle \f$ i \f$
- * - \f$ \text{field}_j \f$ is the value from the target field for particle \f$ j \f$
- * 
- * The calculation can optionally be divided by the region volume (when divideByVolume is set to yes),
- * which allows calculating normalized averages:
- * \f[
- *    \text{result} = \frac{1}{V_{\text{region}}} \frac{\sum_{j \in \text{includeMask}} w_j \cdot \phi_j \cdot \text{field}_j}
- *                        {\sum_{i \in \text{processRegion}} w_i \cdot \phi_i}
- * \f]
- * 
- * The averaging can be further filtered using an includeMask to selectively include only
- * specific particles that satisfy certain criteria.
- * 
- * This class supports the following field types:
- * - real (scalar values)
- * - realx3 (vector values)
- * - realx4 (tensor values)
- * 
- * @section usage Usage Example
- * Below is a sample dictionary showing how to configure and use this class:
- *
- * ```
- * processMethod    arithmetic;     // method of performing the sum (arithmetic, uniformDistribution, GaussianDistribution)
- * processRegion    sphere;         // type of region on which processing is performed 
- * 
- * sphereInfo
- * {
- *     radius 0.01;
- *     center (-0.08 -0.08 0.015);
- * }
- * 
- * timeControl default; 
- * 
- * /// all the post process operations to be done 
- * operations
- * (
- *     // computes the arithmetic mean of particle velocity 
- *     averageVel
- *     {
- *         function         average;
- *         field            velocity;
- *         dividedByVolume  no;     // default is no
- *         threshold        3;      // default is 1
- *         includeMask      all;    // include all particles in the calculation
- *     }
- *     
- *     // computes the fraction of par1 in the region 
- *     par1Fraction
- *     {
- *         function        average;
- *         field           one;     // the "one" field is special - all members have value 1.0
- *         phi             one;     // default is "one"
- *         dividedByVolume no;
- *         includeMask     lessThan;
- *         
- *         // diameter of par1 is 0.003, so these settings 
- *         // will select only particles of type par1
- *         lessThanInfo
- *         {
- *             field      diameter;
- *             value      0.0031;  
- *         }
- *     }
- * );
- * ```
- *
- * @section defaults Default Behavior
- * - By default, `phi` is set to the field named "one" which contains value 1.0 for all entries
- * - `dividedByVolume` is set to "no" by default
- * - `threshold` is set to 1 by default
- * - `includeMask` can be set to various filters, with "all" being the default to include all particles
- *
- * @section special Special Fields
- * The field named "one" is a special field where all members have the value 1.0. This makes it
- * particularly useful for calculating:
- * 
- * 1. Volume or number fractions (as shown in the par1Fraction example)
- * 2. Simple counts when used with an appropriate mask
- * 3. Normalizing values by particle count
- *
- * @see postprocessOperation
- * @see executeAverageOperation
+ * @see PostprocessOperationAverage
  */
 
 #include <variant>

src/PostprocessData/operation/PostprocessOperation/PostprocessOperationAverage.cpp

@@ -162,6 +162,14 @@ bool PostprocessOperationAverage::write(const fileSystem &parDir) const
             processedFieldName()+"_prime2" + ".Start_" + ti.timeName());
         os2Ptr_ = makeUnique<oFstream>(path);
 
+        if(regPoints().scientific())
+        {
+            // set output format to scientific notation
+            os2Ptr_().stdStream()<<std::scientific;
+        }
+    
+        os2Ptr_().precision(regPoints().precision());
+
         regPoints().write(os2Ptr_());
     }
 
@@ -178,4 +186,26 @@ bool PostprocessOperationAverage::write(const fileSystem &parDir) const
     return true;
 }
 
+bool PostprocessOperationAverage::write(iOstream &os) const
+{
+    if(! postprocessOperation::write(os))
+    {
+        return false;
+    }
+    if(!calculateFluctuation2_())
+    {
+        return true;
+    }
+    
+    return 
+        std::visit
+        (
+            [&](auto&& arg)->bool
+            {
+                return arg.writeFieldToVtk(os);
+            },
+            fluctuation2FieldPtr_()
+        );
+}
+
 } // namespace pFlow::postprocessData

src/PostprocessData/operation/PostprocessOperation/PostprocessOperationAverage.hpp

@@ -195,6 +195,8 @@ public:
     /// write to os stream
     bool write(const fileSystem &parDir)const override;
 
+    bool write(iOstream& os)const override;
+
 
     /// @brief Execute average operation on field values
     /// @param weights Weight factors for particles

src/PostprocessData/operation/PostprocessOperation/PostprocessOperationBulkDensity.cpp

@@ -0,0 +1,25 @@
+#include "PostprocessOperationBulkDensity.hpp"
+
+namespace pFlow::postprocessData
+{
+
+PostprocessOperationBulkDensity::PostprocessOperationBulkDensity
+(
+    const dictionary &opDict, 
+    const regionPoints &regPoints, 
+    fieldsDataBase &fieldsDB
+)
+:
+    PostprocessOperationSum
+    (
+        opDict,
+        "mass",
+        "one",
+        "all",
+        regPoints,
+        fieldsDB
+    )
+{
+}
+
+}

src/PostprocessData/operation/PostprocessOperation/PostprocessOperationBulkDensity.hpp

@@ -0,0 +1,77 @@
+/*------------------------------- 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 __PostprocessOperationBulkDensity_hpp__
+#define __PostprocessOperationBulkDensity_hpp__
+
+/*!
+ * @class PostprocessOperationBulkDensity
+ * @brief Calculates bulk density in the regions
+ * 
+ *
+ * @see PostprocessOperationSum
+ */
+
+#include "PostprocessOperationSum.hpp"
+
+namespace pFlow::postprocessData
+{
+
+class PostprocessOperationBulkDensity
+:
+    public PostprocessOperationSum
+{
+
+public:
+
+    TypeInfo("PostprocessOperation<bulkDensity>");
+
+    /// @brief Constructs average operation processor
+    /// @param opDict Operation parameters dictionary
+    /// @param regPoints Region points data
+    /// @param fieldsDB Fields database
+    PostprocessOperationBulkDensity(
+        const dictionary& opDict,
+        const regionPoints& regPoints,
+        fieldsDataBase& fieldsDB);
+    
+    /// destructor 
+    ~PostprocessOperationBulkDensity() override = default;
+
+    /// add this virtual constructor to the base class
+    add_vCtor
+    (
+        postprocessOperation,
+        PostprocessOperationBulkDensity,
+        dictionary
+    );
+
+    bool divideByVolume()const override
+    {
+        return true;
+    }
+
+};
+
+} 
+
+#endif //__PostprocessOperationSolidVolFraction_hpp__
+
+

src/PostprocessData/operation/PostprocessOperation/PostprocessOperationSolidVolFraction.cpp

@@ -0,0 +1,25 @@
+#include "PostprocessOperationSolidVolFraction.hpp"
+
+namespace pFlow::postprocessData
+{
+
+PostprocessOperationSolidVolFraction::PostprocessOperationSolidVolFraction
+(
+    const dictionary &opDict, 
+    const regionPoints &regPoints, 
+    fieldsDataBase &fieldsDB
+)
+:
+    PostprocessOperationSum
+    (
+        opDict,
+        "volume",
+        "one",
+        "all",
+        regPoints,
+        fieldsDB
+    )
+{
+}
+
+}

src/PostprocessData/operation/PostprocessOperation/PostprocessOperationSolidVolFraction.hpp

@@ -0,0 +1,77 @@
+/*------------------------------- 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 __PostprocessOperationSolidVolFraction_hpp__
+#define __PostprocessOperationSolidVolFraction_hpp__
+
+/*!
+ * @class PostprocessOperationSolidVolFraction
+ * @brief Calculates solid volume fraction in the regions
+ * 
+ *
+ * @see PostprocessOperationSum
+ */
+
+#include "PostprocessOperationSum.hpp"
+
+namespace pFlow::postprocessData
+{
+
+class PostprocessOperationSolidVolFraction
+:
+    public PostprocessOperationSum
+{
+
+public:
+
+    TypeInfo("PostprocessOperation<solidVolFraction>");
+
+    /// @brief Constructs average operation processor
+    /// @param opDict Operation parameters dictionary
+    /// @param regPoints Region points data
+    /// @param fieldsDB Fields database
+    PostprocessOperationSolidVolFraction(
+        const dictionary& opDict,
+        const regionPoints& regPoints,
+        fieldsDataBase& fieldsDB);
+    
+    /// destructor 
+    ~PostprocessOperationSolidVolFraction() override = default;
+
+    /// add this virtual constructor to the base class
+    add_vCtor
+    (
+        postprocessOperation,
+        PostprocessOperationSolidVolFraction,
+        dictionary
+    );
+
+    bool divideByVolume()const override
+    {
+        return true;
+    }
+
+};
+
+} 
+
+#endif //__PostprocessOperationSolidVolFraction_hpp__
+
+

src/PostprocessData/operation/PostprocessOperation/PostprocessOperationSum.cpp

@@ -41,6 +41,49 @@ PostprocessOperationSum::PostprocessOperationSum
     }
 }
 
+PostprocessOperationSum::PostprocessOperationSum
+(
+    const dictionary &opDict, 
+    const word &fieldName, 
+    const word &phiName, 
+    const word &includeName, 
+    const regionPoints &regPoints, 
+    fieldsDataBase &fieldsDB
+)
+:
+    postprocessOperation(
+        opDict, 
+        fieldName, 
+        phiName, 
+        includeName, 
+        regPoints, 
+        fieldsDB)
+{
+    if( fieldType() == getTypeName<real>() )
+    {
+        processedRegField_ = makeUnique<processedRegFieldType>(
+            regionField(processedFieldName(), regPoints, real(0)));
+    }
+    else if( fieldType() == getTypeName<realx3>() )
+    {
+        processedRegField_ = makeUnique<processedRegFieldType>(
+            regionField(processedFieldName(), regPoints, realx3(0)));
+    }
+    else if( fieldType() == getTypeName<realx4>() )
+    {
+        processedRegField_ = makeUnique<processedRegFieldType>(
+            regionField(processedFieldName(), regPoints, realx4(0)));
+    }
+    else
+    {
+        fatalErrorInFunction<<" in dictionary "<< opDict.globalName()
+            << " field type is not supported for sum operation"
+            << " field type is "<< fieldType()
+            << endl;
+        fatalExit;
+    }
+}
+
 /// Performs weighted sum of field values within each region
 bool PostprocessOperationSum::execute
 (

src/PostprocessData/operation/PostprocessOperation/PostprocessOperationSum.hpp

@@ -154,6 +154,14 @@ public:
         const regionPoints& regPoints,
         fieldsDataBase& fieldsDB);
     
+    PostprocessOperationSum(
+        const dictionary& opDict,
+        const word& fieldName,
+        const word& phiName,
+        const word& includeName,
+        const regionPoints& regPoints,
+        fieldsDataBase& fieldsDB);
+
     /// destructor 
     ~PostprocessOperationSum() override = default;
 

src/PostprocessData/operation/PostprocessOperation/operationFunctions.hpp

@@ -142,7 +142,7 @@ regionField<T> executeFluctuation2Operation
 )
 {
     const auto& regPoints = fieldAvg.regPoints();
-    regionField<T> processedField(regFieldName, regPoints, T{});
+    regionField<T> processedField(regFieldName+"_fluctuation2", regPoints, T{});
     auto vols = regPoints.volumes();
 
     for(uint32 reg =0; reg<regPoints.size(); reg++)

src/PostprocessData/operation/postprocessOperation/postprocessOperation.cpp

@@ -107,6 +107,14 @@ bool postprocessOperation::write(const fileSystem &parDir) const
             processedFieldName() + ".Start_" + ti.timeName());
         osPtr_ = makeUnique<oFstream>(path);
         
+        if(regPoints().scientific())
+        {   
+            // set output format to scientific notation 
+            osPtr_().stdStream()<<std::scientific;
+        }
+
+        osPtr_().precision(regPoints().precision());
+        
         regPoints().write(osPtr_());
     }
 
@@ -124,6 +132,25 @@ bool postprocessOperation::write(const fileSystem &parDir) const
     return true;
 }
 
+bool postprocessOperation::write(iOstream& os)const
+{
+    if(!regPoints().writeToSameTimeFile())
+    {
+        const auto& field = processedField();
+
+        return 
+        std::visit
+        (
+            [&](auto&& arg)->bool
+            {
+                return arg.writeFieldToVtk(os);
+            },
+            field
+        );
+    }
+    return false;
+}
+
 uniquePtr<postprocessOperation> postprocessOperation::create
 (
     const dictionary &opDict,

src/PostprocessData/operation/postprocessOperation/postprocessOperation.hpp

@@ -225,6 +225,7 @@ public:
     }
 
     /// whether the result is divided by volume of the region
+    virtual  
     bool divideByVolume()const
     {
         return divideByVolume_();
@@ -255,7 +256,7 @@ public:
     /// write the result to output stream (possibly a file)
     /// @param os Output stream to write the result.
     virtual 
-    bool write(iOstream& os)const {return true;}
+    bool write(iOstream& os)const;
 
     /// Create the polymorphic object using the virtual constructor.
     /// @param opDict Dictionary containing operation-specific parameters.

src/PostprocessData/postprocessComponent/PostprocessComponent/PostprocessComponent.cpp

@@ -152,11 +152,33 @@ bool pFlow::postprocessData::PostprocessComponent<RegionType, ProcessMethodType>
     }
     else
     {
-        notImplementedFunction;
-        return false;
+        word chNum = real2FixedStripZeros(database().time().currentTime() *1000000, 0);
+        fileSystem  file = parDir + (name() +"-"+chNum+".vtk");
+
+        auto osPtr = makeUnique<oFstream>(file);
+
+        // set output format to scientific notation
+        if(regPoints().scientific())
+        {
+            osPtr->stdStream() << std::scientific;
         }
     
+        osPtr().precision(regPoints().precision());
 
+        regPoints().write(osPtr());
+
+        for(auto& operation:operatios_)
+        {
+            if(!operation->write(osPtr()))
+            {
+                fatalErrorInFunction
+                    <<"Error occurred in writing operation defined in dict "
+                    << operation->operationDict()
+                    <<endl;
+                return false;
+            }
+        }   
+    }
 
     return true;
 }

src/PostprocessData/postprocessComponent/PostprocessComponent/PostprocessComponent.hpp

@@ -122,8 +122,6 @@ public:
 
 };
 
-
-
 }
 
 #include "PostprocessComponent.cpp"

src/PostprocessData/postprocessComponent/PostprocessComponent/PostprocessComponentGaussian.hpp

@@ -47,8 +47,8 @@ public:
     :
         PostprocessComponent<RegionType,GaussianDistribution>(dict, fieldsDB, defaultTimeControl)
     {
-        /// initializes the Gaussian distribution for all elements of region
-        //const uint32 n = this->regPoints().size();
+
+        this->regPoints().applyRegionExtension();
         auto d = this->regPoints().eqDiameters();
         auto c = this->regPoints().centers();
         auto& regs = this->regionProecessMethod();

src/PostprocessData/postprocessComponent/PostprocessComponent/PostprocessComponents.cpp

@@ -26,6 +26,7 @@ Licence:
 #include "sphereRegionPoints.hpp"
 #include "lineRegionPoints.hpp"
 #include "multipleSpheresRegionPoints.hpp"
+#include "rectMeshRegionPoints.hpp"
 
 namespace pFlow::postprocessData
 {
@@ -37,6 +38,10 @@ template class PostprocessComponentGaussian<multipleSpheresRegionPoints>;
 template class PostprocessComponentUniform<multipleSpheresRegionPoints>;
 template class PostprocessComponentArithmetic<multipleSpheresRegionPoints>;
 
+template class PostprocessComponentGaussian<rectMeshRegionPoints>;
+template class PostprocessComponentUniform<rectMeshRegionPoints>;
+template class PostprocessComponentArithmetic<rectMeshRegionPoints>;
+
 template class PostprocessComponentGaussian<lineRegionPoints>;
 template class PostprocessComponentUniform<lineRegionPoints>;
 template class PostprocessComponentArithmetic<lineRegionPoints>;

src/PostprocessData/postprocessComponent/particleProbePostprocessComponent/particleProbePostprocessComponent.cpp

@@ -157,6 +157,12 @@ bool pFlow::postprocessData::particleProbePostprocessComponent::write(const file
         // file is not open yet
         fileSystem path = parDir + (name_+".Start_"+ti.timeName());
         osPtr_ = makeUnique<oFstream>(path);
+        
+        if(regionPointsPtr_().scientific())
+        {
+            osPtr_().stdStream() << std::scientific;
+        }
+        osPtr_().precision(regionPointsPtr_().precision());
         regionPointsPtr_().write(osPtr_());
     }
 

src/PostprocessData/readme.md

@@ -2,17 +2,16 @@
 
 The `PostprocessData` module in phasicFlow provides powerful tools for analyzing particle-based simulations both during runtime (in-simulation) and after simulation completion (post-simulation). This document explains how to configure and use the postprocessing features through the dictionary-based input system.
 
-- in-simulation: this is postprocessing that is active during simulation. When running a solver, it allows for real-time data analysis and adjustments based on the simulation's current state. See below to see how you can activate in-simulation postprocessing.
-- post-simulation: this is postprocessing that is done after the simulation is completed. It allows for detailed analysis of the simulation results, including data extraction and visualization based on the results that are stored in time-folders. If you want to use post-simulation, you need to run utility `postprocessPhasicFlow` in terminal (in the simulation case setup folder) to run the postprocessing. This utility reads the `postprocessDataDict` file and performs the specified operations on the simulation data.
-
+- **In-simulation**: This is postprocessing that is active during simulation. When running a solver, it allows for real-time data analysis and adjustments based on the simulation's current state. See below to learn how you can activate in-simulation postprocessing.
+- **Post-simulation**: This is postprocessing that is done after the simulation is completed. It allows for detailed analysis of the simulation results, including data extraction and visualization based on the results stored in time folders. If you want to use post-simulation, you need to run the utility `postprocessPhasicFlow` in the terminal (in the simulation case setup folder) to execute the postprocessing. This utility reads the `postprocessDataDict` file and performs the specified operations on the simulation data.
 
 ### Important Notes
 
 * **NOTE 1:**  
-postprocessing for in-simulation, is not implemented for MPI execution. So, do not use it when using MPI execution. For post-simulation postprocessing, you can use the `postprocessPhasicFlow` utility without MPI, even though the actual simulation has been done using MPI.
+Postprocessing for in-simulation is not implemented for MPI execution. So, do not use it when using MPI execution. For post-simulation postprocessing, you can use the `postprocessPhasicFlow` utility without MPI, even though the actual simulation has been done using MPI.
 
 * **NOTE 2:**  
-In post-simulation mode, all timeControl settings are ignored. The postprocessing will be done for all the time folders that are available in the case directory or if you specify the time range in the command line, the postprocessing will be done for the time folders that are in the specified range of command line.
+In post-simulation mode, all `timeControl` settings are ignored. The postprocessing will be done for all the time folders that are available in the case directory, or if you specify the time range in the command line, the postprocessing will be done for the time folders within the specified range.
 
 ## Table of Contents
 
@@ -32,12 +31,14 @@ In post-simulation mode, all timeControl settings are ignored. The postprocessin
   - [7.1. Example 1: Probing Individual Particles](#71-example-1-probing-individual-particles)
   - [7.2. Example 2: Processing in a Spherical Region](#72-example-2-processing-in-a-spherical-region)
   - [7.3. Example 3: Processing Along a Line](#73-example-3-processing-along-a-line)
+  - [7.4. Example 4: Processing in a Rectangular Mesh](#74-example-4-processing-in-a-rectangular-mesh)
+  - [7.5. Example 5: Tracking particles](#75-example-5-tracking-particles)
 - [8. Advanced Features](#8-advanced-features)
-  - [8.1. Special functions applied on fields](#81-special-functions-applied-on-fields)
-  - [8.2. Particle Filtering with includeMask](#82-particle-filtering-with-includemask)
+  - [8.1. Special Functions Applied on Fields](#81-special-functions-applied-on-fields)
+  - [8.2. Particle Filtering with IncludeMask](#82-particle-filtering-with-includemask)
   - [8.3. Implementation Notes](#83-implementation-notes)
 - [9. Mathematical Formulations](#9-mathematical-formulations)
-- [10. A complete dictionary file (postprocessDataDict)](#10-a-complete-dictionary-file-postprocessdatadict)
+- [10. A Complete Dictionary File (postprocessDataDict)](#10-a-complete-dictionary-file-postprocessdatadict)
 
 ## 1. Overview
 
@@ -46,12 +47,12 @@ Postprocessing in phasicFlow allows you to:
 - Extract information about particles in specific regions of the domain
 - Calculate statistical properties such as averages and sums of particle attributes
 - Track specific particles throughout the simulation
-- Apply different weighing methods when calculating statistics
+- Apply different weighting methods when calculating statistics
 - Perform postprocessing at specific time intervals
 
 ## 2. Setting Up Postprocessing
 
-Postprocessing is configured through a dictionary file named `postprocessDataDict` which should be placed in the `settings` directory. Below is a detailed explanation of the configuration options.
+Postprocessing is configured through a dictionary file named `postprocessDataDict`, which should be placed in the `settings` directory. Below is a detailed explanation of the configuration options.
 
 ### 2.1. Basic Configuration
 
@@ -60,7 +61,6 @@ The input dictionary, **settings/postprocessDataDict**, may look like this:
 ```cpp
 // PostprocessData dictionary
 
-
 // Enable/disable postprocessing during simulation
 runTimeActive yes;  // Options: yes, no
 
@@ -70,7 +70,7 @@ shapeType sphere;   // Options depend on the simulation type: sphere, grain, etc
 // Default time control for postprocessing components
 defaultTimeControl
 {
-    timeControl         timeStep;  // Options: timeStep, simulationTime, settings
+    timeControl         timeStep;  // Options: timeStep, simulationTime, settingsDict
     startTime           0;         // Start time for postprocessing
     endTime             1000;      // End time for postprocessing
     executionInterval   150;       // How frequently to run postprocessing
@@ -83,7 +83,6 @@ components
 );
 ```
 
-
 If you want to activate in-simulation postprocessing, you need to add these lines to the `settings/settingsDict` file:
 
 ```cpp
@@ -92,7 +91,7 @@ libs   ("libPostprocessData.so");
 auxFunctions    postprocessData;
 ```
 
-This will link the postprocessing library to your simulation, allowing you to use its features. Note that, anytime you want to deactivate the in-simulation postprocessing, you can simply change the `runTimeActive` option to `no` in `postprocessDataDict` file.
+This will link the postprocessing library to your simulation, allowing you to use its features. Note that anytime you want to deactivate the in-simulation postprocessing, you can simply change the `runTimeActive` option to `no` in the `postprocessDataDict` file.
 
 ## 3. Time Control Options
 
@@ -102,7 +101,7 @@ Each postprocessing component can either use the default time control settings o
 |--------|-------------|---------------------|
 | `timeStep` | Controls execution based on simulation time steps | `startTime`, `endTime`, `executionInterval` |
 | `simulationTime` | Controls execution based on simulation time | `startTime`, `endTime`, `executionInterval` |
-| `settings` | Uses parameters from settingsDict file | None (defined elsewhere) |
+| `settingsDict` | Uses parameters from settingsDict file | None (defined elsewhere) |
 | `default` | Uses the default time control settings (uses `defaultTimeControl` settings) | None (uses default) |
 
 If no time control is specified, the `default` option is used automatically.
@@ -111,14 +110,14 @@ If no time control is specified, the `default` option is used automatically.
 
 The postprocessing module provides several methods for processing particle data. They are categorized into two main groups: bulk and individual methods.
 
-- **Bulk Methods**: Operate on all particles that are located in a specified locations/regions (cells, spheres, etc.).
+- **Bulk Methods**: Operate on all particles that are located in specified locations/regions (cells, spheres, etc.).
 - **Individual Methods**: Operate on specific particles, allowing for targeted particle property extraction.
 
-| Method | Property type | Description | Formula |
-|--------|------------------|-------------|---------|
+| Method | Property Type | Description | Formula |
+|--------|---------------|-------------|---------|
 | `arithmetic` | bulk | Simple arithmetic mean/sum with equal weights | Each particle contributes equally |
 | `uniformDistribution` | bulk | Each particle contributes inversely proportional to the total number of particles | $w_i = 1/n$ where $n$ is the number of particles |
-| `GaussianDistribution` | bulk | Weight contribution based on distance from center with Gaussian falloff | $w_i = \exp(-\|x_i - c\|^2/(2\sigma^2))/\sqrt{2\pi\sigma^2}$ |
+| `GaussianDistribution` | bulk | Weight contribution based on distance from the center with Gaussian falloff | $w_i = \exp(-\|x_i - c\|^2/(2\sigma^2))/\sqrt{2\pi\sigma^2}$ |
 | `particleProbe` | individual | Extracts values from specific particles | Direct access to particle properties |
 
 ## 5. Region Types
@@ -131,11 +130,48 @@ Regions define where in the domain the postprocessing operations are applied:
 | `multipleSpheres` | Multiple spherical regions | `centers`, `radii` defined in `multiplSpheresInfo` dict | bulk |
 | `line` | Spheres along a line with specified radius | `p1`, `p2`, `nSpheres`, `radius` defined in `lineInfo` dict| bulk |
 | `box`| A cuboid region | `min`, `max` defined in `boxInfo` dict | bulk |
-| `centerPoints`* | Specific particles selected by ID | `ids` | individual |
-| `centerPoints`* | Specific particles selected by center points located in a box | `boxInfo` | individual |
-| `centerPoints`* | Specific particles selected by center points located in a sphere | `sphereInfo` | individual |
-| `centerPoints`* | Specific particles selected by center points located in a cylinder | `cylinderInfo` | individual |
-| <td colspan="4">\* Particles selection is done when simulation reaches the time that is specified by `startTime` of the post-process component and this selection remains intact up to the end of simulation. This is very good for particle tracking purposes or when you want to analyze specific particles behavior over time.</td> |
+| `rectMesh`** | creates a rectangular mesh and each direction is divided into equal spaces| corner points of mesh, and `nx`, `ny`, `nz`: number of divisions in each direction | bulk |
+| `centerPoints`* | if `selector` is set to `id`, particles selected by ID list | `ids`: a list of particle ids | individual |
+| `centerPoints`* | if `selector` is set to `box`, particles are selected by center points located in a box | corner points of the box are given in `boxInfo` sub-dict | individual |
+| `centerPoints`* | if `selector` is set to `sphere`, particles are selected by center points located in a sphere | center and radius of a sphere given in `sphereInfo` sub-dict | individual |
+| `centerPoints`* | if `selector` is set to `cylinder`, particles are selected by center points located in a cylinder | axis info and radius of cylinder at end points that are given in `cylinderInfo` sub-dict | individual |
+| <td colspan="3">\* Particles selection is done when simulation reaches the time that is specified by `startTime` of the post-process component and this selection remains intact up to the end of simulation. This is very good for particle tracking purposes or when you want to analyze specific particles behavior over time.</td> |
+| <td colspan="3">\** This region creates a rectangular mesh and particles are located into cells according to their center points. When using `GaussianDistribution` as `processMethod`, a larger neighbor radius is considered for each cell and particles inside this neighbor radius are included in the calculations.</td> |
+
+### output format
+
+The output format of the postprocessing results can be controlled by the `precision` and `scientific` parameters:
+
+- `precision`: Number of decimal places for the output (defualt is 6).
+- `scientific`: Whether to use scientific notation for large numbers (options: `yes`, `no`, default is `yes`).
+
+for example, if you want to use 5 decimal places and no scientific notation, you can set:
+
+```C++
+on_single_sphere
+{
+    processMethod    arithmetic;
+
+    processRegion    sphere;
+    
+    sphereInfo
+    {
+        radius  0.01;
+        center  (-0.08 -0.08 0.015);
+    }
+    
+    timeControl default;
+    
+    precision    5; // default is 6
+
+    scientific   no; // default is yes
+
+    operations
+    (
+        // a list of operations should be defined here
+    );
+}
+```
 
 ## 6. Processing Operations for Bulk Properties
 
@@ -166,7 +202,7 @@ where:
 
 ### 6.2. About fluctuation2 in average function
 
-Fluctuation2 is an optional parameter that can be used to account for fluctuations in the particle field values with respect to mean value of the field.
+`fluctuation2` is an optional parameter that can be used to account for fluctuations in the particle field values with respect to mean value of the field.
 It is used in the `average` function to calculate the fluctuation of the field values around the mean. The formula for fluctuation2 is:
 
 $$\text{fluctuation}^2 = \frac{\sum_j w_j \cdot \phi_j \cdot (\text{field}_j - \text{mean})^2}{\sum_i w_i \cdot \phi_i}$$
@@ -184,6 +220,8 @@ In addition to the above basic functions, some derived functions are available f
 | Function | Property type | Description | Formula | Required Parameters |
 |----------|---------------|-------------|---------|---------------------|
 |`avMassVelocity` | bulk | Average velocity weighted by mass | $\frac{\sum_{i \in \text{region}} w_i \cdot m_i \cdot v_i}{\sum_{i \in \text{region}} w_i \cdot m_i}$ | - |
+|`solidVolFraction`| bulk| Volume fraction of solid| $\phi = \frac{\sum_{i \in \text{region}} w_i \cdot V_i}{V_{\text{region}}}$ | - |
+|`bulkDensity`| bulk| Bulk density of particles in the region | $\rho_{bulk} = \frac{\sum_{i \in \text{region}} w_i \cdot m_i}{V_{\text{region}}}$ | - |
 
 ### 6.4. Available Fields
 
@@ -349,6 +387,90 @@ along_a_line
 
 This example creates 10 spherical regions along a line from (0,0,0) to (0,0.15,0.15) and calculates the bulk density and volume density in each region.
 
+### 7.4 Example 4: Processing in a Rectangular Mesh
+
+In this example, a rectangular mesh is defined. The `rectMeshInfo` section specifies the minimum and maximum corner points of the box, the number of divisions in each direction, and an optional cell extension factor which is effective for GaussianDistribution only. In the `operations` section, two operations are defined: one for calculating the average velocity and another for calculating the solid volume fraction.
+
+```cpp
+on_a_rectMesh
+{
+    processMethod   GaussianDistribution;
+    processRegion   rectMesh;
+
+    timeControl     settingsDict; // uses settings from settingsDict file
+
+    rectMeshInfo 
+    {
+        min (-0.12 -0.12 0.00); // lower corner point of the box 
+        max (0.12   0.12 0.11); // upper corner point of the box
+        
+        nx 30; // number of divisions in x direction
+        ny 30; // number of divisions in y direction
+        nz 15; // number of divisions in z direction
+
+        // optional (default is 2.0)
+        // for each cell, a neighbor radius is considered. This neighbor radius is equal to 
+        // cellExtension * equivalent diameter of the cell. 
+        // cell extension is only effective when using GaussianDistribution as processMethod.
+        cellExtension 3; 
+    }
+
+    operations
+    (
+        avVelocity
+        {
+            function     average;
+            field        velocity;
+            fluctuation2 yes;
+            threshold    4;
+            phi          mass;
+        }
+
+        solidVolumeFraction
+        {
+            function sum;
+            field    volume;
+            divideByVolume yes;
+        }
+    );
+}
+```
+
+### 7.5 Example 5: Tracking particles
+
+Suppose we want to mark and track the position of particles that are located inside a box region at t = 1 s. All particles that are inside the box at t = 1 s will be marked/selected and then the position of them are recorded along the simulation time. The following example shows how to do this. Note that marking/selecting of particles is done at the instance that is defined by `startTime`.  
+
+```C++
+particlesTrack
+{
+    processMethod      particleProbe;
+    
+    processRegion      centerPoints;
+    
+    // all particles whose ceters are located inside this box 
+    // are selected. Selection occurs at startTime: particles 
+    // that are inside the box at t = startTime. 
+    selector           box;
+    boxInfo
+    {
+        min            (0 0 0);
+        max            (0.1 0.05 0.05);
+    }
+    
+    // center position of selected particles are processed 
+    field              position;
+    
+    timeControl        simulationTime;
+    // execution starts at 1.0 s
+    startTime           1.0;
+    // execution ends at 100 s
+    endTime             100;
+    // execution interval of this compoenent 
+    executionInterval   0.02;
+
+}
+```
+
 ## 8. Advanced Features
 
 ### 8.1. Special functions applied on fields
@@ -464,7 +586,7 @@ components
         field            component(velocity,y);
         ids              (0 10 100);
         timeControl      default; // other options are settings, timeStep, simulationTime 
-        // settings: uses parameters from settingsDict file
+        // settingsDict: uses parameters from settingsDict file
         // timeStep: uses the time step of the simulation controlling the execution of postprocessing
         // simulationTime: uses the simulation time of the simulation controlling the execution of postprocessing
         // default: uses the default time control (defined in defaultTimeControl).
@@ -481,6 +603,7 @@ components
         // are selected. Selection occurs at startTime: particles 
         // that are inside the box at t = startTime. 
         selector           box;
+
         boxInfo
         {
             min            (0 0 0);
@@ -490,6 +613,14 @@ components
         // center position of selected particles are processed 
         field              position;
 
+        // precision for output to file (optional: default is 6)
+        precision           8;
+
+        // if the output format of numbers in scientific format 
+        // is required, set scientific to yes, otherwise no
+        // (optional: default is yes)
+        scientific          no;
+        
         timeControl        simulationTime;
         // execution starts at 1.0 s
         startTime           1.0;
@@ -500,6 +631,57 @@ components
 
     }
 
+    on_a_rectMesh
+    {
+        processMethod   GaussianDistribution;
+        processRegion   rectMesh;
+
+        timeControl     settingsDict; // uses settings from settingsDict file
+
+        rectMeshInfo 
+        {
+            min (-0.12 -0.12 0.00); // lower corner point of the box 
+            max (0.12   0.12 0.11); // upper corner point of the box
+            
+            nx 30; // number of divisions in x direction
+            ny 30; // number of divisions in y direction
+            nz 15; // number of divisions in z direction
+
+            // optional (default is 2.0)
+            // for each cell, a neighbor radius is considered. This neighbor radius is equal to 
+            // cellExtension * equivalent diameter of the cell. 
+            // cell extension is only effective when using GaussianDistribution as processMethod.
+            cellExtension 3; 
+        }
+
+        // precision for output to file (optional: default is 6)
+        precision   5;
+
+        // if the output format of numbers in scientific format
+        // is required, set scientific to yes, otherwise no
+        // (optional: default is yes)
+        scientific  no; 
+
+        operations
+        (
+            avVelocity
+            {
+                function     average;
+                field        velocity;
+                fluctuation2 yes;
+                threshold    4;
+                phi          mass;
+            }
+
+            solidVolumeFraction
+            {
+                function sum;
+                field    volume;
+                divideByVolume yes;
+            }
+        );
+    }
+    
     on_single_sphere
     {
         // method of performing the sum (arithmetic, uniformDistribution, GaussianDistribution)

src/PostprocessData/region/regionFields/regionField.hpp

@@ -24,6 +24,7 @@ Licence:
 #include "types.hpp"
 #include "regionPoints.hpp"
 #include "Field.hpp"
+#include "cellMapper.hpp"
 
 namespace pFlow::postprocessData
 {
@@ -101,6 +102,11 @@ public:
         return field_.size();
     }
 
+    uint32x3 shape()const
+    {
+        return regionPoints_.shape();
+    }
+
     bool empty()const
     {
         return field_.empty();

src/PostprocessData/region/regionFields/regionFieldTemplate.cpp

@@ -1,3 +1,6 @@
+
+
+
 namespace pFlow::postprocessData
 {
 
@@ -9,6 +12,86 @@ regionField<T>::regionField(
 :
     field_(name, "regionFieldValue", rPoints.size(), rPoints.size(), defaultVal),
     regionPoints_(rPoints)
+
 {}
 
+template<typename T>
+inline
+bool regionField<T>::writeFieldToVtk(iOstream& os)const
+{
+    fatalErrorInFunction<< "This type is not supported for vtk conversion:"<<
+	field_.typeName()<<endl;
+	fatalExit;
+    return false;
+}
+
+template<>
+inline
+bool regionField<real>::writeFieldToVtk(iOstream& os)const
+{
+    os<<"FIELD FieldData 1 " << field_.name() << " 1 "<< field_.size() << " float\n";
+    
+    
+    const auto mapper = cellMapper{shape()};
+
+    for(uint32 k=0; k<mapper.nz(); k++)
+    {
+        for(uint32 j=0; j<mapper.ny(); j++)
+        {
+            for(uint32 i=0; i<mapper.nx(); i++)
+            {
+                os<< field_[ mapper(i,j,k) ]<<'\n';
+            }
+        }
+    }
+    os<<endl;
+    return true;
+}
+
+template<>
+inline
+bool regionField<realx3>::writeFieldToVtk(iOstream& os)const
+{
+    os<<"FIELD FieldData 1 " << field_.name() << " 3 "<< field_.size() << " float\n";
+    
+    
+    const auto mapper = cellMapper{shape()}; 
+
+    for(uint32 k=0; k<mapper.nz(); k++)
+    {
+        for(uint32 j=0; j<mapper.ny(); j++)
+        {
+            for(uint32 i=0; i<mapper.nx(); i++)
+            {
+                os<<field_[mapper(i,j,k)].x()<<' '<<field_[mapper(i,j,k)].y()<<' '<<field_[mapper(i,j,k)].z()<<'\n';
+            }
+        }
+    }
+    os<<endl;
+    return true;
+}
+
+template<>
+inline
+bool regionField<uint32>::writeFieldToVtk(iOstream& os)const
+{
+    os<<"FIELD FieldData 1 " << field_.name() << " 1 "<< field_.size() << " int\n";
+    
+    
+    const auto mapper = cellMapper{shape()} ; 
+
+    for(uint32 k=0; k<mapper.nz(); k++)
+    {
+        for(uint32 j=0; j<mapper.ny(); j++)
+        {
+            for(uint32 i=0; i<mapper.nx(); i++)
+            {
+                os<< field_[ mapper(i,j,k) ]<<'\n';
+            }
+        }
+    }
+    os<<endl;
+    return true;
+}
+
 } // End namespace pFlow::postprocessData

src/PostprocessData/region/regionPoints/rectMeshRegionPoints/cellMapper.hpp

@@ -0,0 +1,56 @@
+
+#ifndef __cellMapper_hpp__
+#define __cellMapper_hpp__
+
+#include "types.hpp"
+
+namespace pFlow::postprocessData
+{
+
+struct cellMapper
+{
+    uint32x3 cells_;
+
+    cellMapper()
+    :
+        cells_()
+    {}
+
+    explicit cellMapper(uint32x3 cells)
+    :
+        cells_(cells)
+    {}
+
+    cellMapper(const cellMapper&) = default;
+    cellMapper(cellMapper&&) = default;
+    cellMapper& operator=(const cellMapper&) = default;
+    cellMapper& operator=(cellMapper&&) = default;
+    ~cellMapper() = default;
+
+    inline
+    uint32 operator()(uint32 i, uint32 j, uint32 k)const
+    {
+        return (k*(cells_.y()*cells_.x()))+j*cells_.x() + i;
+    }
+
+    uint32 nx()const
+    {
+        return cells_.x();
+    }
+
+    uint32 ny()const
+    {
+        return cells_.y();
+    }
+
+    uint32 nz()const
+    {
+        return cells_.z();
+    }
+
+};
+
+
+} //pFlow::postprocessData
+
+#endif //__cellMapper_hpp__

src/PostprocessData/region/regionPoints/rectMeshRegionPoints/rectMeshRegionPoints.cpp

@@ -0,0 +1,224 @@
+#include "rectMeshRegionPoints.hpp"
+#include "fieldsDataBase.hpp"
+#include "numericConstants.hpp"
+
+void pFlow::postprocessData::rectMeshRegionPoints::findPointsBeyoundCells()
+{
+    // check if pointsBeyoundCells_ is initialized
+    if(!pointsBeyoundCells_)
+    {
+        pointsBeyoundCells_ = makeUnique<decltype(pointsOnCells_)>
+        (
+            "selectedPoints2",
+            this->size()
+        );
+    }
+
+    // get the reference to pointsBeyoundCells_ and clear it
+    auto& selectedPoints = pointsBeyoundCells_();
+
+    // point positions are obtained from the database
+    const auto points = database().updatePoints();
+
+    // iterate through all cells to find points that are within the search radius
+    for(int32 i=0; i<mapper_.nx(); i++)
+    {
+        for(int32 j=0; j<mapper_.ny(); j++)
+        {
+            for(int32 k=0; k<mapper_.nz(); k++)
+            {
+                uint32 cellIndex = mapper_(i,j,k);
+
+                // copy the points in the center cell
+                auto& cellIndices = selectedPoints[cellIndex];
+                cellIndices.clear();
+                
+                
+                if(pointsOnCells_[cellIndex].empty())
+                    continue;
+
+                const auto cellCenter = centerPoints_[cellIndex];
+                const auto rad = 0.5*diameter_[cellIndex];
+                
+                for(int32 ii=-2; ii <= 2; ++ii)
+                {
+                    for(int32 jj=-2; jj <= 2; ++jj)
+                    {
+                        for(int32 kk=-2; kk <= 2; ++kk)
+                        {
+
+                            int32 ni = i + ii;
+                            int32 nj = j + jj;
+                            int32 nk = k + kk;
+                            if(ni < 0 || nj < 0 || nk < 0)
+                                continue;
+                            
+                            if(ni >= mapper_.nx() || nj >= mapper_.ny() || nk >= mapper_.nz())
+                                continue;
+                            
+                            uint32 neighborIndex = mapper_(ni, nj, nk);
+
+                            const auto& neighborPoints = pointsOnCells_[neighborIndex];
+
+                            for(auto nIndx : neighborPoints)
+                            {
+                                if( (points[nIndx]-cellCenter).length() < rad )
+                                {
+                                    cellIndices.push_back(nIndx);
+                                }
+                            }
+
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+pFlow::postprocessData::rectMeshRegionPoints::rectMeshRegionPoints
+(
+    const dictionary &dict, 
+    fieldsDataBase &fieldsDataBase
+)
+:
+    regionPoints(dict, fieldsDataBase),
+    boxRegion_(dict.subDict("rectMeshInfo")),
+    cellExtension_(dict.subDict("rectMeshInfo").getValOrSet<real>("cellExtension", 2.0)),
+    pointsOnCells_("selectedPoints"),
+    selectedPoints_(pointsOnCells_)
+{
+    cellExtension_ = max(cellExtension_, one);
+
+    const auto& rectMeshInfo = dict.subDict("rectMeshInfo");
+    
+    auto nx = rectMeshInfo.getValMax<uint32>("nx", 1);
+    auto ny = rectMeshInfo.getValMax<uint32>("ny", 1);
+    auto nz = rectMeshInfo.getValMax<uint32>("nz", 1);
+    
+    mapper_ = cellMapper(uint32x3(nx, ny, nz));
+    uint32 nCells = mapper_.nx() * mapper_.ny() * mapper_.nz();
+    real vol = boxRegion_.volume() / nCells;
+    volumes_.resize(nCells, vol);
+    diameter_.resize(nCells, 2 * pow(3 * vol / 4.0 / Pi, 0.3333333));
+    pointsOnCells_.resize(nCells);
+    centerPoints_.resize(nCells);
+
+    real dx = (boxRegion_.maxPoint().x() - boxRegion_.minPoint().x()) / mapper_.nx();
+    real dy = (boxRegion_.maxPoint().y() - boxRegion_.minPoint().y()) / mapper_.ny();
+    real dz = (boxRegion_.maxPoint().z() - boxRegion_.minPoint().z()) / mapper_.nz();
+    
+    for(uint32 i = 0; i < nx; ++i)
+    {
+        for(uint32 j = 0; j < ny; ++j)
+        {
+            for(uint32 k = 0; k < nz; ++k)
+            {
+                realx3 center = boxRegion_.minPoint() + 
+                    realx3(
+                        ( static_cast<real>(i) + 0.5) * dx,
+                        ( static_cast<real>(j) + 0.5) * dy,
+                        ( static_cast<real>(k) + 0.5) * dz
+                    );
+                centerPoints_[mapper_(i, j, k)] = center;
+            }
+        }
+    }
+}
+
+void pFlow::postprocessData::rectMeshRegionPoints::applyRegionExtension()
+{
+    // it cannot be lower than 1
+    cellExtension_ = max(one, cellExtension_);
+
+    real vf = pow(cellExtension_, 3);
+    for(auto& v:volumes_)
+    {
+        v *= vf;
+    }
+
+    for(auto& d:diameter_)
+    {
+        d *= cellExtension_;
+    }
+}
+
+bool pFlow::postprocessData::rectMeshRegionPoints::update()
+{
+    const auto points = database().updatePoints();
+    for (auto& elem : pointsOnCells_)
+    {
+        elem.clear();
+    }
+ 
+    real dx = (boxRegion_.maxPoint().x() - boxRegion_.minPoint().x()) / mapper_.nx();
+    real dy = (boxRegion_.maxPoint().y() - boxRegion_.minPoint().y()) / mapper_.ny();
+    real dz = (boxRegion_.maxPoint().z() - boxRegion_.minPoint().z()) / mapper_.nz();
+
+    for (uint32 i = 0; i < points.size(); ++i)
+    {
+        if(boxRegion_.isInside(points[i]))
+        {
+            uint32 indexX = (points[i] - boxRegion_.minPoint()).x() / dx;
+            uint32 indexY = (points[i] - boxRegion_.minPoint()).y() / dy;
+            uint32 indexZ = (points[i] - boxRegion_.minPoint()).z() / dz;
+            pointsOnCells_[mapper_(indexX, indexY, indexZ)].push_back(i);
+        }
+    }
+
+    // search beyound cells is not required
+    if( equal(cellExtension_,one))
+    {
+        selectedPoints_ = pointsOnCells_;
+        return true;
+    }
+
+    // search beyound cells is required
+    findPointsBeyoundCells();
+    selectedPoints_ = pointsBeyoundCells_();
+
+    return true;
+}
+
+bool pFlow::postprocessData::rectMeshRegionPoints::write(iOstream &os) const
+{
+
+    auto [x, y , z] = boxRegion_.minPoint();
+    auto [nx, ny, nz] = mapper_.cells_;
+    real dx = (boxRegion_.maxPoint().x() - boxRegion_.minPoint().x()) / mapper_.nx();
+    real dy = (boxRegion_.maxPoint().y() - boxRegion_.minPoint().y()) / mapper_.ny();
+    real dz = (boxRegion_.maxPoint().z() - boxRegion_.minPoint().z()) / mapper_.nz();
+
+
+    os << "# vtk DataFile Version 3.0" << endl;
+    os << "postProcessData" << endl;
+    os << "ASCII" << endl;
+    os << "DATASET RECTILINEAR_GRID" << endl;
+	os << "DIMENSIONS " << nx + 1 << " " << ny + 1 << " " << nz + 1 << endl;
+	
+    os << "X_COORDINATES " << nx + 1 << " float\n";
+    for(int32 i = 0; i < nx + 1; i++)
+    {
+        os << x << "\n";
+        x += dx;
+    }
+
+    os << "Y_COORDINATES " << ny + 1 << " float\n";
+    for(int32 j = 0; j < ny + 1; j++)
+    {
+        os << y << "\n";
+        y += dy;
+    }
+
+    os << "Z_COORDINATES " << nz + 1 << " float\n";
+    for(int32 j = 0; j < nz + 1; j++)
+    {
+        os << z << "\n";
+        z += dz;
+    }
+
+    os << "CELL_DATA " << nx * ny * nz << endl;
+
+    return true;
+}

src/PostprocessData/region/regionPoints/rectMeshRegionPoints/rectMeshRegionPoints.hpp

@@ -0,0 +1,222 @@
+/*------------------------------- 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.
+
+-----------------------------------------------------------------------------*/
+
+/**
+ * @file rectMeshRegionPoints.hpp
+ * @brief A class representing a rectMesh region for point selection
+ * 
+ * This class provides functionality to select points within a rectMesh region
+ * and to compute related properties such as volume and equivalent diameter.
+ * It inherits from regionPoints and implements all required virtual methods.
+ * 
+ * @see regionPoints
+ * @see fieldsDataBase
+ */
+
+#ifndef __rectMeshRegionPoints_hpp__
+#define __rectMeshRegionPoints_hpp__
+
+#include "regionPoints.hpp"
+#include "box.hpp"
+#include "Vectors.hpp"
+#include "cellMapper.hpp"
+
+
+namespace pFlow::postprocessData
+{
+
+
+class rectMeshRegionPoints
+:
+    public regionPoints
+{
+private:
+
+    /// box object defining the region for point selection
+    box             boxRegion_;
+
+    /// store the cells that are inside the box region
+    cellMapper      mapper_;
+
+    /// Center points of each cell in the rectMesh region
+    realx3Vector    centerPoints_;
+
+    /// Volume of each cell in the rectMesh region
+    realVector      volumes_;
+
+    /// Diameter of each cell in the rectMesh region
+    realVector      diameter_;
+
+    real            cellExtension_;
+
+    Vector<uint32Vector>            pointsOnCells_;
+
+    uniquePtr<Vector<uint32Vector>> pointsBeyoundCells_;
+
+    /// Indices of points that are selected by this region
+    Vector<uint32Vector>&           selectedPoints_;
+
+
+    void findPointsBeyoundCells();
+
+public:
+
+    TypeInfo("rectMesh");
+
+    /**
+     * @brief Construct a rectMesh region for point selection
+     * 
+     * @param dict Dictionary containing sphereInfo dictionary 
+     * @param fieldsDataBase Database containing fields data
+     */
+    rectMeshRegionPoints(
+        const dictionary& dict,
+        fieldsDataBase& fieldsDataBase);
+
+    /// Destructor
+    ~rectMeshRegionPoints() override = default;
+    
+    /**
+     * @brief Get the number of regions
+     */
+    uint32 size()const override
+    {
+        return volumes_.size();
+    }
+
+    /**
+     * return the shape of the field 
+     */
+    uint32x3 shape()const override
+    {
+        return mapper_.cells_;
+    }
+
+    const cellMapper&  mapper()const
+    {
+        return mapper_;
+    }
+
+    /**
+     * @brief Update the points selected by this region
+     * @return True if update was successful
+     */
+    bool empty()const override
+    {
+        return volumes_.empty();
+    }
+
+    void applyRegionExtension() override;
+
+     
+    real regionExtensionRatio()const override
+    {
+        return cellExtension_;
+    }
+
+    /**
+     * @brief Get the volume of the rectMesh region
+     * @return A span containing the volume of the region
+     */
+    span<const real> volumes()const override
+    {
+        return span<const real>(volumes_.data(), volumes_.size());
+    }
+
+    /**
+     * @brief Get the equivalent diameter of the rectMesh region
+     * @return A span containing the diameter of the region
+     */
+    span<const real> eqDiameters()const override
+    {
+        return span<const real>(diameter_.data(), diameter_.size());
+    }
+
+    /**
+     * @brief Get the center of the rectMesh region
+     * @return A span containing the center point of the region
+     */
+    span<const realx3> centers()const override
+    {
+        return span<const realx3>(centerPoints_.data(), centerPoints_.size());
+    }
+    
+    /**
+     * @brief Get the indices of points within the region (const version)
+     * @param elem Element index (ignored as there's only one sphere)
+     * @return A span containing indices of points within the region
+     */    
+    span<const uint32> indices(uint32 elem)const override
+    {
+        if (elem >= size())
+        {
+        fatalErrorInFunction
+            << "The element index is out of range. elem: " << elem
+            << " size: " << size() << endl;
+            fatalExit;
+        }
+
+        return span<const uint32>(selectedPoints_[elem].data(), selectedPoints_[elem].size());
+    }
+
+    /**
+     * @brief Get the indices of points within the region (non-const version)
+     * @param elem Element index (ignored as there's only one sphere)
+     * @return A span containing indices of points within the region
+     */
+    span<uint32> indices(uint32 elem) override
+    {
+        if (elem >= size())
+        {
+            fatalErrorInFunction
+            << "The element index is out of range. elem: " << elem
+            << " size: " << size() << endl;
+            fatalExit;
+        }
+
+        return span<uint32>(selectedPoints_[elem].data(), selectedPoints_[elem].size());
+    }
+
+    /**
+     * @brief Update the points selected by this region
+     * @return True if update was successful
+     */
+    bool update()override;
+
+    /**
+     * @brief Determine if data should be written to the same time file
+     */
+    bool writeToSameTimeFile()const override
+    {
+        return false;
+    }
+
+    /**
+     * @brief Write region data to output stream
+     * @param os Output stream to write to
+     * @return True if write was successful
+     */
+    bool write(iOstream& os)const override;
+    
+};
+
+}
+
+#endif // __sphereRegionPoints_hpp__

src/PostprocessData/region/regionPoints/regionPoints/regionPoints.cpp

@@ -12,7 +12,10 @@ regionPoints::regionPoints
 )
 :
     fieldsDataBase_(fieldsDataBase)
-{}
+{
+    precision_ = dict.getValOrSet<int>("precision", 6);
+    scientific_ = dict.getValOrSet<Logical>("scientific", Logical(true));
+}
 
 const Time& regionPoints::time() const
 {

src/PostprocessData/region/regionPoints/regionPoints/regionPoints.hpp

@@ -54,6 +54,12 @@ class regionPoints
     /// Reference to the fields database containing simulation data
     fieldsDataBase& fieldsDataBase_;
 
+    /// default precision for output
+    int precision_ = 6;
+
+    /// if scientific notation is used for output
+    Logical scientific_;
+
 public:
 
     TypeInfo("regionPoints");
@@ -75,14 +81,41 @@ public:
     /// Returns non-const reference to the fields database
     fieldsDataBase& database();
 
+    int precision() const
+    {
+        return precision_;
+    }
+    
+    bool scientific()const
+    {
+        return scientific_(); 
+    }
     /// @brief size of elements 
     virtual 
     uint32 size()const = 0;
 
+    virtual 
+    uint32x3 shape()const
+    {
+      return uint32x3(size(), 1u, 1u);
+    }
+    
     /// @brief  check if the region is empty
     virtual 
     bool empty()const = 0;  
     
+    /// by default it does nothing
+    /// But, it can be used for the methods that needs to search for 
+    /// particles which are beyound the region 
+    virtual void applyRegionExtension()
+    {}
+
+    virtual 
+    real regionExtensionRatio()const
+    {
+        return 1.0;
+    }
+
     /// @brief  volume of elements
     /// @return sapn for accessing the volume of elements 
     virtual 

src/PostprocessData/sampleDictionary/postprocessDataDict

@@ -39,7 +39,7 @@ components
         field            component(velocity,y);
         ids              (0 10 100);
         timeControl      default; // other options are settings, timeStep, simulationTime 
-        // settings: uses parameters from settingsDict file
+        // settingsDict: uses parameters from settingsDict file
         // timeStep: uses the time step of the simulation controlling the execution of postprocessing
         // simulationTime: uses the simulation time of the simulation controlling the execution of postprocessing
         // default: uses the default time control (defined in defaultTimeControl).
@@ -75,6 +75,49 @@ components
 
     }
 
+    on_a_rectMesh
+    {
+        processMethod   GaussianDistribution;
+        processRegion   rectMesh;
+
+        timeControl     settingsDict; // uses settings from settingsDict file
+
+        rectMeshInfo 
+        {
+            min (-0.12 -0.12 0.00); // lower corner point of the box 
+            max (0.12   0.12 0.11); // upper corner point of the box
+            
+            nx 30; // number of divisions in x direction
+            ny 30; // number of divisions in y direction
+            nz 15; // number of divisions in z direction
+
+            // optional (default is 2.0)
+            // for each cell, a neighbor radius is considered. This neighbor radius is equal to 
+            // cellExtension * equivalent diameter of the cell. 
+            // cell extension is only effective when using GaussianDistribution as processMethod.
+            cellExtension 3; 
+        }
+
+        operations
+        (
+            avVelocity
+            {
+                function     average;
+                field        velocity;
+                fluctuation2 yes;
+                threshold    4;
+                phi          mass;
+            }
+
+            solidVolumeFraction
+            {
+                function sum;
+                field    volume;
+                divideByVolume yes;
+            }
+        );
+    }
+    
     on_single_sphere
     {
         // method of performing the sum (arithmetic, uniformDistribution, GaussianDistribution)
@@ -154,7 +197,6 @@ components
         endTime     3.0;
         executionInterval 0.1;
         
-
         // 10 spheres with radius 0.01 along the straight line defined by p1 and  p2 
         lineInfo
         {