xfygogo
/
phasicFlow
mirror of https://github.com/PhasicFlow/phasicFlow.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into documentation

This commit is contained in:
Hamidreza Norouzi 2023-03-31 10:49:33 -07:00
parent 04f3b2a150 8faa1a5e53
commit fa666de68a
15 changed files with 798 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
doc/Doxyfile
View File

@ -822,7 +822,8 @@ WARN_LOGFILE =
INPUT = $(pFlow_PROJECT_DIR)/src \
$(pFlow_PROJECT_DIR)/utilities \
$(pFlow_PROJECT_DIR)/solvers \
mdDocs
mdDocs \
$(pFlow_PROJECT_DIR)/tutorials
# This tag can be used to specify the character encoding of the source files
# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@ -866,7 +867,7 @@ RECURSIVE = YES
# Note that relative paths are relative to the directory from which doxygen is
# run.
EXCLUDE = $(pFlow_PROJECT_DIR)/src/phasicFlow/commandLine
EXCLUDE = $(pFlow_PROJECT_DIR)/src/phasicFlow/commandLine/CLI
# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
# directories that are symbolic links (a Unix file system feature) are excluded

8
doc/mdDocs/howToBuild.md
View File

@ -123,17 +123,19 @@ After building, `bin`, `include`, and `lib` folders will be created in `~/Phasic
**note 1**: When compiling the code in parallel, you need to have enough RAM on your computer. As a rule, you need 1 GB free RAM per each processor in your computer for compiling in parallel.
You may want to use fewer number of cores on your computer by using the following command:
`$ make install -j 3`
the above command uses only 3 cores for compiling.
the above command only uses 3 cores for compiling.
**note 2**: By default PhasicFlow is compiled with **double** as floating point variable. You can compile it with **float**. Just in the command line of camke added `-DpFlow_Build_Double=Off` flag to compile it with float. For example if you are building for cuda, you can enter the following command:
`$ cmake ../ -DpFlow_Build_Cuda=On --DpFlow_Build_Double=Off`
`$ cmake ../ -DpFlow_Build_Cuda=On -DpFlow_Build_Double=Off`
### Step 6: Testing
In the current terminal or a new terminal enter the following command:
`$ ~checkPhasicFlow`
`$ checkPhasicFlow`
This command shows the host and device environments and software version. If PhasicFlow was build correctly, you would get the following output:
```

5
doc/mdDocs/howToUsePhasicFlow.md Normal file
View File

@ -0,0 +1,5 @@
# How to use PhasicFlow {#howToUsePhasicFlow}
Here you will learn how to use PhasicFlow to setup a granular flow simulation. The inputs for simulation are supplied through some text-based files, called file dictionary, located in two folders: `settings` and `caseSetup`. These folders are located under the root case directory.
All the commands are performed through terminal in which the current working directory is root case directory (you see `settings` and `caseSetup` folders when `ls` command is entered). The states of geometry and particles are stored in time folders with names that represent the time. When simulation is finished, one case use post-processing tool pFlowToVTK to convert the stored results in the time folder into VTK file format. The VTK file format can be read by Paraview.
A set of tutorials with detailed descriptions are provided to show you how to use PhasicFlow for various granular flow problems. Here is a list of them.
* [Small rotating drum] (@ref rotatingDrumSmall)

47
src/MotionModel/entities/rotatingAxis/rotatingAxis.hpp
View File

@ -32,6 +32,33 @@ class rotatingAxis;
#include "rotatingAxisFwd.hpp"
/**
* An axis which rotates around itself at specified speed
*
* This defines an axis with two end points that rotates around
* itself at specified speed (rad/s).
*
*
\verbatim
// This creates an axis of rotation around x-axis, rotation starts at t = 1 s
// and ends at t = 5 s.
{
p1 (0 0 0);
p2 (1 0 0);
omega 1.57;
startTime 1;
endTime 5;
} \endverbatim
*
* | parameter | value type | discription | optional (default) |
* |----| ---- | ---- | ---- |
* | p1 | realx3 | begin point of axis | No |
* | p2 | realx3 | end point of axis | No |
* | omega | real | rotation speed (rad/s) | No |
* | startTime | real | start time of rotation (s) | Yes (0) |
* | endTime | real | end time of rotation (s) | Yes (infinity) |
*
*/
class rotatingAxis
:
public timeInterval,
@ -39,56 +66,72 @@ class rotatingAxis
{
protected:
// rotation speed
/// rotation speed
real omega_ = 0;
/// is rotating
bool rotating_ = false;
public:
// - Constructor
/// Empty constructor
FUNCTION_HD
rotatingAxis(){}
/// Construct from dictionary
FUNCTION_H
rotatingAxis(const dictionary& dict);
/// Construct from components
FUNCTION_HD
rotatingAxis(const realx3& p1, const realx3& p2, real omega = 0.0);
/// Copy constructor
FUNCTION_HD
rotatingAxis(const rotatingAxis&) = default;
/// Copy asssignment
rotatingAxis& operator=(const rotatingAxis&) = default;
/// Set omega
FUNCTION_HD
real setOmega(real omega);
/// Return omega
INLINE_FUNCTION_HD
real omega()const
{
return omega_;
}
/// Is rotating
INLINE_FUNCTION_HD
bool isRotating()const
{
return rotating_;
}
/// Linear tangential velocity at point p
INLINE_FUNCTION_HD
realx3 linTangentialVelocityPoint(const realx3 &p)const;
// - IO operation
/// Read from dictionary
FUNCTION_H
bool read(const dictionary& dict);
/// Write to dictionary
FUNCTION_H
bool write(dictionary& dict) const;
/// Read from input stream is
FUNCTION_H
bool read(iIstream& is);
/// Write to output stream os
FUNCTION_H
bool write(iOstream& os)const;

12
src/phasicFlow/commandLine/CLI/Timer.hpp → src/phasicFlow/commandLine/CLI/cliTimer.hpp
View File

@ -22,7 +22,7 @@
namespace CLI {
/// This is a simple timer with pretty printing. Creating the timer starts counting.
class Timer {
class cliTimer {
protected:
/// This is a typedef to make clocks easier to use
using clock = std::chrono::steady_clock;
@ -57,7 +57,7 @@ class Timer {
public:
/// Standard constructor, can set title and print function
explicit Timer(std::string title = "Timer", time_print_t time_print = Simple)
explicit cliTimer(std::string title = "cliTimer", time_print_t time_print = Simple)
: title_(std::move(title)), time_print_(std::move(time_print)), start_(clock::now()) {}
/// Time a function by running it multiple times. Target time is the len to target.
@ -111,17 +111,17 @@ class Timer {
std::string to_string() const { return time_print_(title_, make_time_str()); }
/// Division sets the number of cycles to divide by (no graphical change)
Timer &operator/(std::size_t val) {
cliTimer &operator/(std::size_t val) {
cycles = val;
return *this;
}
};
/// This class prints out the time upon destruction
class AutoTimer : public Timer {
class AutoTimer : public cliTimer {
public:
/// Reimplementing the constructor is required in GCC 4.7
explicit AutoTimer(std::string title = "Timer", time_print_t time_print = Simple) : Timer(title, time_print) {}
explicit AutoTimer(std::string title = "cliTimer", time_print_t time_print = Simple) : cliTimer(title, time_print) {}
// GCC 4.7 does not support using inheriting constructors.
/// This destructor prints the string
@ -131,4 +131,4 @@ class AutoTimer : public Timer {
} // namespace CLI
/// This prints out the time if shifted into a std::cout like stream.
inline std::ostream &operator<<(std::ostream &in, const CLI::Timer &timer) { return in << timer.to_string(); }
inline std::ostream &operator<<(std::ostream &in, const CLI::cliTimer &timer) { return in << timer.to_string(); }

1
tutorials/sphereGranFlow/rotatingDrumSmall/README.md
View File

@ -1,3 +1,4 @@
# Simulating a small rotating drum {#rotatingDrumSmall}
## Problem definition
The problem is to simulate a rotating drum with the diameter 0.24 m and the length 0.1 m rotating at 11.6 rpm. It is filled with 30,000 4-mm spherical particles. The timestep for integration is 0.00001 s.
<div align="center"><b>

265
tutorials/sphereGranFlow/toteblender/ReadMe.md Normal file
View File

@ -0,0 +1,265 @@
# Problem Definition
The problem is to simulate a double pedestal tote blender with the diameter **0.03 m** and **0.1 m** respectively, the length **0.3 m**, rotating at **28 rpm**. This blender is filled with **20000** Particles. The timestep for integration is **0.00001 s**. There is one type of Particle in this blender that are being inserted during simulation to fill the blender.
* **20000** particles with **4 mm** diameter, at the rate of 20000 particles/s for 1 sec. َAfter settling particles, this blender starts to rotate at t=**1s**.
<html>
<body>
<div align="center"><b>
a view of the tote-blender while rotating
</div></b>
<div align="center">
<img src="sample sample sample sample", width=700px>
</div>
</body>
</html>
# Setting up the Case
As it has been explained in the previous cases, the simulation case setup is based on text-based scripts. Here, the simulation case setup are sotred in two folders: `caseSetup`, `setting`. (see the above folders). Unlike the previous cases, this case does not have the `stl` file. and the geometry is described in the `geometryDict` file.
## Defining particles
Then in the `caseSetup/sphereShape` the diameter and the material name of the particles are defined.
```C++
// names of shapes
names (sphere1);
// diameter of shapes (m)
diameters (0.004);
// material names for shapes
materials (prop1);
```
## Particle Insertion
In this case we have a region for ordering particles. These particles are placed in this blender. For example the script for the inserted particles is shown below.
<div align="center">
in <b>caseSetup/particleInsertion</b> file
</div>
```C++
// positions particles
positionParticles
{
// ordered positioning
method positionOrdered;
// maximum number of particles in the simulation
maxNumberOfParticles 40000;
// perform initial sorting based on morton code?
mortonSorting Yes;
// cylinder for positioning particles
cylinder
{
// Coordinates of top cylinderRegion (m,m,m)
p1 (0.05 0.0 0.12);
p2 (0.05 0.0 0.22);
// radius of cylinder
radius 0.066;
}
positionOrderedInfo
{
// minimum space between centers of particles
diameter 0.003;
// number of particles in the simulation
numPoints 20000;
// axis order for filling the space with particles
axisOrder (z y x);
}
}
```
## Interaction between particles
In `caseSetup/interaction` file, material names and properties and interaction parameters are defined: interaction between the particles of rotating drum. Since we are defining 1 material for simulation, the interaction matrix is 1x1 (interactions are symetric).
```C++
// a list of materials names
materials (prop1);
// density of materials [kg/m3]
densities (1000.0);
contactListType sortedContactList;
model
{
contactForceModel nonLinearNonLimited;
rollingFrictionModel normal;
/*
Property (prop1-prop1);
*/
// Young modulus [Pa]
Yeff (1.0e6);
// Shear modulus [Pa]
Geff (0.8e6);
// Poisson's ratio [-]
nu (0.25);
// coefficient of normal restitution
en (0.7);
// coefficient of tangential restitution
et (1.0);
// dynamic friction
mu (0.3);
// rolling friction
mur (0.1);
}
```
## Settings
### Geometry
In the `settings/geometryDict` file, the geometry and axis of rotation is defined for the drum. The geometry is composed of a cylinder inlet and outlet, cone shell top and down, a cylinder shell and enter and exit Gate.
```C++
surfaces
{
topGate
topGate
{
// type of wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 0.299);
// end point of cylinder axis
p2 (0.0 0.0 0.3);
// radius at p1
radius1 0.03;
// radius at p2
radius2 0.0001;
// material of wall
material solidProperty;
// motion component name
motion axisOfRotation;
}
topCylinder
{
// type of the wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 0.28);
// end point of cylinder axis
p2 (0.0 0.0 0.3);
// radius at p1
radius1 0.03;
// radius at p2
radius2 0.03;
// number of divisions
resolution 36;
// material name of this wall
material prop1;
// motion component name
motion axisOfRotation;
}
coneShelltop
{
// type of the wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 0.2);
// end point of cylinder axis
p2 (0.0 0.0 0.28);
// radius at p1
radius1 0.1;
// radius at p2
radius2 0.03;
// number of divisions
resolution 36;
// material name of this wall
material prop1;
// motion component name
motion axisOfRotation;
}
cylinderShell
{
// type of the wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 0.1);
// end point of cylinder axis
p2 (0.0 0.0 0.2);
// radius at p1
radius1 0.1;
// radius at p2
radius2 0.1;
// number of divisions
resolution 36;
// material name of this wall
material prop1;
// motion component name
motion axisOfRotation;
}
coneShelldown
{
// type of the wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 0.02);
// end point of cylinder axis
p2 (0.0 0.0 0.1);
// radius at p1
radius1 0.03;
// radius at p2
radius2 0.1;
// number of divisions
resolution 36;
// material name of this wall
material prop1;
// motion component name
motion axisOfRotation;
}
/*
This is a plane wall at the exit of silo
*/
bottomCylinder
{
// type of the wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 0.0);
// end point of cylinder axis
p2 (0.0 0.0 0.02);
// radius at p1
radius1 0.03;
// radius at p2
radius2 0.03;
// number of divisions
resolution 36;
// material name of this wall
material prop1;
// motion component name
motion axisOfRotation;
}
exitGate
{
type planeWall;
p1 (-0.05 -0.05 0);
p2 (-0.05 0.05 0);
p3 ( 0.05 0.05 0);
p4 (0.05 -0.05 0);
material prop1;
motion axisOfRotation;
}
}
```
### Rotating Axis Info
In this part of `geometryDict` the information of rotating axis and speed of rotation are defined. Unlike the previous cases, the rotation of this blender starts at time=**0 s**.
```C++
// information for rotatingAxisMotion motion model
rotatingAxisMotionInfo
{
axisOfRotation
{
p1 (-0.1 0.0 0.15); // first point for the axis of rotation
p2 (0.1 0.0 0.15); // second point for the axis of rotation
omega 1.5708; // rotation speed ==> 15 rad/s
// Start time of Geometry Rotating (s)
startTime 1;
// End time of Geometry Rotating (s)
endTime 9.5;
}
}
```
## Performing Simulation
To perform simulations, enter the following commands one after another in the terminal.
Enter `$ particlesPhasicFlow` command to create the initial fields for particles.
Enter `$ geometryPhasicFlow` command to create the Geometry.
At last, enter `$ sphereGranFlow` command to start the simulation.
After finishing the simulation, you can use `$ pFlowtoVTK` to convert the results into vtk format storred in ./VTK folder.

76
tutorials/sphereGranFlow/toteblender/caseSetup/interaction Normal file
View File

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

15
tutorials/sphereGranFlow/toteblender/caseSetup/particleInsertion Normal file
View File

@ -0,0 +1,15 @@
/* -------------------------------*- C++ -*--------------------------------- *\
| phasicFlow File |
| copyright: www.cemf.ir |
\* ------------------------------------------------------------------------- */
objectName particleInsertion;
objectType dicrionary;
/* ------------------------------------------------------------------------- */
// is insertion active?
active no;
// not implemented for yes
collisionCheck No;

16
tutorials/sphereGranFlow/toteblender/caseSetup/sphereShape Normal file
View File

@ -0,0 +1,16 @@
/* -------------------------------*- C++ -*--------------------------------- *\
| phasicFlow File |
| copyright: www.cemf.ir |
\* ------------------------------------------------------------------------- */
objectName sphereDict;
objectType sphereShape;
/* ------------------------------------------------------------------------- */
// name of shapes
names (sphere1);
// diameter of shapes (m)
diameters (0.005);
// material name for shapes
materials (solidProperty);

7
tutorials/sphereGranFlow/toteblender/cleanThisCase Normal file
View File

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

21
tutorials/sphereGranFlow/toteblender/runThisCase Normal file
View File

@ -0,0 +1,21 @@
#!/bin/sh
cd ${0%/*} || exit 1 # Run from this directory
echo "\n<--------------------------------------------------------------------->"
echo "1) Creating particles"
echo "<--------------------------------------------------------------------->\n"
particlesPhasicFlow
echo "\n<--------------------------------------------------------------------->"
echo "2) Creating geometry"
echo "<--------------------------------------------------------------------->\n"
geometryPhasicFlow
echo "\n<--------------------------------------------------------------------->"
echo "3) Running the case"
echo "<--------------------------------------------------------------------->\n"
sphereGranFlow
#------------------------------------------------------------------------------

221
tutorials/sphereGranFlow/toteblender/settings/geometryDict Normal file
View File

@ -0,0 +1,221 @@
/* -------------------------------*- C++ -*--------------------------------- *\
| phasicFlow File |
| copyright: www.cemf.ir |
\* ------------------------------------------------------------------------- */
objectName geometryDict;
objectType dictionary;
/* ------------------------------------------------------------------------- */
// motion model: rotating object around an axis
motionModel rotatingAxisMotion;
// information for rotatingAxisMotion motion model
rotatingAxisMotionInfo
{
axisOfRotation
{
p1 (-0.1 0.0 0.15); // first point for the axis of rotation
p2 ( 0.1 0.0 0.15); // second point for the axis of rotation
omega 1.5708; // rotation speed ==> 15 rad/s
// Start time of Geometry Rotating (s)
startTime 0.5;
// End time of Geometry Rotating (s)
endTime 9.5;
}
}
surfaces
{
topGate
{
// type of wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 0.3);
// end point of cylinder axis
p2 (0.0 0.0 0.301);
// radius at p1
radius1 0.03;
// radius at p2
radius2 0.0001;
// material of wall
material solidProperty;
// motion component name
motion axisOfRotation;
}
topCylinder
{
// type of the wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 0.28);
// end point of cylinder axis
p2 (0.0 0.0 0.3);
// radius at p1
radius1 0.03;
// radius at p2
radius2 0.03;
// number of divisions
resolution 36;
// material name of this wall
material solidProperty;
// motion component name
motion axisOfRotation;
}
coneShelltop
{
// type of the wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 0.2);
// end point of cylinder axis
p2 (0.0 0.0 0.28);
// radius at p1
radius1 0.1;
// radius at p2
radius2 0.03;
// number of divisions
resolution 36;
// material name of this wall
material solidProperty;
// motion component name
motion axisOfRotation;
}
cylinderShell
{
// type of the wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 0.1);
// end point of cylinder axis
p2 (0.0 0.0 0.2);
// radius at p1
radius1 0.1;
// radius at p2
radius2 0.1;
// number of divisions
resolution 36;
// material name of this wall
material solidProperty;
// motion component name
motion axisOfRotation;
}
coneShelldown
{
// type of the wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 0.02);
// end point of cylinder axis
p2 (0.0 0.0 0.1);
// radius at p1
radius1 0.03;
// radius at p2
radius2 0.1;
// number of divisions
resolution 36;
// material name of this wall
material solidProperty;
// motion component name
motion axisOfRotation;
}
bottomCylinder
{
// type of the wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 0.0);
// end point of cylinder axis
p2 (0.0 0.0 0.02);
// radius at p1
radius1 0.03;
// radius at p2
radius2 0.03;
// number of divisions
resolution 36;
// material name of this wall
material solidProperty;
// motion component name
motion axisOfRotation;
}
exitGate
{
// type of the wall
type cylinderWall;
// begin point of cylinder axis
p1 (0.0 0.0 -0.001);
// end point of cylinder axis
p2 (0.0 0.0 0.0);
// radius at p1
radius1 0.03;
// radius at p2
radius2 0.0001;
// number of divisions
resolution 36;
// material name of this wall
material solidProperty;
// motion component name
motion axisOfRotation;
}
}

69
tutorials/sphereGranFlow/toteblender/settings/particlesDict Normal file
View File

@ -0,0 +1,69 @@
/* -------------------------------*- C++ -*--------------------------------- *\
| phasicFlow File |
| copyright: www.cemf.ir |
\* ------------------------------------------------------------------------- */
objectName particlesDict;
objectType dictionary;
/* ------------------------------------------------------------------------- */
setFields
{
/*
Default value for fields defined for particles
These fields should always be defined for simulations with
spherical particles.
*/
defaultValue
{
// linear velocity (m/s)
velocity realx3 (0 0 0);
// linear acceleration (m/s2)
acceleration realx3 (0 0 0);
// rotational velocity (rad/s)
rVelocity realx3 (0 0 0);
// name of the particle shape
shapeName word sphere1;
}
selectors
{}
}
// positions particles
positionParticles
{
// ordered positioning
method positionOrdered;
// maximum number of particles in the simulation
maxNumberOfParticles 25001;
// perform initial sorting based on morton code?
mortonSorting Yes;
// cylinder for positioning particles
cylinder
{
// Coordinates of top cylinderRegion (m,m,m)
p1 (0.0 0.0 0.09);
p2 (0.0 0.0 0.21);
// radius of cylinder
radius 0.09;
}
positionOrderedInfo
{
// minimum space between centers of particles
diameter 0.005;
// number of particles in the simulation
numPoints 24000;
// axis order for filling the space with particles
axisOrder (x y z);
}
}

43
tutorials/sphereGranFlow/toteblender/settings/settingsDict Normal file
View File

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