Procedures

This routine returns friction velocity computed in turbulent_wall bc and stored in mus_turb_wallFunc_data_type routine.

This routine returns the boundary normal pointing inside the domain

This routine returns normal distance to boundary calculated in mus_init_turbWallFunc and stored in mus_turb_wallFunc_data_type routine.

This routine returns turbulent viscosity computed in turbulent_wall bc according to RANS formulation and stored in mus_turb_wallFunc_data_type routine.

This routine returns yPlus = distToBnd * fric_vel / visc

This routine returns the omega

This routine returns the kinematic viscosity

This routine returns the reference pressure

This routine returns the boundary qValues

This routine returns the turbulent viscosity

Add a momentum increment to element with PosInTotal in total list

addCollisionForceToBuffer adds DEM collision force Fcoll to the force buffer sent to particle with id particleID on rank recvRankIndex.

ModifyAuxFieldCell is a helper routine that modifies the auxfield in the cell with position elemPos in the total list. It takes the total force F_particle and the vector r_lat (in lattice units) pointing from the particle location to the barycenter of the fluid element, then computes the weight and modifies the auxField. Performing addForceToAuxFieldCell over every neighboring cell around a particle (including the one the particle is on) distributes the entire force.

Routine to modify the auxField (velocity) with the forces exerted by particles on the fluid

Allocate BC lists, 2nd step in Build_BClists

Routine for allocating the existsOnProc, addToProc and removeFromProc masks used to determine when particles should be sent over to new processes or which processes need to receive position, velocity updates etc.

Routine to calculate the drag force according to [1] S. Tenneti, R. Garg, and S. Subramaniam, “Drag law for monodisperse gas–solid systems using particle-resolved direct numerical simulation of flow past fixed assemblies of spheres,” International Journal of Multiphase Flow, vol. 37, no. 9, pp. 1072–1092, Nov. 2011, doi: 10.1016/j.ijmultiphaseflow.2011.05.010.

ApplyHydrodynamicForces performs the momentum transfer from fluid TO particle

applyLiftForce_DPS computes the Saffman lift force on a particle according to the paper : Saffman PG. The lift on a small sphere in a slow shear flow. J Fluid Mech 1965;22(2):385–400. doi:10.1017/S0 022112065000824.

Calculate the pressure gradient force on a particle

Update state with source variable "absorb_layer". absorb_layer is used to absorb the flow and gradually reduce the flow quantities like pressure and velocity to a fixed value. It is based on: Xu, H., & Sagaut, P. (2013). Analysis of the absorbing layers for the weakly-compressible lattice Boltzmann methods. Journal of Computational Physics, 245(x), 14–42. Jacob, J.; Sagaut, P. (2019): Solid wall and open boundary conditions in hybrid recursive regularized lattice Boltzmann method for compressible flows. In Physics of Fluids 31 (12), p. 126103.

Update state with source variable "absorb_layer". absorb_layer is used to absorb the flow and gradually reduce the flow quantities like pressure and velocity to a fixed value. It is based on: Xu, H., & Sagaut, P. (2013). Analysis of the absorbing layers for the weakly-compressible lattice Boltzmann methods. Journal of Computational Physics, 245(x), 14–42. Jacob, J.; Sagaut, P. (2019): Solid wall and open boundary conditions in hybrid recursive regularized lattice Boltzmann method for compressible flows. In Physics of Fluids 31 (12), p. 126103.

Update state with source variable "absorb_layer". absorb_layer is used to absorb the flow and gradually reduce the flow quantities like pressure and velocity to a fixed value. It is based on: Xu, H., & Sagaut, P. (2013). Analysis of the absorbing layers for the weakly-compressible lattice Boltzmann methods. Journal of Computational Physics, 245(x), 14–42. Jacob, J.; Sagaut, P. (2019): Solid wall and open boundary conditions in hybrid recursive regularized lattice Boltzmann method for compressible flows. In Physics of Fluids 31 (12), p. 126103.

Update state with source variable "absorb_layer". absorb_layer is used to absorb the flow and gradually reduce the flow quantities like pressure and velocity to a fixed value. It is based on: Xu, H., & Sagaut, P. (2013). Analysis of the absorbing layers for the weakly-compressible lattice Boltzmann methods. Journal of Computational Physics, 245(x), 14–42. Jacob, J.; Sagaut, P. (2019): Solid wall and open boundary conditions in hybrid recursive regularized lattice Boltzmann method for compressible flows. In Physics of Fluids 31 (12), p. 126103.

Update state with source variable "absorb_layer". absorb_layer is used to absorb the flow and gradually reduce the flow quantities like pressure and velocity to a fixed value for incompressible model. It is based on: Xu, H., & Sagaut, P. (2013). Analysis of the absorbing layers for the weakly-compressible lattice Boltzmann methods. Journal of Computational Physics, 245(x), 14–42.

Update state with source variable Brinkman force obtained from Brinkman coefficient.

Update state with source variable Brinkman force obtained from Brinkman coefficient. The force update is for TRT collision model.

Update state with source variable "ChargeDensity" with 1st order integration of source Term. Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for Seawater Desalination"

Update state with source variable "ChargeDensity" with 2nd order integration of source Term. Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for

Update state with source variable "electric field"

Update state with source variable "electric_field" Simuilar to derive routine but it updates the state whereas derive is used for tracking

Update state with source variable "electric_field" with thermodynamic factor. Simuilar to derive routine but it updates the state whereas derive is used for tracking

Update state with source variable "electric_field" with 2nd order force integration. Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for Seawater Desalination"

Update state with source variable "electric_field" with 2nd order integration of force term in LBE with thermodynamic factor Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for Seawater Desalination"

Update state with source variable "equalInjection" Simuilar to derive routine but it updates the state whereas derive is used for tracking

Update state with source variable "force". Force term used here is from: "Discrete lattice effects on the forcing term in the lattice Boltzmann method", Zhaoli Guo, Chugung Zheng and Baochang Shi. In the paper, use force term is referred as Method 2 as: $$F_i = w_i( (\vec{e}_i-\vec{u}*)/cs2 + (\vec{e}_i \cdot \vec{u}*)\vec{e}_i/cs4) \cdot \vec{F}$$ Force must be defined as body force per unit volume KM: If this force formula is used then velocity needs to be computed as u = \sum c_i f_i + \vec{F}/2

Update state with source variable "force_1stOrd" Force term used here is from: "A D3Q27 multiple-relaxation-time lattice Boltzmann method for turbulent flows", K. Suga, Y. Kuwata, K. Takashima, R. Chikasue

Update state with source variable "force" for Generalized Navier-Stokes equations. The implementation is taken from "Lattice Boltzmann model for incompressible flows through porous media" by Z. Guo and T.S. Zhao (2002) Physical Review E.

Update state with source variable "force" for MRT collision model. Force term used here is from: Chai, Z., & Zhao, T. (2012). Effect of the forcing term in the multiple-relaxation-time lattice Boltzmann equation on the shear stress or the strain rate tensor. Physical Review E, 86(1), 1–11. Force term for MRT is $$\bar{F} = M^-1 (I-0.5 S) M F'$$ and $$F'_i = w_i( (\vec{e}_i-\vec{u}*)/cs2 + (\vec{e}_i \cdot \vec{u}*)\vec{e}_i/cs4) \cdot \vec{F}$$

Update state with source variable "force" for d3q19 MRT collision model. Force term used here is from: Chai, Z., & Zhao, T. (2012). Effect of the forcing term in the multiple-relaxation-time lattice Boltzmann equation on the shear stress or the strain rate tensor. Physical Review E, 86(1), 1–11. Force term for MRT is $$\bar{F} = M^-1 (I-0.5 S) M F'$$ and $$F'_i = w_i( (\vec{e}_i-\vec{u}*)/cs2 + (\vec{e}_i \cdot \vec{u}*)\vec{e}_i/cs4) \cdot \vec{F}$$

Update state with source variable "force" for d3q19 MRT collision model. Force term used here is from: Chai, Z., & Zhao, T. (2012). Effect of the forcing term in the multiple-relaxation-time lattice Boltzmann equation on the shear stress or the strain rate tensor. Physical Review E, 86(1), 1–11. Force term for MRT is $$\bar{F} = M^-1 (I-0.5 S) M F'$$ and $$F'_i = w_i( (\vec{e}_i-\vec{u}*)/cs2 + (\vec{e}_i \cdot \vec{u}*)\vec{e}_i/cs4) \cdot \vec{F}$$

Update state with source variable "force" for MRT collision model. Force term used here is from: Chai, Z., & Zhao, T. (2012). Effect of the forcing term in the multiple-relaxation-time lattice Boltzmann equation on the shear stress or the strain rate tensor. Physical Review E, 86(1), 1–11. Force term for MRT is $$\bar{F} = M^-1 (I-0.5 S) M F'$$ and $$F'_i = w_i( (\vec{e}_i-\vec{u}*)/cs2 + (\vec{e}_i \cdot \vec{u}*)\vec{e}_i/cs4) \cdot \vec{F}$$

Update state with source variable "force" with 1st order integration of force in lattice Boltzmann equation. Simuilar to derive routine but it updates the state whereas derive is used for tracking Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for Seawater Desalination"

Update state with source variable "force" with thermodynamic factor Simuilar to derive routine but it updates the state whereas derive is used for tracking Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for Seawater Desalination"

Update state with source variable "force" with 2nd order integration of force in lattice Boltzmann equation. Simuilar to derive routine but it updates the state whereas derive is used for tracking Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for Seawater Desalination"

Update state with source variable "force" with 2nd order integration of force in lattice Boltzmann equation with thermodynamic factor. Simuilar to derive routine but it updates the state whereas derive is used for tracking Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for Seawater Desalination"

Update state with source variable "injection" Similar to derive routine but it updates the state whereas derive is used for tracking

Update state with source variable "ps_sourceCoeff".

Update state with source variable "turb_channel_force" for BGK.

Update state with source variable "force" for generic MRT collision model for turb_channel_force. It uses velocityX average in bulk to adapt the driving force for turbulent channel.

Update state with source variable "force" for d3q19 MRT collision model for turb_channel_force. It uses velocityX average in bulk to adapt the driving force for turbulent channel.

Update state with source variable "force" for d3q19 MRT collision model for turb_channel_force. It uses velocityX average in bulk to adapt the driving force for turbulent channel.

Update state with source variable "force" for generic MRT collision model for turb_channel_force. It uses velocityX average in bulk to adapt the driving force for turbulent channel.

ApplyVelocityBounceback adds the momentum exchange term to the distribution function at the particle neighboring fluid nodes this term accounts for the moving boundary of the particle.

Set up interpolation routines for fluid (weakly compressible) scheme

Set up interpolation routines for fluid (weakly compressible) scheme and turbulence active

This routine assigns the BC lists Run over all the elements with the property boundary and check each direction. Assign all common boundaries to the level-wise representation 3rd step in build_BCLists

Boundary condition for APESMATE that supports pdfs as input variable Makes it possible to use pdf from, for example, the left to the right domain

Advection relaxation routine for the D3Q19 model with BGK based on the !! equilibrium distribution function for the generalized Navier Stokes equations (GNS) aka Volume Averaged Navier-Stokes !! equations (VANS). feq definition from: Z. Guo and T. S. Zhao, “Lattice Boltzmann model for incompressible flows through porous media,” Phys. Rev. E, vol. 66, no. 3, p. 036304, Sep. 2002, doi: 10.1103/PhysRevE.66.036304.

Optimized Advection relaxation routine for the MSGas BGK model for d3q19 layout with three species.

Optimized Advection relaxation routine for the MSLiquid BGK model for d3q19 layout with three species.

Semi-optimized Advection relaxation routine for the MSLiquid BGK model for d3q19 layout with three species with thermodynamic factor.

Advection relaxation routine for the D3Q19 model with BGK for the isothermal acoustic equation.

Unoptimized Advection relaxation routine for the multispecies BGK model for testing

Unoptimized Advection relaxation routine for the multispecies BGK model

Unoptimized Advection relaxation routine for the multispecies BGK model with thermodynamic factors in Maxwell-Stefan formulation

Recursive Regularized relaxation routine for the D3Q19 This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer. works for both d3q19 and d3q27

Recursive Regularized relaxation routine for the D3Q27 This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer.

Unoptimized Advection relaxation routine for the multispecies BGK model with external forcing term

Hybrid recursive regularization relaxation routine for the BGK model. based on: Feng et al., JCP 2019, "Hybrid recursive regularized thermal lattice Boltzmann model for high subsonic compressible flows"

Projected Recursive Regularized relaxation routine for the D3Q19 This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer. works for both d3q19 and d3q27

Projected Recursive Regularized relaxation routine for the D3Q19 This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer. works for both d3q19 and d3q27

Hybrid recursive regularization relaxation routine for the BGK model. based on: Feng et al., JCP 2019, "Hybrid recursive regularized thermal lattice Boltzmann model for high subsonic compressible flows"

Projected Recursive Regularized relaxation routine for the D3Q19 This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer. works for both d3q19 and d3q27

Projected Recursive Regularized relaxation routine for the D3Q19 This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer. works for both d3q19 and d3q27

Projected Recursive Regularized relaxation routine for the D3Q19 This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer. works for both d3q19 and d3q27

Projected Recursive Regularized relaxation routine for the D3Q27 This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer.

Recursive Regularized relaxation routine for the D3Q19 This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer. works for both d3q19 and d3q27

Recursive Regularized relaxation routine for the D3Q27 This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer.

Regularized relaxation routine for the D3Q19 and 27 model with BGK. This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer. works for both d3q19 and d3q27

Regularized relaxation routine for the D3Q19 and 27 model with BGK. This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer. works for both d3q19 and d3q27

Assemble the level-wise list of elements which adhere to the boundary conditions.

Calculate the MLUPS or MFLUPS for the simulation

This routine calculates Maxwell-Stefan diffusivity coeffcient Matrix for given mole_frac of all species

This routine calculates Maxwell-Stefan diffusivity coeffcient Matrix for given mole_frac of all species

This routine calculates thermodynamic factor for given mole_frac of all species

This routine returns mass density of all species and mass averaged mixture velocity from given pdf of all species for single element. It is used in Nonequilbrium extrapolation based boundary conditions.

wrap_periodic checks whether a distance r from x_particle to

calcPeriodicRsurface is used to calculate the vector from the particle origin to a point on the surface in presence of periodic boundaries. Usage: first calculate the distance from the particle origin to a surface element using r = baryOfSurface - x_origin. If the particle is close to a periodic boundary this vector may not be correct. In that case a call to calcPeriodicRsurface modifies the vector r to take into account the periodicity. This is done by checking if the magnitude of r is less than the particle radius R_particle (which can be modified with some tolerance if needed). This routine is used for fully resolved (MEM) particles only.

This routine computes bndForce on boundary elements using momentum exchange method.

Calculate global and sum of levels numbers of elements

calcVelocityAndPressureGradient calculates the gradient of pressure and curl of the velocity field (in lattice units) at coordinate coord Coord must be a local element on this process!

calcVelocityAndPressureGradient calculates the gradient of pressure and curl of the velocity field (in lattice units) at coordinate coord Coord must be a local element on this process!

calcVelocityAndPressureGradient calculates the gradient of pressure and curl of the velocity field (in lattice units) at coordinate coord Coord must be a local element on this process!

Calculation stream-wise velocity compononent from wall function and friction velocity, stream-wise unit vector and turbulent viscosity with mixing length formulation.

Calculate kinematic viscosity from nonNewtonian Casson model. $\mu = (k0 + k1 * sqrt(shearRate))^2/shearRate$

Calculate kinematic viscosity from nonNewtonian Carreau-Yasuda model. $\mu = \mu_\inf + (\mu_0-\mu_\inf)(1+(\lambdashearRate)a)^((n-1)/a)$

Calculate kinematic viscosity from nonNewtonian Casson model for incompressible model. $\mu = (k0 + k1 * sqrt(shearRate))^2/shearRate$

Calculate kinematic viscosity from nonNewtonian Carreau-Yasuda model for incompressible model. $\mu = \mu_\inf + (\mu_0-\mu_\inf)(1+(\lambdashearRate)a)^((n-1)/a)$

Calculate kinematic viscosity from nonNewtonian power-law model for incompressible model $\mu = K shearRate^(n-1)$

Calculate kinematic viscosity from nonNewtonian power-law model. $\mu = K shearRate^(n-1)$. Shear rate is computed from strain rate which is computed from nonEquilibrium PDF which in turn computed from pre-collision PDF

No comment yet!

Calculating central moment. This follows equations 21 in cumulent paper ( Geier .et al 2015 )

Calculating central moment by spliting among directions. This follows equations 43, 44, 45 in cumulent paper (Geier .et al 2015) We first do x direction for better performance.

Routine that checks if new particles should be created and creates them if so.

Routine that checks if new particles should be created and creates them if so.

Check prerequisite for some boundary conditions

Check the total density for a selected scheme and write to unit

This routine performs several tasks: geometry increment, time updating, tracking, density checking, restart

Unoptimized explicit implementation

Unoptimized explicit implementation

Check the total potential for poisson scheme

It count valid (non-solid) elements in BC elements list. Input: minLevel, maxLevel LevelPointer LevelDesc nElems - number of BC elements elems - positions of BC elements in tree or levelPointer Output: nValid - number of valid BC elements posInBCElem - positions of valid elements in BC elements list

Check for the streaming layout.

This function runs over all variable loaded from restart file check if variables loaded are pdf variable or derive variable

Check the maximum velocity whether it is above Ma>0.1

Check the maximum velocity whether it is above Ma>0.1

checkAndCollideDEM checks if two particles A and B collide This is the case if the continuous representations overlap If there is a collision, a collision force is applied to each particle

checkAndCollideDEM checks if two particles A and B collide This is the case if the continuous representations overlap If there is a collision, a collision force is applied to each particle checkAndCollideDEM checks if two particles A and B collide This is the case if the continuous representations overlap If there is a collision, a collision force is applied to each particle

handleParticleOverlap checks for overlap with discrete representations of other particles. Returns overlapsOtherParticle = TRUE if there is overlap. This does not require communication with other processes.

Initialize the communication buffers for a single level

This routine compute bulk viscosity omega for species for all levels omega_bulk = (2-molWeigRatio_k)/(3*bulk_visc)

compute_fluid_momentum calculates the total momentum of the fluid for all fluid elements in the global domain. The result "totalMomentum" is returned in physical units.

This routine computes friction velocity from wall model profile using Newton iteration method

This routine computes the molecular weight ratio for all species based asinari model

This routine computes weights for weighted_average interpolation.

computeDistance computes the shortest distance between points x1 and x2 In doing so it takes possible periodic boundaries into account.

DEM_computeExternalForces adds the non-DEM forces (including hydrodynamic force from the LBM) to F_DEM which is used to update velocity within the DEM subcycle.

This routines computes streamWise velocity component from friction velocity and distance to boundary using any wall function profile.

computeWallForce_1D computes the 1D DEM force between a particle at position xp with velocity un to a wall at position xwall.

Routine for computing the collision force between particles and walls for the case of a simple prismatic domain with walls aligned with the Cartesian axes.

computeWallPosSum computes the sum of the locations of wall boundaries in the area surrounding the particle. It also sets rmflag to true if an open boundary is detected, indicating that this particle should be removed from the global domain (in a different routine)

computeWallPosSum computes the sum of the locations of wall boundaries in the area surrounding the particle. It also sets rmflag to true if an open boundary is detected, indicating that this particle should be removed from the global domain (in a different routine)

Conversion factor betwen the pre- and post-collision quantity for the shear stress.

Checks if integer coordinate is in the total list of this rank

Routine which checks whether integer coordinate is local on the current rank

Identify the number of boundary condition elements of each BC type and number of elements with multiple BC types. This is 1st step in Build_BClists

Routine to create new unresolved DPS particles

Routine to create new fully resolved MEM particles

Routine to create a new particle using the information in the particleCreator object

Routine to create a new particle using the information in the particleCreator object

computes cross-product a x b = res

************80

No comment yet!

Cumulant kernel based on Geier2017 and optimized. Just omega(2) is given in input. omega(2)=-1 means omega2=omegaBulk. Limiters read from input. lim(N)=10^10 means unlimited. lim(N) is for omega(N+2). Just omega(3:5) are limited as in the paper. omega(6:10) = 1._rk

Cumulant based on Geier2017 paper. With all modifications and limiters. All omegas are given in input. When omega(N) = -1 means adjusted in this routine. omega(2)=-1 means omega2=omegaBulk. Limiters read from input. lim(N)=10^10 means unlimited. lim(N) is for omega(N+2). Just omega(3:5) are limited as in the paper.

Checking the stability regions of omegas for the parametrized Cumulant Just omega(2) is given in input. omega(2)=-1 means omega2=omegaBulk. Limiters read from input. lim(N)=10^10 means unlimited. lim(N) is for omega(N+2). Just omega(3:5) are limited as in the paper. omega(6:10) = 1._rk

Detailed Debug output to the PDF neighbor (connectivity) list

check the dependencies from Finer

Interpolation routine that is based on a simple weighted average of source nodes. This is the interpolation coarse-> fine. Weights are needed here, as the distances source <-> target are different for the source nodes.

Debug the dependencies for the ghostFromFiner elements

Dump the neighbors found for the boundaries with neighbor elements

DEM_computeExternalForces adds the non-DEM forces (including hydrodynamic force from the LBM) to F_DEM which is used to update velocity within the DEM subcycle.

DEM_computeExternalForces adds the non-DEM forces (including hydrodynamic force from the LBM) to F_DEM which is used to update velocity within the DEM subcycle.

Compute collision forces using Discrete Element Method between particles local to this process i.e. both particles are owned by this process.

Compute collision forces using Discrete Element Method between particles local to this process i.e. both particles are owned by this process.

Compute collision forces using Discrete Element Method between particle pairs where particles belong to different processes.

Compute collision forces using Discrete Element Method between particle pairs where particles belong to different processes.

DEM_computeWallForces_DPS computes the forces on particles as a result of collisions with walls described in the boundaryData object. These forces are only computed for particles owned by this process.

DEM_exchangeForces sends DEM collision force contributions from collisions that cannot be resolved by the receiving process. The send force buffers in this case must already be filled in the DEM collision-handling routines!

DEM_exchangeForces sends DEM collision force contributions from collisions that cannot be resolved by the receiving process. The send force buffers in this case must already be filled in the DEM collision-handling routines!

DEM_exchangeWallPositions sends wall position sums close to a particle as detected on each process to the particle owner, which averages the results to get one average wall position Upon termination of this routine particle%rwall for all particles which I own should be set correctly.

DEM_exchangeWallPositions sends wall position sums close to a particle as detected on each process to the particle owner, which averages the results to get one average wall position Upon termination of this routine particle%rwall for all particles which I own should be set correctly.

Reset the force at the next time step to 0

Reset the force at the next time step to 0

Swap the indices of Fnow and Fnext pointing to the force at the current and next time step respectively

Swap the indices of Fnow and Fnext pointing to the force at the current and next time step respectively

DEMsubcycles runs Nsubcycles time integration steps per LBM time step In this routine velocity verlet integration of particle position and velocity is used.

DEMsubcycles runs Nsubcycles time integration steps per LBM time step In this routine velocity verlet integration of particle position and velocity is used. This routine is for one-way coupled DPS particles.

DEMsubcycles runs Nsubcycles time integration steps per LBM time step In this routine simple Forward Euler integration of particle position and velocity is used.

Calculate the density of a given set of elements (sum up all links).

Calculate the equlibrium of given elements with the given input state array.

Initiates the calculation of equilibrium. This routine sets the function Pointer for equilibrium calcualtion and calls the generice get Value of Index routine

Derive absorb layer variable defined as a source term.

Derive absorb layer variable defined as a source term.

Derive the Brinkman force variable defined as a source term.

Derive Brinkman force variable defined as a source term with TRT operator. It evaluates spacetime function defined in lua file for Brinkman coefficient variable and multiplies it with negative velocity to obtain the force term. This force term is then converted to state value which is to be added to the state with respect to TRT operator. Reference: 1) Zhaoli Guo and T. S. Zhao. “Lattice Boltzmann Model for Incompressible Flows through Porous Media”. In: Physical Review E 66.3 (2002), p. 036304. doi: 10.1103/PhysRevE.66.036304. 2) Irina Ginzburg. “Consistent lattice Boltzmann schemes for the Brinkman model of porous flow and infinite Chapman-Enskog expansion”. In: Phys. Rev. E 77 (6 June 2008), p. 066704. doi: 10.1103/PhysRevE.77.066704.

Derive injection variable defined as a source term for lbm passive scalar. It evaluates spacetime function defined in lua file for injection variable and convert it to state value which is to be added to the state

Derive external force variable defined as a source term. It evaluates spacetime function defined in lua file for force variable and convert it to state value which is to be added to the state

Derive external force variable defined as a source term. It evaluates spacetime function defined in lua file for force variable and convert it to state value which is to be added to the state

Derive external force variable defined as a source term. It evaluates spacetime function defined in lua file for force variable and convert it to state value which is to be added to the state

Derive external force variable defined as a source term. It evaluates spacetime function defined in lua file for force variable and convert it to state value which is to be added to the state

Derive external force variable defined as a source term. It evaluates spacetime function defined in lua file for force variable and convert it to state value which is to be added to the state

Derive injection variable defined as a source term for lbm passive scalar. It evaluates spacetime function defined in lua file for injection variable and convert it to state value which is to be added to the state

Derive external source variable defined as a source term.

This routine computes auxField from state array

This routine computes auxField 'density and velocity' of given field from state array. velocity of original PDF is computed in this routine by solving LSE

This routine computes auxField 'density and velocity' of given field from state array. velocity of original PDF is computed in this routine by solving LSE.

This routine computes auxField 'density and velocity' of given field from state array with thermodynamic factot. velocity of original PDF is computed in this routine by solving LSE.

subroutine to add derive variables for weakly compressible PB (schemekind = 'nernstPlanck') to the varsys. A Coupled Lattice Boltzmann Method to Solve Nernst-Planck Model for Simulating Electro-Osmotic flows author> Xuguang yang This routine computes auxField 'mole_density' from state array

This routine computes auxField 'potential' from state array

This routine computes auxField from state array

Calculate the force on the boundary of a given set of elements

Calculate the moment on the boundary of a given set of elements

Calculate charge density of a given element for mixture. Charge density is mixture quantity to it returns same value for all species charge_density = Faraday * \sum_i z_i*density_i/molecularWeight_i

Calculate charge density from species concentration

Calculate charge density from potential field using Boltzmann approximation

Calculate charge density from potential field using Boltzmann approximation from given index

Calculate the charge density of a given set of elements

Calculate the charge density of a given idx

Current density is computed from species momentum stored in auxField array. Current density, J = charge_density*velocity = \rho_e * u = \sum_k z_k F p_k / M_k where p_k is the species momentum

Calculate current density from species momentum

Calculate the current density of a given set of elements

Calculate the current density of a given idx (sum up all links).

Initiates the calculation of density This routine sets the function Pointer for density calcualtion and calls the generice get Element from PDF routine

Initiates the calculation of density. This routine sets the function Pointer for density calcualtion and calls the generice get Value of Index routine

Calculate the density of a given set of elements (sum up all links).

Calculate the density of a given idx (sum up all links).

Calculate the electric_field of a given set of elements

Calculate the electrical field of a given idx

Calculate the electric field of a given set of elements (sum up all links). This routine is used to compute electric field for all scheme kinds

Calculate the electric field of a given set of elements (sum up all links). This routine is used to compute electric field for all scheme kinds

This routine computes velocity from state array

This routine computes equil from state array

This routine computes equilibrium from state array

This routine computes equilibrium from state array

Initiates the calculation of equlibrium This routine sets the function Pointer for equlibrium calcualtion and calls the generice get Element from PDF routine

This routine computes equilbrium from auxField

Initiates the calculation of equilibrium. This routine sets the function Pointer for equilibrium calcualtion and calls the generice get Value of Index routine

This routine computes equilbrium from density and velocity This must comply with interface in mus_variable_module derive_FromMacro

This routine computes equilbrium from density and velocity This must comply with interface in mus_variable_module derive_FromMacro

This routine computes equilbrium from auxField

Calculate the equlibrium of a given element number with the given input state vector.

This routine computes equilbrium from auxField

This routine computes equilbrium from density and velocity This must comply with mus_variable_module%derive_FromMacro

Equilibrium from density and momentum stored in auxField

This routine computes equilbrium from auxField

This routine computes equilbrium from density and velocity This must comply with mus_variable_module%derive_FromMacro

This routine computes equilbrium from auxField

This routine computes equilbrium from auxField

This routine computes 2nd order equilbrium from density and velocity This must comply with mus_variable_module%derive_FromMacro

This routine computes equilbrium from auxField

This routine computes equilbrium from density and velocity This must comply with mus_variable_module%derive_FromMacro

Equilibrium velocity from state Calculate the momentum of a given element for single species or mixture from the cptr scheme state vector for gas mixture (Asinari model). Need to solve the system of equations to compute this momentum since first order moments gives only moments of transformed pdfs. Hence to obtain the first order moments of actual pdfs we need to solve system of equation of size = nSpecies for each velocity components

Equilibrium velocity from density and momentum in auxField.

Equilibrium velocity from density and momentum in auxField with thermodynamic factor

Equilibrium from density and momentum in auxField with thermodynamic factor

Compute and convert following variable force into physical units

Calculate the bnd_force of a given idx

Calculate kinetic energy from density and velocity in auxField This routine sets the function Pointer for kinetic energy calcualtion and calls the generice get Element from PDF routine

Calculates Kinetic energy from density and velocity for given set of points.

Initiates the calculation of kinetic_energy. This routine sets the function Pointer for kinetic_energy calcualtion and calls the generice get Value of Index routine

Calculate the kinetic energy in physical units The interface has to comply to the abstract interface tem_varSys_proc_element.

Calculate the kinetic energy of a given idx

Calculate mixture kinematic pressure. This routine requires initial total mole density which is defined in mixture table. Formula to compute kinematic pressure $p = c^2_s (\sum_k \rho_k \phi_k - min_l (m_l) n_0)/\rho_0$ here, $\rho_k$ - species density, \ $\phi_k$ - species molecular weight ratio, \ $n_0$ - reference mixture number density,\ $\rho_0$ - reference density. In tracking,

Calculate the kinematic mixture pressure in physical of a given set of elements (sum up all links).

Calculate the kinematic pressure of a given idx

Calculate the mach number of a given set of elements (sum up all links).

Calculates Mach nr for given set of points.

Initiates the calculation of mach number. This routine sets the function Pointer for pressure calcualtion and calls the generice get Value of Index routine

mass fraction from density stored in auxField

Calculate mixture velocity of a given element from the momentum and density stored in auxField array for liquid mixture. auxField was updated with momentum of untransformed PDF which was computed by solving LSE in compute kernel.

Calculate mixture velocity from density from species momentum

Calculate the potential of a given set of elements (sum up all links). This routine is used to compute potential for all scheme kinds

Calculate the potential of a given set of elements (sum up all links). This routine is used to compute potential for all scheme kinds

Calculate the number density of a given element for single species from the density stored in auxField array. Mixture number density is computed by summing species number density using tem_evalAdd_forElement Number density = density/molecular weight mixture number density = sum(number_density)

Calculate mole density from species concentration for getValOfIndex

Calculate the density of a given set of elements (sum up all links).

Calculate the mole density of a given idx

Compute mole flux from momentum stored in auxField. mole flux = numDens_i*velocity_i = momentum / molWeight

Calculate mole flux from species momentum for getValOfIndex

Calculate the density of a given set of elements (sum up all links).

Calculate the mole flux of a given idx

mole fraction from density stored in auxField

Initiates the calculation of moment for 2D This routine sets the function Pointer for moment for 2D calcualtion and calls the generice get Element from PDF routine

This routine computes momentum from state array

This routine computes momentum of all species from state array

Compute and convert following variable moment into physical units

Calculate the bnd_moment of a given idx

Calculate momentum from density and velocity stored in auxField

Calculates momentum from density and velocity for given set of points.

Calculate Momentum from density and velocity in auxField.

Calculate the momentum of a given element number with the given input vector (sum up all values)

Calculate the momentum of a given idx

This routine computes momentum from state array

This routine computes momentum from state array

Initiates the calculation of NonEquil This routine sets the function Pointer for NonEquil calcualtion and calls the generice get Element from PDF routine

Initiates the calculation of non_equilibrium. This routine sets the function Pointer for non_equilibrium calcualtion and calls the generice get Value of Index routine

Calculate the momentum of a given element number with the given input vector (sum up all values)

Calculate the momentum of a given idx

Calculate the potential of a given set of elements

Calculate the potential of a given idx

Calculate the pressure of a given set of elements (sum up all links).

Calculates pressure for given set of points.

Initiates the calculation of pressure. This routine sets the function Pointer for pressure calcualtion and calls the generice get Value of Index routine

Calculate species pressure both for gas and liquid model In case of gas mixture, it is partial pressure where as in liquid mixture this is not valid. However, it is used to compute mixture pressure and then the kinematic_pressure from the mixture pressure. Formula to calculate pressure: $p_k = c^2_s ( \rho_k \phi_k )$ here, $\rho_k$ - species density, \ $\phi_k$ - species molecular weight ratio, \

Compute and convert following variable pressure/shear_stress/wss/shear_mag into physical units

Calculate the pressure of a given idx

Convert lattice q-criterion to physical unit i.e strainRate**2

This routine computes density from state array

Calculate the shear stress magnitude of a given element number with the given

Calculate the shear rate

Calculate the deviatoric shear stress for Newtonian fluid (exclude pressure) (no mixtures).\n Shear Stress depends on variable: nonEquilibirium

Calculate charge density source variable referred in config file

Initiates the calculation of StrainRate This routine sets the function Pointer for StrainRate calcualtion and calls the generice get Element from PDF routine

Initiates the calculation of kinetic_energy. This routine sets the function Pointer for kinetic_energy calcualtion and calls the generice get Value of Index routine

Calculate the strain rate (or called rate of strain)

Calculate the strain rate of a given idx

Calculate the temperature of a given set of elements (sum up all links).

Calculate the velocity magnitude of a given element number with the given input vector (sum up all values)

Calculate the temperature of a given idx

This routine computes velocity from pre collision state array using Fetch

This routine computes velocity from state array

This routine computes velocity from state array

This routine computes velocity from state array

This routine computes velocity from state array

This routine computes velocities of all species from state array

This routine computes velocity from state array

Calculate the velocity of a given element for single species. from the momentum and density stored in auxField array for liquid mixture. auxField was updated with momentum of untransformed PDF which was computed by solving LSE in compute kernel.

Calculate velocity from species density and momentum in auxField for getValOfIndex

Calculate the velocity of a given element number with the given input vector (sum up all values)

Calculate the velocity of a given idx

Convert lattice viscosity to physical viscosity

Calculate the wall shear stress (WSS) of a given element with the given input

Calculate the pressure of a given set of elements (sum up all links).

Initiates the calculation of velocity This routine sets the function Pointer for velocity calcualtion and calls the generice get Element from PDF routine

destroyParticle_MEM removes a particle from the lattice and the particleGroup It will * empty the exclusionList * initialize all the former particle elements to new fluid elements * restore connectivity for all these new fluid elements This routine should be followed up by a call to remove_particle_from_da_particle_MEM!

Distribute the volume of a particle to update the fluid volume fraction field

Control routine for an optimized workflow with reduced functionality.

This routine utilizes fluid elements on my level (L) to fill finer ghost elements on next level (L+1). Then it exchanges the datas of finer ghost elements (L+1) between process.

This routine does: 1. interpolate my coarse ghost element (iLevel) from finer level (iLevel+1) 2. exchange the data of my coarse ghost elements between process

Fill GhostFromFiner elements on my level with debug value

No comment yet!

Fill GhostFromFiner elements on my level with debug value

Main control routine: Update the time step for all levels. Main steps: * if iLevel < maxLevel do recursive at iLevel+1 * do BC at iLevel * do auxField calculation at iLevel * do compute kernel at iLevel * do apply source at iLevel * do do_IntpFinerAndExchange at iLevel if iLevel < maxLevel * intp My Coarser ghost (iLevel) from Finer (iLevel+1) * do exchange bufferFromFiner at iLevel * exchange buffer at iLevel * exchange bufferFromCoarser at iLevel if iLevel > minLevel * do do_intpCoarserAndExchange at iLevel if iLevel < maxLevel * intp Finer Ghost (iLevel+1) from my coarser (iLevel) * exchange bufferFromCoarser at iLevel+1

This routine dump compute and BC timing for all ranks rank nFluids tCompute nBCElems tBC tCPU tMainLoop

Dump pdf values into debug files

dump dependencies for one element

check the dependencies from Coarser

check the dependencies from Coarser

check the dependencies from Finer and write them out so we can compare

check the dependencies from Finer

check the dependencies from Finer and write them out so we can compare

Routine to dump particle timing data

Performance results (MLUPs) are written to a file for statistical review The file-format is simple can be evaluated with gnuplot

Debugging routine to dump debug tracking data

write all pdf entries of a all elements of the pdf array for a given level to the debug unit

derive equilibrium from macro

derive equilibrium from macro

Equlibrium velocity from macro

Equlibrium velocity from macro with thermodynamic factor

exchangeForces send force contributions from each process on which a particle exists to the particle owner. The total hydrodynamic force is then computed by the particle owner as the sum of all the force contributions (which physically are the surface forces from the part of the particle surface handled by each process). The owner then updates particle velocity in a subsequent call to a different routine. For momentum-exchange method only!

exchangeHydroForces_DPS exchanges particles hydrodynamic forces after they have been updated by the particle owner. Each process sends force updates for particles they own and receives updates for particles which they do not own, but that do exist in their particleGroup.

exchangeMomInc_DPS send the accumulated momentum transfer FROM particles TO fluid from a particle's previous owner to its new owner.

exchangeNewParticles sends all the data needed to initialize a particle on a process. This is needed when a particle travels from one process to another. The data is used to add the particle to the receiving process particleGroup. This only creates a continuous representation of the particle on the receiving process. A subsequent call to a different routine then maps this to the discrete representation in the form of elements in the exclusionList.

exchangeNewParticles sends all the data needed to initialize a particle on a process. This is needed when a particle travels from one process to another. The data is used to add the particle to the receiving process particleGroup. This only creates a continuous representation of the particle on the receiving process. A subsequent call to a different routine then maps this to the discrete representation in the form of elements in the exclusionList.

exchangeParticleStates is used to exchange particle (continuous) position and velocity as well as the integer coordOfOrigin. This is necessary for (for example) the collision handling routines

If a particle is removed from the global domain (e.g. after colliding with an open boundary) then exchangeParticlesToRemove will send messages informing all other processes that this particle should be removed.

If a particle is removed from the global domain (e.g. after colliding with an open boundary) then exchangeParticlesToRemove will send messages informing all other processes that this particle should be removed.

exchangePositions exchanges particles continuous positions after they have been updated by the particle owner. Each process sends position updates for particles they own and receives updates for particles which they do not own, but that do exist in their particleGroup.

exchangePositions exchanges particles continuous positions after they have been updated by the particle owner. Each process sends position updates for particles they own and receives updates for particles which they do not own, but that do exist in their particleGroup.

exchangeVelocities exchanges particles continuous velocities after they have been updated by the particle owner. Each process sends velocity updates for particles they own and receives updates for particles which they do not own, but that do exist in their particleGroup.

exchangeVelocities exchanges particles continuous velocities after they have been updated by the particle owner. Each process sends velocity updates for particles they own and receives updates for particles which they do not own, but that do exist in their particleGroup.

Transfer pdf of boundary elements into bcBuffer which is used by all boundary routines.

Routine which fills the bins in mus_particle_blob_prob_type

Routine to initialize particle creator object with random positions inside a cylinder described by blob_cylinder type

Routine to initialize particle creator object with random positions inside a prism described by blob_prism type

Fill_cylinder fills the dynamic array positions with coordinates of particles spaced a distance d apart inside a cylinder with faces z = 0 and z = L and radius R. For cylinders of different position and orientation, these coordinates can be transformed.

Transfer pre- and post-collision PDF of neighbors of boundary elements into neighBufferPre and neighBufferPost. Access to state array

Interpolate auxiliary field from coarse source to fine target

Interpolate auxiliary field from coarse source to fine target

Interpolate auxiliary field from coarse source to fine target

Interpolate auxiliary field from coarse source to fine target

Interpolate auxiliary field from coarse source to fine target

Interpolate auxiliary field from fine source to coarse target

Fill fine ghost from coarse fluid by linear interpolation for D2Q9 stencil. 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate moments (den, vel, tau) (10 moments for 3D and 6 moments for 2D) 3. calculate fEq and use it to calculate high order moments 4. convert moments to PDF This routine is used by acoustic linear interpolation.

Fill fine ghost from coarse fluid by linear interpolation for D2Q9 stencil. 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate moments (den, vel, tau) (10 moments for 3D and 6 moments for 2D) 3. calculate fEq and use it to calculate high order moments 4. convert moments to PDF This routine is used by acoustic linear interpolation.

Fill fine ghost from coarse fluid by linear interpolation for D2Q9 stencil. 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate moments (den, vel, tau) (10 moments for 3D and 6 moments for 2D) 3. calculate fEq and use it to calculate high order moments 4. convert moments to PDF This routine is used by acoustic linear interpolation.

Fill fine ghost from coarse fluid by quadratic interpolation for D2Q9 stencil. 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate moments (den, vel, tau) (10 moments for 3D and 6 moments for 2D) 3. calculate fEq and use it to calculate high order moments 4. convert moments to PDF This routine is used by acoustic quadratic interpolation.

Fill fine ghost from coarse fluid by quadratic interpolation for D2Q9 stencil. 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate moments (den, vel, tau) (10 moments for 3D and 6 moments for 2D) 3. calculate fEq and use it to calculate high order moments 4. convert moments to PDF This routine is used by acoustic quadratic interpolation.

Fill fine ghost from coarse fluid by quadratic interpolation for D2Q9 stencil. 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate moments (den, vel, tau) (10 moments for 3D and 6 moments for 2D) 3. calculate fEq and use it to calculate high order moments 4. convert moments to PDF This routine is used by acoustic quadratic interpolation.

Linear interpolation of ghostFromFiner 1. Calculate Equilibrium and nonEquilibrium 2. Compute scaling factor 3. calculate target: Eq + Scale * nonEquilibrium

Linear interpolation of ghostFromFiner 1. Calculate Equilibrium and nonEquilibrium 2. Compute scaling factor 3. calculate target: Eq + Scale * nonEquilibrium

Linear interpolation of ghostFromFiner 1. Calculate Equilibrium and nonEquilibrium 2. Compute scaling factor 3. calculate target: Eq + Scale * nonEquilibrium

Recursively fill all the helper elements (i.e. ghost, halo) with valid information from the fluid elements.

Recursively fill all the helper elements (i.e. ghost, halo) with valid information from the fluid elements.

Fill coarse target ghost from fine source fluid by average interpolation. 1. Calculate Equilibrium and nonEquilibrium 2. Compute scaling factor 3. calculate target: Eq + Scale * nonEquilibrium

Average interpolation of ghostFromFiner The interpolation procedure used in this routine is:\n 1. Calculate Equilibrium and nonEquilibrium 2. Compute scaling factor 3. calculate target: Eq + Scale * nonEquilibrium

Average interpolation of ghostFromFiner The interpolation procedure used in this routine is:\n 1. Calculate Equilibrium and nonEquilibrium 2. Compute scaling factor 3. calculate target: Eq + Scale * nonEquilibrium

find_particle_comm_procs generates a list of all processes we may need to communicate particle data with over the duration of the simulation. We only need to communicate this data for particles on our rank which also exist on other processes. This means we will never communicate with processes whose domains are not within one particle diameter of our domain. This is the key assumption used to generate the list of procs Hence the padding distance dpad should be set to the largest particle diameter in the simulation

Find maximum possible interpolation order which can be used for fillFinerFromMe by comparing nFoundSources with nMaxSources of different interpolation order starting from interpolation order defined by user

find particle index and ID in particleGroup array

Routine to find the process a certain treeID is on. Looks in the ranks in the array of argument procs Returns the INDEX of the found proc in this array Example: procs = [4 8 7] and we find our treeID on rank 8 will return procIndex = 2

This routine computes friction velocity from wall model profile using fixed-point iterative method

followNeighPath can be used to determine the position of a neighboring lattice site in the total list. For this we follow one or more entries of the levelDesc%neigh array. Since this array is only defined for local fluid elements, startPos must point to a local fluid element.

This routine computes friction velocity from Schmitt wall model.

Debugging routine to create a list of elements along a line so that the properties of these elements can be printed

function to get the derivative of uPlus with respect to uTau

function to get the derivative of uPlus with respect to uTau

function to get the derivative of uPlus with respect to uTau

function pointer to get kineticEnergy from vel and density for any stencil

function pointer to get kineticEnergy from vel and density for any stencil

Calculate the moment of a centain order The moment of a distribution $f_i$ is defined as:\n $$m_{x^{p}y^{q}z^{r}} = \sum_{i}^{Q} c^{p}_{xi} c^{q}_{yi} c^{r}_{zi} f_i$$ The fucntion argument expX is array of size 3, which contains the values of \f$p, q, r\f$

function pointer to get momentum from vel and density for any stencil

function pointer to get momentum from vel and density for any stencil

get the moment vector to calculate the moment from the pdf

function pointer to get pdf equilibrium from vel and density along a

function pointer to get pdf equilibrium from vel and density along a

This function computes the equilibrium pdf from velocity

This function computes the equilibrium pdf from velocity

This function computes the equilibrium pdf from velocity

This function computes the incompressible equilibrium pdf from velocity

This function computes the incompressible equilibrium pdf from velocity

This function computes the incompressible equilibrium pdf from velocity

function pointer to get pdf equilibrium from vel and density along a

function pointer to get pdf equilibrium from vel and density along a

function pointer to get kineticEnergy from vel and density for any stencil

function pointer to get kineticEnergy from vel and density for any stencil

This function computes the sigma vector necessary to get the

This function computes the sigma vector necessary to get the

This function computes the sigma vector necessary to get the

function to get uPlus

function to get uPlus

function to get uPlus

function pointer to get pdf equilibrium from vel and density for any stencil

function pointer to get pdf equilibrium from vel and density for any stencil

function pointer to get pdf equilibrium from vel and density for d2q9 stencil

function pointer to get pdf equilibrium from vel and density for d2q9 stencil

function pointer to get pdf equilibrium from vel and density for any stencil

function pointer to get pdf equilibrium from vel and density for any stencil

function pointer to get pdf equilibrium from vel and density for d3q19 stencil

function pointer to get pdf equilibrium from vel and density for d3q19 stencil

function pointer to get pdf equilibrium from vel and density for any stencil

function pointer to get pdf equilibrium from vel and density for any stencil

function pointer to get pdf equilibrium from vel and density for d3q27 stencil

function pointer to get pdf equilibrium from vel and density for d3q27 stencil

function pointer to get pdf equilibrium from vel and density for any stencil

function pointer to get pdf equilibrium from vel and density for any stencil

function pointer to get pdf equilibrium from vel and density for any stencil

function pointer to get pdf equilibrium from vel and density for any stencil

Convenience function to get barycenter of integer coordinate

Get the conversion factor variable from physics table from a given solver specific character handle.

Calculate the density of a given element number with the given state vector (sum up all values)

Calculate the density of a given subset of pdfs vector (sum up all values)

Calculate the equilibrium distribution function in all directions

Calculate the equilibrium distribution function in all directions

Calculate the equilibrium distribution function in all directions

Calculate the equilibrium distribution function in all directions This is the incompressible formulation with reference density rho0

Get the right field prefixes from a given solver specific character handle.

Get the field variable name for given field type from a given solver specific character handle.

Get the field variable name for given field type from a given solver specific character handle.

This function computes gradient of rho * velocity^3 from gradient, density and veleocity data. Just derivatives u_x, v_y and w_z. Gradient is computed using central difference. if an element has an boundary then neighbor refers to current element then forward difference is used.

This function computes gradient of rho * velocity^3 from gradient, density and veleocity data. Just derivatives u_x, v_y and w_z. Gradient is computed using central difference. if an element has an boundary then neighbor refers to current element then forward difference is used.

This function computes gradient of rho * velocity^3 from gradient, density and veleocity data. Just derivatives u_x, v_y and w_z. Gradient is computed using central difference. if an element has an boundary then neighbor refers to current element then forward difference is used.

This function computes gradient of rho * velocity^3 from gradient, density and veleocity data. Just derivatives u_x, v_y and w_z. Gradient is computed using central difference. if an element has an boundary then neighbor refers to current element then forward difference is used.

This function computes gradient of velocity from gradient and veleocity data. Gradient is computed using central difference. if an element has an boundary then neighbor refers to current element then forward difference is used

This function computes gradient of velocity from gradient and veleocity data. Gradient is computed using central difference. if an element has an boundary then neighbor refers to current element then forward difference is used

This function computes gradient of velocity from gradient and veleocity data. Gradient is computed using central difference. if an element has an boundary then neighbor refers to current element then forward difference is used

This function computes gradient of velocity from gradient and veleocity data. Gradient is computed using central difference. if an element has an boundary then neighbor refers to current element then forward difference is used

This function computes gradient of velocity from gradient and veleocity data. Gradient is computed using central difference. if an element has an boundary then neighbor refers to current element then forward difference is used

This function computes gradient of velocity from gradient and veleocity data. Gradient is computed using central difference. if an element has an boundary then neighbor refers to current element then forward difference is used

This function computes Hermite polinomial. It gives in output minimum

This function computes Hermite polinomial. It gives in output minimum

Get a character from the identify table using a given solver specific character handle and a given key word.

Get the index in the total list of a specified integer coordinate

getInterpolationBnds is used to determine which cells to interpolate fluid quantities from for a particle positioned at its coordOfOrigin + r_lat. The 8 cells obtained are the cells whose barycenter forms the tightest bounding cube around the particle.

getNeighborCoord gets the coordinate of the element offset from input coord by (nx,ny,nz) while taking into account periodicity

Setting the non-equilibrium part based on the acoustic scaling

Calculate the non-equilibrium part of pdf from strain rate tensor based on the diffusive scaling

Routine to generate a unique particleID for a particle

Get the number of fields from a given solver specific character handle.

Calculate the conversion factor to convert nonEq moments between fine and coarser.

Calculate the conversion factor to convert nonEq pdfs from coarse to fine.

Calculate the conversion factor to convert nonEq pdfs from fine to coarse.

Routine to create a particle logunit based on particle ID

getPathToVec builds a series of 3 indices which can be followed using the levelDesc(lev)%neigh array to get the position of a neighboring element in the total list. Usage: given an element at coordinate [0,0,0] with position startPos in the total list, to reach the element at [1,1,1] we do: call getPathToVec([1,1,1], cxDir, path) pos = startPos do k = 1,3 pos = levelDesc(lev)%neigh%nghElems(path(k),pos) end do At the end of the loop pos will point to the requested element

Get the position in the levelDesc%total list of an element with integer coordinate coord. This routine returns ldPos <= 0 if the element could not be found on this process.

Routine to find the bounding box of the part of the spatial domain on this process

getSearchBoxLimits is used in find_particle_comm_procs to determine where the non-local elements we have to check the owner proc of are.

Calculate the Shear Rate

Get the value of variable inside the table name 'key' in scheme @note Todo extent it for vectors

Calculate the velocity in all 3 directions from the element indicated (elem), reading the pdf (state information) from the state array. state array includes all the pdfs of all elements. The access to the state array has to be done via the generic access macro IDX, as we want to access post-collision values.

Calculate the velocity in all 3 directions from a subset given, ordered according to the stencil

Calculate the velocity in all 3 directions from a subset given, ordered according to the stencil

Get the the weights of a used stencil from a given solver specific character handle.

Weight function for 1d linear interpolation or distribution. Given the distance from particle to fluid cell barycenter, it returns weight, where weight is a linear function of the distance between the position of the particle and the barycenter of the lattice site we are distributing to.

Calculate wss from shear stress (tau) tau: x, y, z, xy, yz, xz

Interface for routine to get the value of the velocity and pressure field at a specified integer coordinate

Get the value of the density and velocity at a certain integer coordinate

Get the value of the density and velocity at a certain integer coordinate

Function which checks if element has remote neighbors

Add momentum increments due to particles within DEM subcycles to the auxField

Choose the relaxation model

This subroutine sets the right boundary conditions for the different boundaries.

Initialize stencil for weighted average interpolation

This function initialize eNRTL model by loading liquid mixture property from filename

Initialize the communication buffers for a single level

Initialize the values required for the moments BC

Allocate mus_particles_communication_type and its variables

Initialize the values required for the characteristic boundary conditions

Routine to initialize the particle creator object from a particle blob cylinder object Check if particles should be initialized to the local fluid velocity.

Routine to initialize the particle creator object from a particle blob prism object Check if particles should be initialized to the local fluid velocity.

assign qVal to corresponding BC and level-wise if qVal not provided by seeder. qVal from seeder are assigned in assignBCList in mus_construction_module, So set qVal from config only when it is not provided by seeder.

Create the communication buffers

Create the communication buffers

Initialize Moments transformation matrix for LBM compressible and incompressible fluid model. This matrix must be consistent with the relaxation matrix used in compute kernel and interpolation routines

Intialize the moment transformation matrix for multispecies. This matrix must be consistent with relaxation matrix used for multispecies MRT collision routines

initParticle_DPS performs the initialization of a DPS particle once it has been created. This consists of determining the coordinates of particle origin and determining which processes this particle exists on.

Routine to initialize a newly created MEM particle

Routine to initialize DPS particle log file (e.g. print header)

Routine to initialize MEM particle log file (e.g. print header)

Characteristic-based non-reflective inlet boundary conditions

Characteristic-based non-reflective inlet boundary conditions for incompressible flows

Inlet boundary conditions for passive scalar transport (Flekkoy).

Dump interpolation method to logUnit

Main control routine which interpolates and stores the fluid properties at the particle locations

Interpolate the fluid properties to a point xp

Interpolate the fluid properties to a point xp

1D discrete delta interpolation function. Used to interpolate the fluid property of a lattice cell with barycenter xf to the position of a particle xp.

1D discrete delta interpolation function according to Peskin. Used to interpolate the fluid property of a lattice cell with barycenter xf to the position of a particle xp. Note that this function has a support of 2*dx so requires both neighbor and next-neighbor for interpolation

isLocalCollision checks if collision between two particles is local This is the case when they are both owned by this process

isLocalCollision checks if collision between two particles is local This is the case when they are both owned by this process

Back to central moment This follows equations 57-59 in cumulent paper (Geier .et al 2017)

Back to central moment This follows equations 60-62 in cumulent paper (Geier .et al 2017)

Back to central moment This follows equations 63-65 in cumulent paper (Geier .et al 2017)

Calculating central moment This follows equations 12-14 in cumulent paper (Geier .et al 2017)

Calculating central moment This follows equations 9-11 in cumulent paper (Geier .et al 2017)

Calculating central moment This follows equations 6-8 in cumulent paper (Geier .et al 2017)

Load the iterativeMethod to use in the turbulent wall model from the user configuration.

Load relaxation options from a table

Load shape, bulk velocity and height for turbulent channel force

Load the iterativeMethod to use in the turbulent wall model from the user configuration.

Routine to log DPS particle data

Routine to log MEM particle data

make_pdf_tiny sets the state vector (particle distribution function) values to some tiny value. This is done for visualization purposes. It has no effect on the flow as the particle elements do not participate in the stream-and-collide process.

Main control routine which maps each DPS particle to the lattice

mapToLattice is the high-level routine performs a full re-mapping each time step

Routine to map particles to the lattice (update coordinate of the origin etc.)

Inlet Velocity Bounce Back boundary condition with mass flow rate as input

Inlet Velocity Equilibrium type boundary conditions with mass flow rate as input

Modify the auxField of an element with posInTotal in the total list

No comment yet!

No comment yet!

No comment yet!

No comment yet!

Moment based velocity boundary condition from Sam Bennent PhD thesis "A Lattice Boltzmann Model for Diffusion of Binary Gas Mixtures"

Moment based velocity boundary condition from Sam Bennent PhD thesis "A Lattice Boltzmann Model for Diffusion of Binary Gas Mixtures"

Moment based wall boundary condition from Sam Bennent PhD thesis "A Lattice Boltzmann Model for Diffusion of Binary Gas Mixtures" Usage

derive untransformed pdf velocity of species by solving system of equations of nSpecies

derive untransformed pdf velocity of species by solving system of equations of nSpecies

Optimized Advection relaxation routine for the multispecies mrt model for d3q19 with 3 species

Optimized Advection relaxation routine for the multispecies mrt model for d3q19 with 3 species with thermodynamic factor

Unoptimized Advection relaxation routine for the multispecies BGK model

Unoptimized Advection relaxation routine for the multispecies BGK model with thermodynamic factors in Maxwell-Stefan formulation

set all relaxation parameter to same omega, results in bgk collision

This function returns mrt relaxation diagonal matrix for d2q9 layout Parameters are taken from: Lallemand, P., & Luo, L. (2000). Theory of the lattice boltzmann method: dispersion, dissipation, isotropy, galilean invariance, and stability. Physical Review. E, Statistical Physics, Plasmas, Fluids, and Related Interdisciplinary Topics, 61(6 Pt A), 6546–62.

This function returns mrt relaxation diagonal matrix for d2q9 layout Parameters are taken from: Lallemand, P., & Luo, L. (2000). Theory of the lattice boltzmann method: dispersion, dissipation, isotropy, galilean invariance, and stability. Physical Review. E, Statistical Physics, Plasmas, Fluids, and Related Interdisciplinary Topics, 61(6 Pt A), 6546–62.

This function returns mrt relaxation diagonal matrix for d3q15 layout Parameters are taken from: D’Humières, D., Ginzburg, I., Krafczyk, M., Lallemand, P., & Luo, L.-S. (2002). Multiple-relaxation-time lattice Boltzmann models in three dimensions. Philosophical Transactions. Series A, Mathematical, Physical, and Engineering Sciences, 360(1792), 437–51.

This function returns mrt relaxation diagonal matrix for d3q19 layout Parameters are taken from: D’Humières, D., Ginzburg, I., Krafczyk, M., Lallemand, P., & Luo, L.-S. (2002). Multiple-relaxation-time lattice Boltzmann models in three dimensions. Philosophical Transactions. Series A, Mathematical, Physical, and Engineering Sciences, 360(1792), 437–51.

This function returns mrt relaxation diagonal matrix for d3q27 layout

Loading Musubi specific abort criteria from the abort_criteria table.

Return the solver aux variable for a given set of elements

Return the solver state variable for a given set of elements

Return the solver state variable for a given set of elements by using FETCH macro for nNext

Return the solver state variable for a given set of elements by using FETCH macro for nNow

This routine takes points coordinates, stores them in the method_data and return indices where points are located in the growing array of points or values ( sometimes we do not need to store the points ) It is need to setup points for every variable. Points will be provided by boundaries or sources depends on what uses the variable. This points do not change with time . This indices will be stored in corresponding boundary or source to evaluate a value on that point later using tem_varSys_proc_getValOfIndex.

Wrap up the routines required for dynamic load balancing

Routine load musubi source terms for given key. key is glob_source or source

This routine adds Brinkman (porous-media) damping to the velocity stored in the auxField for the incompressible fluid model. Reference: 1) Zhaoli Guo and T. S. Zhao. “Lattice Boltzmann Model for Incompressible Flows through Porous Media”. In: Physical Review E 66.3 (2002), p. 036304. doi: 10.1103/PhysRevE.66.036304. 2) Irina Ginzburg. “Consistent lattice Boltzmann schemes for the Brinkman model of porous flow and infinite Chapman-Enskog expansion”. In: Phys. Rev. E 77 (6 June 2008), p. 066704. doi: 10.1103/PhysRevE.77.066704.

This routine add sponge density and velocity field to density and velocity in auxField. Density and velocity in far field are computed by time average.

This routine add electric force to momentum in auxField for multispecies liquid model Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for Seawater Desalination"

This routine add electric force to momentum in auxField for multispecies liquid model with thermodynamic factor Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for Seawater Desalination"

This routine add body force to velocity in auxField for weakly-compressible model.

This routine add body force to velocity in auxField for weakly-compressible model for the Generalized Navier Stokes equations (GNS) for coupled LBM-DEM simulations.

This routine add force to velocity in auxField for incompressible model

This routine add body force to momentum in auxField for multispecies liquid model Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for Seawater Desalination"

This routine add body force to momentum in auxField for multispecies liquid model with thermodynamic factor Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for Seawater Desalination"

This routine add sponge density and velocity field to density and velocity in auxField. Density and velocity in far field are computed by time average.

This routine add sponge density and velocity field to density and velocity in auxField. Density and velocity in far field are computed by time average.

This routine add sponge density and velocity field to density and velocity in auxField for weakly-compressible model. Reference: Jacob, J.; Sagaut, P. (2019): Solid wall and open boundary conditions in hybrid recursive regularized lattice Boltzmann method for compressible flows. In Physics of Fluids 31 (12), p. 126103.

Dummy routine for add source to auxField

This routine add source term with charge density in the Poisson equation to the potential. Refer to Appendix in PhD Thesis of K. Masilamani "Coupled Simulation Framework to Simulate Electrodialysis Process for Seawater Desalination"

This routine add dynamic force to velocity in auxField for weakly-compressible model for turbulent channel test case. Force definition: Force = rhou_tau^2/H + rho(u_bulk_ref-uX_bulk_avg)*u_bulk_ref/H Reference: 1) https://www.wias-berlin.de/people/john/ELECTRONIC_PAPERS/JR07.IJNMF.pdf 2) Haussmann, Marc; BARRETO, Alejandro CLARO; KOUYI, Gislain LIPEME; Rivière, Nicolas; Nirschl, Hermann; Krause, Mathias J. (2019): Large-eddy simulation coupled with wall models for turbulent channel flows at high Reynolds numbers with a lattice Boltzmann method — Application to Coriolis mass flowmeter. In Computers & Mathematics with Applications 78 (10), pp. 3285–3302. DOI: 10.1016/j.camwa.2019.04.033.

Advection relaxation routine for the D3Q27 model with BGK with standard equilibrium function

Advection relaxation routine for the BGK model with an explicit calculation of all equilibrium quantities. Slow and simple. This routine should only be used for testing purposes

Unoptimized explicit implementation

Unoptimized explicit implementation

No comment yet!

Improved BGK model (with Galilean correction term) taken from Martin Geier cumulent paper 2015 Geier, M., Schönherr, M., Pasquali, A., & Krafczyk, M. (2015). The cumulant lattice Boltzmann equation in three dimensions : Theory and validation. Computers and Mathematics with Applications.

Improved BGK model (with Galilean correction term) taken from Martin Geier cumulent paper 2015 Geier, M., Schönherr, M., Pasquali, A., & Krafczyk, M. (2015). The cumulant lattice Boltzmann equation in three dimensions : Theory and validation. Computers and Mathematics with Applications.

No comment yet!

Advection relaxation routine for the D3Q19 model with BGK.

Advection relaxation routine for the D2Q9 MRT model f( x+c, t+1 ) = f(x,t) - M^(-1)S( m - meq )

Advection relaxation routine for the MRT model. This routine has roughly 260 FLOPS per elements.

Semi-optimized explicit implementation

No comment yet!

Advection relaxation routine for the D3Q19 model with TRT collision operator In TRT, there are two relaxation parameters one can choose. They have a relationship, which is so-called magic number: Lambda = ( 1/omegaP - 1/2 ) * ( 1/omegaN - 1/2 ) Different value of Lambda results different error: Lambda = 1/4 is the best stability for the LBE. As well, this number gives the solution for the steady-state case dependant only on the equilibirium funciton. Lambda = 1/12 removes the third-order advection error Lambda = 1/6 removes fourth-order diffusion errors Lambda = 3/16 gives exact location of bounce-back walls for the Poiseuille flow. omegaP is usually fixed by viscosity, another one is fixed through the above magic number combination.

No comment yet!

BGK relaxation routine using equilibrium distribution for simulating the Generalized Navier Stokes (GNS) aka Volume-Averaged Navier-Stokes (VANS) equations for coupled LBM-DEM simulations This subroutine interface must match the abstract interface definition kernel in scheme/mus_scheme_type_module.f90 in order to be callable via compute function pointer.

No comment yet!

Advection relaxation routine for the D3Q19 model with BGK for incompressible lbm model

Advection relaxation routine for the D2Q9 MRT model f( x+c, t+1 ) = f(x,t) - M^(-1)S( m - meq )

Advection relaxation routine for the MRT model. This routine has roughly 205 FLOPS per element.

Semi-optimized explicit implementation

No comment yet!

Advection relaxation routine for the D3Q19 model with TRT collision operator.

Advection relaxation routine for the D3Q19 model with BGK based on the !! equilibrium distribution function for the generalized Navier Stokes equations (GNS) aka Volume Averaged Navier-Stokes !! equations (VANS). feq definition from: Z. Guo and T. S. Zhao, “Lattice Boltzmann model for incompressible flows through porous media,” Phys. Rev. E, vol. 66, no. 3, p. 036304, Sep. 2002, doi: 10.1103/PhysRevE.66.036304. Incompressible version

Advection relaxation routine for the flekkoy diffusion model.

Advection relaxation routine for the 2nd order diffusion model. A comparison to the previous flekkoy model can be found in Chopard, B., Falcone, J. & Latt, J. "The lattice Boltzmann advection -diffusion model revisited." Eur. Phys. J. Spec. Top. 171, 245–249 (2009). https://doi.org/10.1140/epjst/e2009-01035-5

Advection relaxation routine based on the E-Model for the D3Q19 Lattice Boltzmann model for the generic advection and anisotropic-dispersion equation

Advection relaxation routine based on the E-Model for the D3Q19 Lattice Boltzmann model for the generic advection and anisotropic-dispersion equation. The E-Model is corrected to account for the effect of numerical diffusion with the nonlinear equilibrium correction $$f_i^{eq,cor} = f_i^{eq} + \frac{w_i}{2 c_s^4} (c_{i\alpha} c_{i\beta} - c_s^2 \delta_{\alpha\beta}) u_\alpha u_\beta$$

Advection relaxation routine based on the E-Model for the D3Q19 Lattice Boltzmann model for the generic advection and anisotropic-dispersion equation. The E-Model is corrected to account for the effect of numerical diffusion with the nonlinear equilibrium correction $$f_i^{eq,cor} = f_i^{eq} + \frac{w_i}{2 c_s^4} (c_{i\alpha} c_{i\beta} - c_s^2 \delta_{\alpha\beta}) u_\alpha u_\beta$$

Advection relaxation routine based on the E-Model for the D3Q19 Lattice Boltzmann model for the generic advection and anisotropic-dispersion equation

Advection relaxation routine based on the E-Model for the D3Q19 Lattice Boltzmann model for the generic advection and anisotropic-dispersion equation. The E-Model is corrected to account for the effect of numerical diffusion with the nonlinear equilibrium correction $$f_i^{eq,cor} = f_i^{eq} + \frac{w_i}{2 c_s^4} (c_{i\alpha} c_{i\beta} - c_s^2 \delta_{\alpha\beta}) u_\alpha u_\beta$$

Advection relaxation routine based on the L-Model for the D3Q19 Lattice Boltzmann model for the generic advection and anisotropic-dispersion equation.

Advection relaxation routine for the TRT diffusion model.

Append auxiliary variables which are computed from state and stored in auxField array using calcAuxField function

This routine adds boundary variables for tracking

Append mixture variables for multicomponent liquid models

Append mixture variables for multicomponent models

subroutine to add derive variables for weakly compressible LBM (schemekind = 'fluid') to the varsys.

subroutine to add derive variables for incompressible LBM (schemekind = 'fluid_incompressible') to the varsys.

subroutine to add derive variables for isothermal acoustic equations (schemekind = 'isotherm_acEq') to the varsys.

subroutine to add derive variables for weakly compressible LBM (schemekind = 'passive_scalar') to the varsys. for passive scalar contains only one derive variable: density

subroutine to add derive variables for multispecies-liquid (schemekind = 'multispecies_gas') to the varsys.

subroutine to add derive variables for multispecies-liquid (schemekind = 'multispecies_liquid') to the varsys.

subroutine to add derive variables for weakly compressible LBM (schemekind = 'lbm') to the varsys.

subroutine to add derive variables for weakly compressible PB (schemekind = 'poisson') to the varsys. A Coupled Lattice Boltzmann Method to Solve Nernst-Planck Model for Simulating Electro-Osmotic flows author> Xuguang yang

subroutine to add material variable

Append variable read from restart file as state variables

Build a variable system of all possible source terms for the given schemeKind

Append state variable depends on the scheme kind

subroutine to add variables for turbulence model

Apply all source terms i.e field specific source and global source on all fields.

This subroutine applies the force calculated to the eulerian elements.

Dummy routine for apply source

This routine assign function pointer to compute auxField var

This function assigns the pointers for the respective derived function in

This function returns function pointer of nonEquilibrium scaling for interpolation according to scheme definition

This function returns mrt function pointer according to scheme definition. In Jonas Toelke paper (2006) about MRT, the following notions are used:\n s(a) = s(2) s(b) = s(3) s(c) = s(5) = s(7) = s(9) s(d) = s(11) = s(13 s(e) = s(17) = s(18) = s(19) s(w) = s(10) = s(12) = s(14) = s(15) = s(16) It is suggested that, for D3Q19, s(a) = s(b) = s(c) = s(d) = s(e) = max( s(w), -1.0 ) Notice that the collision matrix S used in this papar corresponds to -omega in BGK model, because it express the LB equation is slightly different way.

This routine assigns function pointer to compute non-Newtonian viscosity

This routine assigns function pointer to compute turbulence viscosity based on turbulence model and scheme header definition

Auxilary field variable for a given set of points using linear interpolation. Unlike mus_deriveVar_forPoint which does not consider ghost and halo elements, this routine considers them because auxField vars on ghost elements are interpolated and halo elements are exchanged. The interface has to comply to the abstract interface tem_varSys_proc_point.

Routine to get the actual value for a given array of indices. The indices belong to the grwarray of points storing levelwise in Pointdata%pntLvl(iLevel). Hence this routines takes the indeices as input, can refer to the pointData and evaluate the variable and returns the values

This routine performs the load balancing for multilevel simulations. The weights are calculated on the basis of levelwise run time, which are then fed to sparta for calculation of splitting positions. Restart files are saved and the simulation is restarted with the newly distributed mesh

Initialize musubi solverHead and print musubi banner to screen

Output the min and max time across all ranks, which are spent on each boundary condition.

subroutine to find neighbours of element with individual (for each element) stencil definitions. Unique stencil label for boundary stencils are created with boundary label and stencil%cxDir therefore each stencil is limited to one boundary type

This routine build and append IBM stencils to scheme stencil array

This routine build minBcID for boundary elements, it is required if a element has more than one boundary in its directions. if a element has more than one boundary then use minBcID which depends on boundary order in seeder configuration

This routine builds mapping between elements in tree to to propery list

Build global variable system for Musubi

Calculate the number of links to be communicated

This routine calculates Diffusivity coefficients matrix for given mole_frac of all species for single element

Dummy routine which sets diffusivity coeff matrix to diagonal matrix

Compute nElems for different types

This routine calculates thermodynamic factor for given mole_frac of all species for single element

Dummy routine which sets thermodynamic factor matrix to diagonal matrix

Dummy routine for calcAuxField

This routine compute auxFields density and velocity for compressible model for fluid and nGhostFromCoarser elements

This routine compute auxFields density and velocity for compressible d2q9 model for fluid and nGhostFromCoarser elements

This routine compute auxFields density and velocity for compressible d3q19 model for fluid and nGhostFromCoarser elements

This routine compute auxFields density and velocity for compressible d3q27 model for fluid and nGhostFromCoarser elements

This routine compute auxField density and momentum for each species for multicomponent models. The momentum computed here is only momentum of transformed PDF. The momentum of original PDF is computed by solving linear equation system in compute kernel and the momentum in auxField is updated there.

This routine compute zeroth moment (mole density) from state for each species and store in auxField.

This routine compute zeroth moment from state and store in auxField. use this routine only for models which requires only zeroth-order moment as auxField

This routine compute auxField variable from pre-collision pdf and exchange halos

This routine computes force on boundary elements which are used to compute lift and drag coefficient on boundary

Dummy routine for calcBndForce

This routine access bndForce from turbulent wall function boundary elements

This routine computes bndForce on wall boundary elements

This routine computes bndForce on wall_libb boundary elements

This subroutine fills the force array for the X (neighbors). (Inamuro paper: step 1, fill g_l(X))

This function compute relaxation paramter omega from viscosity

Calculate lattice speed of sound for given stencil

Check if a BC is wall or symmetry for all fields

This routine checks whether omega is within the stability limit. If not it will terminate the simulation with error message. Using limits given in Tölke, J., Freudiger, S., & Krafczyk, M. (2006). An adaptive scheme using hierarchical grids for lattice Boltzmann multi-phase flow simulations. Computers & Fluids, 35(8–9), 820–830. For BGK: 2/3 < omega < 1.976 For MRT: 2/3 < omega < 1.999

Initialize Musubi data strucutres based on data provided by Treelm

Construct the propagation list for each element of 1st field.

This subroutine corrects the velocity values according to the force on X (neighbors). (Inamuro paper: step 2, correct u_l(X))

This routine creates musubi specific lua function to compute dx and dt.

Routine initialize possible source variable depends on scheme kind

Routine initialize possible transport variable depends on scheme kind

This routine creates srcElemInTree in pointData. It is called all in getPoint routine when first time the get point routine in called.

This subroutine sets the parameters for the predefined d2q9 stencil.

This subroutine sets the parameters for the predefined d2q5 stencil.

This subroutine sets the parameters for the predefined d2q9 stencil.

This subroutine sets the parameters for the predefined d3q13 stencil.

This subroutine sets the parameters for the predefined d3q19 stencil.

This subroutine sets the parameters for the predefined d3q27 stencil.

This subroutine sets the parameters for the predefined d3q6 layout%fStencil, used by the Flekkoy model of passive scalar transport.

This subroutine sets the parameters for the predefined d3q7 stencil.

This routine defines layout for predefined stencils

Calculate the equlibrium of given elements with the given input state array.

Calculate the density of a given set of elements (sum up all links). This routine is used to compute density for all scheme kinds For multispecies, it can compute both species density and mixture density

Calculate the electric_field of a given pre-collision pdfs i.e fetch_pdf_now

Calculate the equlibrium of given elements with the given input state array.

Calculate the potential of a given set of pdfs of elements

For 2D only!

Calculate the Non-Equlibrium

Calculate the strain rate ( or rate of strain, or rate of deformation)

Derive variable for a given set of points using linear interpolation. This is a generic routine for any variable. Limitation: If neighbor is halo element then its not considered for interpolation, only the fluid (non-ghost) elements in the local process are used for interpolation.

Calculate the velocity of a given element number with the given input vector (sum up all values)

Destroy the stencil

This routine dumps global nElems in intpFromCoarser, intpFromFiner, sourcesFromCoarser ans sourcesFromFiner

Dump moments matrix: toPDF and toMoment

This routine dumps tracking and restart when timeControl is active

Dump weights to a file.

This routines act as a destructor for field type. Only allocatable arrays which are allocated in mus_construct routine are deallocated. KM: DO NOT DESTROY FIELD ARRAY AS IT CONTAINS ALL CONFIG INFO

This routine checks for the existence of symmetric boundaries and returns the boundary IDs which are defined as symmetry

write single field into a lua file

write field prop into a lua file

This routines deallocates allocatables in field%bc boundary_type for dynamic load balancing

Interface for dumping a single field or a set of fields in a file in lua format.

write array of fields into a lua file

This routine builds the neighbor lists for Xk -> x (neigh_Xk) and x->Xk (neigh_x) as well as the send and receive buffers for the eulerian elements.

Do final check on check on total density, Close auxiliary stuff such as restart and the tracker, finalize treelm, dump timing and finialize mpi with fin_env

This routine finialize grwStencil by truncating stencil elem arrays and set stencil%nElems

This routine dumps the timings%timedat to disc

This routines act as a destructor for fluid type

write fluid prop into a lua file

This routine frees all temporary variables and destroys growing arrays as well as the communicators.

This routine prepares the data for variable derivation or operators. It gathers all input variables from the variable system, calls the function with the actual calculation.

Routine to get the actual value for a given array of indices for musubi derive variables The indices belong to the grwarray of points storing levelwise in Pointdata%pntLvl(iLevel). Hence this routines takes the indeices as input, can refer to the pointData and evaluate the variable and returns the values

This subroutine checks for various conditions defined in the geomIncr table within the lua file, calculates the requested macroscpoic variables and then compares them against the specified threshold. Accordingly then solidification or fluidification of elements is performed.

Read all the necessary information for the geometry increase from the lua config file. This routine basically provides as a wrapper to the routine which reads single values

Reads various parameters from the lua file defined for geometry increase This routine reads single values and is wrapped around in another function where it is called multiple times as required

Routine to get a pointer to a new instance of mus_varSys_solverData_type to be used as method data for a variable in the variable system.

Get Surface points on boundary elements. For boundary state variable which are evaluated linkwise, extract surface points for each link and for non-link based variables project barycenter on the boundary surface. Return real coordinates on boundary surface and offset bit which encodes direction.

This function returns musubi modular variable mus_timerHandles to apesmate and deallocate mus_timerHandles level timers.

Calculate weights using timing from compute kernel, interpolation and boundary routines

Read in LUA parameter file See http://www.lua.org for a reference on how to use Lua is a scripting language in itself which allows more complex parameter files including comments And load / create the mesh depending on the configuration

Initialize Musubi data strucutres based on data provided by Treelm

Init auxiliary features such as interpolation boundaries, restart and the tracker

This routines load solver data from config file except tracking

This subroutine builds the communication types for the lagrangian elements Xk.

This subroutine communicates all elements which just moved from the fluids to the halo elements.

This routine calculates the surface velocity for all local xk.

This subroutine prepares the send and receive buffers for the eulerian elements by copying information from the send and receive buffers for the lagrangian elements.

This subroutine sets the positions of the parent IDs in the level descriptor.

This routine finishes the buffers for Xk and X_pdf. This is moved to a seperate routine since both buffers depend on a local communication which should be done nearby the global synchronization point (mus_exchange)

The integer moment vector for a given cxDir and order.

This subroutine modifies the state vector according to the method described in the paper \a Lift generation by a two-dimensional symmetric flapping wing: immersed boundary-lattice Boltzmann simulations \a by Inamuro et al. @cite Ota:2012bx .

This subroutine fills the initial force, initial velocity, predef. velocity array for the surface points Xk as well as the velocity array for the neighbors.

Initialize arrays to store time average density and velocity for dynamic absorbing layer. \todo KM: 20210301 Allocate only pressure or velocity depending on absorb_layer_inlet or absorb_layer_outlet

Assigning compute kernel routine by scheme relaxation type for fluid kind.

This routine assigns compute routine for bgk relaxation.

Assigning compute kernel routine by scheme relaxation type for fluid GNS kind.

This routine assigns compute routine for mrt relaxation

This routine assigns compute routine for trt relaxation

Initialize the relaxation model for lbm incompressible model

This routine assigns compute routine for bgk relaxation

Assigning compute kernel routine by scheme relaxation type for fluid GNS kind for unresolved LBM-DEM particulate flow simulations

This routine assigns compute routine for mrt relaxation

Assigning compute kernel routine by scheme relaxation type for isotherm_acEq kind.

Initialize the relaxation model for lbm passive scalar scheme kind

Initialize the relaxation model for multispecies gas model

Initialize the relaxation model for multispecies liquid model

Initialize the relaxation model for lbm poisson equation

Initialize the relaxation model for lbm poisson equation

Initialize the relaxation model for lbm poisson equation

Initialize the relaxation model for lbm poisson equation

Init auxiliary features such as interpolation boundaries, restart and the tracker

This routine initialize auxField var val array and communication buffers

This routine initialize bndForce array assign function pointer to calculate bndForce

Check prerequisite for multi-species boundary conditions

Initialize flow field by calling corresponding routine according to scheme kind.

This routines sets the function pointer to main control routine

This function loads property file using external c-function

Dummy function to init_enrtl

Initialize flow field depends on read restart or initial condition

This routine initilizes fluid visocity and relaxation paramters for each level

This subroutine initializes the geometry increment.

This routine initialize gradData with direct neighbors in state and finite difference coefficients.

Initialize arrays to store time average density and velocity for dynamic hrrCorrection. \todo KM: 20210301 Allocate also for ghost cells!

This subroutine initializes the IBM data incl. reading the stl, unifying the coordinates, storing the connectivity, allocating the parentIDs array and initializing the stencil used.

This subroutine initializes all arrays in the mus_IBM_tmpData_type.

This routines does setup indices for given source within a field or global. Index are stored for points which source term is active

This subroutine initialzes the interpolation

Initialize the isothermal acEq flow from density and velocity\n equilibrium pdf (fEq) is calculated from density and velocity

This routine initialize lattice dx and dt

Initialize growing array of stencils

Initialize levelwise ghost and source list for interpolation