how to build updated

doc/mdDocs/howToBuild.md

@@ -0,0 +1,149 @@
+# How to build PhasicFlow {#howToBuildPhasicFlow}
+
+You can build PhasicFlow for CPU or GPU. You can have a single build or oven multiple builds on a machine. Here you learn how to have a single build of PhasicFlow, in various modes of execution. 
+
+# Required packages
+You need a list of packaged installed on your computer before building PhasicFlow:
+* git, for cloning the code and package management
+* g++, for compiling the code
+* cmake, for generating build system
+* tbb, a parallel library for STL algorithms
+* Cuda (if GPU is targeted), for compiling the code for CUDA execution.
+* Kokkos, the parallelization backend of PhasicFlow 
+
+### git 
+if git is not installed on your computer, enter the following commands 
+```
+$ sudo apt update
+$ sudo apt install git
+```
+ 
+
+### g++ (C++ compiler)
+The code is tested with g++ (gnu C++ compiler). The default version of g++ on Ubuntu 18.04 LTS or upper is sufficient for compiling. If it is not installed on your operating system, enter the following command:
+
+``` 
+$ sudo apt update
+$ sudo apt install g++
+```
+
+
+### CMake
+You also need to have CMake-3.22 or higher installed on your computer.
+``` 
+$ sudo apt update
+$ sudo apt install cmake
+```
+
+### tbb (2020.1-2 or higher)
+For **Ubuntu 20.04 LTS or higher versions**, you can install tbb using apt. For now, some parallel algorithms on host side rely on tbb parallel library (C++ parallel backend). Use e following commands to install it:
+```
+$ sudo apt update
+$ sudo apt install libtbb-dev
+```
+If you are compiling on **Ubuntu-18.04 LTS**, you need to enter the following commands to get the right version (2020.1-2 or higher) of tbb:
+```
+$ wget "http://archive.ubuntu.com/ubuntu/pool/universe/t/tbb/libtbb2_2020.1-2_amd64.deb"
+$ sudo dpkg --install libtbb2_2020.1-2_amd64.deb
+$ wget "http://archive.ubuntu.com/ubuntu/pool/universe/t/tbb/libtbb-dev_2020.1-2_amd64.deb"
+$ sudo dpkg --install libtbb-dev_2020.1-2_amd64.deb
+```
+### Cuda
+If you want to build PhasicFlow to be executed on an nvidia-GPU, you need to install the latest version of Cuda compiler, which is compatible with your hardware and OS, on your computer. 
+
+# How to build? 
+Here you will learn how to build PhasicFlow for single execution mode. Follow the steps below to install it on your computer. 
+Tested operating systems are:
+* Ubuntu 18.04 LTS
+* Ubuntu 20.04 LTS
+* Ubuntu 22.04 LTS
+
+### Step 1: Package check
+Make sure that you have installed all the required packages on your computer. See above for more information.
+
+### Step 2: Cloning Kokkos
+It is assumed that Kokkos source is located in the home folder of your computer. Clone the latest version of Kokkos into your home folder:
+```
+$ cd ~
+$ mkdir Kokkos
+$ cd Kokkos
+$ git clone https://github.com/kokkos/kokkos.git
+```
+or simply download and extract the source code of Kokkos in `~/Kokkos` folder. In the end, the top level CMakeLists.txt file should be located in `~/Kokkos/kokkos` folder. 
+
+### Step 3: Cloning PhasicFlow
+Create the PhasicFlow folder in your home folder and then clone the source code into that folder:
+```
+$ cd ~
+$ mkdir PhasicFlow
+$ cd PhasicFlow
+$ git clone https://github.com/PhasicFlow/phasicFlow.git
+```
+### Step 4: Environmental variables
+Opne the bashrc file using the following command:
+
+`$ gedit ~/.bashrc`
+
+and add the following line to the end of the file, **save** and **close** it.
+
+`source $HOME/PhasicFlow/phasicFlow/cmake/bashrc`
+
+this will introduce a new source file for setting the environmental variables of PhasicFlow. If you want to load these variables in the current open terminal, you need to source it. Or, simply **close the terminal** and **open a new terminal**.
+
+### Step 5: Building PhasicFlow
+Follow one of the followings to build PhasicFlow for one mode of execution.
+#### Serial build for CPU
+In a **new terminal** enter the following commands:
+```
+$ cd ~/PhasicFlow/phasicFlow
+$ mkdir build
+$ cd build
+$ cmake ../ -DpFlow_Build_Serial=On
+$ make install
+```
+For faster builds, use `make install -j`. This will use all the CPU cores on your computer for building. 
+#### OpenMP build for CPU
+```
+$ cd ~/PhasicFlow/phasicFlow
+$ mkdir build
+$ cd build
+$ cmake ../ -DpFlow_Build_OpenMP=On
+$ make install
+```
+#### GPU build for parallel execution on CUDA-enabled GPUs
+```
+$ cd ~/PhasicFlow/phasicFlow
+$ mkdir build
+$ cd build
+$ cmake ../ -DpFlow_Build_Cuda=On
+$ make install
+```
+
+After building, `bin`, `include`, and `lib` folders will be created in `~/PhasicFlow/phasicFlow/` folder. Now you are ready to use PhasicFlow.
+
+**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. 
+
+**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`
+
+### Step 6: Testing
+In the current terminal or a new terminal enter the following command:
+
+`$ ~checkPhasicFlow`
+
+This command shows the host and device environments and software version. If PhasicFlow was build correctly, you would get the following output:
+```
+Initializing host/device execution spaces . . . 
+  Host execution space is Serial
+  Device execution space is Cuda
+
+  ou are using phasicFlow v-0.1 (copyright(C): www.cemf.ir)
+  In this build, double is used for floating point operations.
+
+
+Finalizing host/device execution space ....
+```

doc/mdDocs/mainpage.md

@@ -1,9 +1,9 @@
-PhasicFlow is an open-source, parallel, multi-artitecture code for discrete element simulation (DEM) simulation of granular and multi-phase flows. It is developed in C++ and can be built and executed on **multi-core CPUs** or **GPUs**. It is fast and scalable code for large simulation. For now, we have performed simulations upto 32,000,000 particles on mid-range GPUs. The calculations can be done based on single precision (float type in C++) or double precision (double type in C++). This option can be selected when the code is first built.  
+PhasicFlow is an open-source, parallel, multi-architecture code for discrete element simulation (DEM) simulation of granular and multi-phase flows. It is developed in C++ and can be built and executed on **multi-core CPUs** or **GPUs**. It is fast and scalable code for large simulation. For now, we have performed simulations up-to 32,000,000 particles on mid-range GPUs. The calculations can be done based on single precision (float type in C++) or double precision (double type in C++). This option can be selected when the code is first built.  
-It solves the Newton's second law of motion and Euler's second law of motion for the translational and rotational motion of spherical particles. The code is not restricted to a specifict geometry or wall motion. It is designed in a way that additional features can be added to the code very easily.
+It solves the Newton's second law of motion and Euler's second law of motion for the translational and rotational motion of spherical particles. The code is not restricted to a specific geometry or wall motion. It is designed in a way that additional features can be added to the code very easily.
 
 ## Explore more
 * [Features of PhasicFlow](@ref phasicFlowFeatures)
-* [How to build PhasicFlow](https://github.com/PhasicFlow/phasicFlow/wiki/How-to-Build-PhasicFlow)
+* [How to build PhasicFlow](@ref howToBuildPhasicFlow)
 * How to setup and run granular flow simulations
 * [Benchmarks and performance tests](https://github.com/PhasicFlow/phasicFlow/wiki/Performance-of-phasicFlow)
 

doc/mdDocs/phasicFlowFeatures.md

@@ -3,9 +3,9 @@
 ## Building options
 You can build PhasicFlow to be executed on multi-core CPUs or GPUs. It is also possible to select the type of floating point variables in PhasicFlow: double or float. float type requires less memory and mostly consumes less time of a processor to complete a mathematical operation. So, there is a benefit for using floats in DEM simulation specially when GPU is targeted for computations. 
 Build options for PhasicFlow:
-* **serial (double or sinlge type)**: execution on one cpu core
+* **serial (double or float type)**: execution on one cpu core
-* **OpenMp (double or single type)**: execution on multiple cores of a CPU
+* **OpenMp (double or float type)**: execution on multiple cores of a CPU
-* **cuda (double or sngle type)**: execution on cuda-enabled GPUs
+* **cuda (double or float type)**: execution on cuda-enabled GPUs