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

Allocate BC lists, 2nd step in Build_BClists

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 "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 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 "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.

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

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.

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

Calculate global and sum of levels numbers of elements

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.

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

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)

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.

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

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

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

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

D u m p

t h e

n e i g h b o r s

f o u n d

f o r

t h e

b o u n d a r i e s

w i t h

n e i g h b o r

e l e m e n t s

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

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

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

No comment yet!

Fill GhostFromFiner elements on my level with debug value

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

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

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

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

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

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

This routine computes friction velocity from Schmitt wall model.

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

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.

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

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.

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.

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

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

Initialize the values required for the characteristic boundary conditions

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

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

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.

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

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

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 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 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!

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

Dummy routine which sets diffusivity coeff matrix to diagonal matrix

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

Compute nElems for different types

Dummy routine which sets thermodynamic factor matrix to diagonal matrix

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

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.

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

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

Dummy function to init_enrtl

This function loads property file using external c-function

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

Wrapper around the actual communication, to avoid copy-in, copy-out by the Intel compiler. (At least the intel compiler on pigeon (v12.0) seems to do copying here, if a sub-array is passed to an assumed size dummy argument. Therefore we use this wrapping with an assumed shape dummy argument, so we can pass a complete field to the actual exchange which has an assumed size argument, without copying complete state field around, just for communication. Ugly, but it doesn't seem to have an impact on performance, and right it seems to be the most suitable solution.

Timers initialization routine for whatever

Initialize the moment space

Initialize the flow from calculated quantitites like density, velocity etc. for multispecies lbm

Initialize the flow from calculated quantitites like density, velocity etc. for multispecies lbm

Initialize nernst planck from and .\n Equilibirium pdf (fEq) is calculated from and .

Initialize passive scalar from pressure and velocity.\n Equilibirium pdf (fEq) is calculated from pressure and velocity.

Initialize the flow from pressure, velocity and strain rate.\n First equilibirium pdf (fEq) is calculated from pressure and velocity. Then non-equilibirium (fnEq) is calculated from strain rate. At last set the pdf of each element by sum up these two parts (fEq+fnEq).

Initialize poisson lbm from potential Equilibirium pdf (fEq) is calculated from potential.

This routine initialize relaxation parameter

Initialize single scheme stencil and variable system

This routine does set_params and setupIndices for all sources terms by gathering points to apply souce term before.

This routine initialize tracking subTree to remove empty tracking objects. On active tracking objects: Homogenize time control, write solver speific info for harvester output format and initialize output using tem_init_tracker

Initialize transport variable by calling setupIndices for every variable and store pntIndex

This routine allocates turbulent viscosity and friction velocity on boundary elements. It also initialize friction velocity from stream-wise velocity component on first neighbor in normal direction.

Create subTree and store nElemsGlobal in all proc for turbulent channel force

This initialize turbulence data type which includes velocity array and communication buffer

This routine initialize auxField variable from PDF values initialized by initial condition. AuxField is computed from state using SAVE access for fluid elements and interpolated for ghost elements

This routine initializes auxField for fluid elements using SAVE access on PDF initialized by IC

This routine load musubi configuration file and initialize construction flow, auxilary and main control routines

Bilinear interpolation for a vector quantity phi

Trilinear interpolation for a vector quantity phi Each phi corresponds to each moment

Dump interpolation method to lua

Biquadratic interpolation for a vector quantity phi

Triquadratic interpolation for a vector quantity phi Each phi corresponds to each moment

Determine the numerical error of the interpolated quantities to the given initial conditions

This function returns pdfs from state

The required source elements for ghost from coarser elements are identified in this routine. Moreover, the weights for each sources based on distance are calculated. \n

All sources (children) have been found in treelm, updated number of sources needed, based on nDims collect all source elements into sourceFromFiner assign ghost intp list. Currently only average interpolation is implemented for fillMineFromFiner

This routine interpolate auxField variable for ghostFromFiner and exchange halos

This routine interpolate auxField variable for ghostFromCoarser and exchange halos

This subroutine interpolates the velocity values using the velocity on Xk. (neighbors). (Inamuro paper: step 3, correct u_l(X_k))

This routine load additional information for absorblayer

Read in the boundary conditions from the LUA parameter file.\n

This routine invokes the treelm routines to load the boundary conditions

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

load fluid properties like fluid and species table from lua file based on the scheme kind

load a single field table In includes: load field property load source variables load boundary defination load immersed boundary method load initial condition defination and its property

This routine returns nFields and field labels from config file. It is required to initialize variable system. labels are loaded only if field table is present else default is set to empty string.

Subroutine to load the field table from the lua configuration file.

Read in the fluid property from the LUA parameter file

This routine load all geometry related datas like mesh, boundary and immersed_boundary. Restart is also loaded here because mesh is loaded in tem_load_restart if restart read is defined.

Load the IBM information from the lua config file.

Load a single IBM table from the config file.

Read in the type of interpolation scheme

This routine load mixture table from scheme table. Define either mass density or number density. If mass density is specified, number density can be computed at runtime or vice versa. @note Todo Currently, the simulation is initialized by density, extend it to initialize from mixture number density/volume fraction and mole fraction \verbatim mixture = { rho0 = 1.0, omega } \endverbatim

load input to solve nernst_planck equation

load a new stencil definition from the lua file

load global parameter from conf

This routine loads the physics table from musubi config file

load input to solve poisson equation

Load input to solve poisson boltzmann equation

load single scheme defined in lua file with or without scheme handle

load scheme header info from lua file identify table or from scheme table or from config

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

this routines load species table from config file

Routine load musubi transport variables

This routine loads wall model and nonlinear solver type for nonlinear equation

load turbulence table

This routine write mixture properties into lua file

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

Dump nonNewtonian (CY) parameters to outUnit

Read in the nonNewtonian Casson model parameters from Lua file

write nonNewtonian Casson parameters into a lua file

Dump nonNewtonian (CY) parameters to outUnit

Read in the nonNewtonian Carreau-Yasuda (CY) model parameters from Lua file

write nonNewtonian (CY) parameters into a lua file

Dump nonNewtonian fluid parameters to outUnit

Read in the nonNewtonian table from Lua file and dump parameters to logUnit Specificly, this routine calls each model parameter loader.

Dump nonNewtonian Power Law (PL) parameters to outUnit

Read in the nonNewtonian Power Law (PL) model parameters from Lua file

write nonNewtonian Power Law (PL) parameters into a lua file

write nonNewtonian fluid parameters into a lua file

This routine loads musubi specific lua function from string and musubi input configuration file

This routine returns the velocity gradient from velocity in auxField

This routine computes Q-criterion from velocity in auxField. $$Q = 1/2 ( (tr(\nabla u))^2 - tr(\nabla u \cdot \nabla u) ) = 1/2 |\Omega|^2 - |S|^2$$ , where $$\Omega$$ and S are asymmetric (vorticity tensor) and symmetric (rate of strain) part of velocity gradient. i.e $$\Omega = 1/2(du_i/dx_j - du_j/dx_i)$$ and $$S=1/2(du_i/dx_j + du_j/dx_i)$$ .

This routine computes vorticity from curl of velocity in auxField. $$vorticity = \nabla \times u$$

This routine writes global parameter into solver specific string in lua format

Advection relaxation routine for the linear poisson boltzmann equation with an explicit calculation of all equilibrium quantities. Slow and simple. $$\nabla^2 \phi = k^2 \phi$$ Where k^2 is inverse of debye length and in this kernel refered as RHS_coeff $$k^2 = \sum_i \frac{ c_{\infty}z_i^2 e^2}{\epsilon_r \epsilon_0 k_b T}$$

Advection relaxation routine for the nonlinear poisson boltzmann equation for electrolyte solution $$\nabla^2 \phi = - \frac{1}{\epsilon_r \epsilon_0} \sum_i { e z_i c_{\infty} N_A exp(-\frac{z e }{k_b T}\phi) }$$

Preparation of the serialize PDF data

This subroutine unserializes the read data and stores it in the state- vector to perform a restart.

This routine measures performance imbalance, MLUPS and dumps timings to disk

Wrap up the routines required for dynamic load balancing

This routine write reference physics parameters into solver specific string in lua format.

This routine write physics convert factor into solver specific string in lua format. use reference density to parmeterize kg and reference mole density to parmeterize mol.

Advection relaxation routine for the poisson equation with an explicit calculation of all equilibrium quantities. Slow and simple. $$\nabla^2 \phi = - \frac{\rho_e}{\epsilon_r \epsilon_0}$$ The right hand side of equation is added as a source term in mus_apply_sourceTerms routine

Advection relaxation routine for the poisson equation with an explicit calculation of all equilibrium quantities. Slow and simple. $$\nabla^2 \phi = - \frac{\rho_e}{\epsilon_r \epsilon_0}$$ The right hand side of equation is added as a source term in mus_apply_sourceTerms routine

Print information on the pre-processor options of the executable.

Read the serialized restart file into the state vectors

Same as reductionTransient_forElement except it evaluate it multiply values from points

This subroutine initializes musubi after a dynamic load balancing is performed.

This subroutine acts as a destructor for the construct routine

Dumps scheme header

Dump single scheme info into restart solver specific conf to dump solver specific information in restart header file

Set necessary data for Wall Bouzidi BC bouzidi should be allocated beforehand

This routine computed conversion factors for lattice to physical units. inverse of this factors can be used to convert from physical to lattice units.\n use reference density to parmeterize kg and reference mole density to parmeterize mol.\n Multiply these factors with the LB quantity to get the physical quantity Divide the physical quantity by these factors to get the LB units.

Set ic states labels by scheme kind

Bitmask is true for incoming direction

Set necessary data for BC velocity_bounceback_qval

Linkwise non-equilibrium extrapolation (can handle curved walls)

Routine to store musubi varSys Data in operation variable solver_bundle. Unline Ateles, Musubi operations does not require any special treatment so it uses to generic routines in treelm

Set BC elements positions in LevelDesc%neigh%nghElems

Routine to store musubi varSys Data in stFun variable

This routine sets mus_timerHandles passed by apesmate

This routine updates the propertybits of an element If solidify == true, set prp_fluidify and set prp_solid If fluidify == treu, clean prp_fluidify and set prp_fluid

This routine setup indices for boundary variables in bc_State_type pntIndex for the points on which boundaries are treated.

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

This routine does the main musubi computation loop

This routine act as a destructor for source type. The arrays allocated in mus_init_sourceTerms are destroyed here

writes species propertries into a lua file

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

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

State variable for a given set of points using linear interpolation.

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

Store the position of each boundary variable in the global varSys in the field%bc%varPos%. This routine also checks if boundary variable defined in config file has same number of components as expected.

Store the position of each variable in the global system in the derVarPos This function is also called in Harvester.

Call tests to determine the actual error from the interpolation routines on the ghost elements. Compare against the analytical solution, which is given in terms of the initial conditions. Call this routine after the initial values are set and the ghost elements have been filled once, but no computation was started -> after fillHelperElements in the mus_aux_module

Convert itime from restart to real time

Check for multilevel cycle complete by modulo of nIters by scaleFactor depends on acoustic or diffusive scaling. Acoustic scaling: scale factor = 2 Diffusive scaling: scale factor = 4

Converts sim time to iter and vice versa depends on which one is defined in the configuration file

This routine compute turbulence viscosity and stores in turbulence data type

This routine update turbulent viscosity of boundary elements from RANS viscosity computed in turbulent_wall boundary.

Dummy function for turbulent viscosity from Gradu procedure

Dummy function to compute turbulent viscosity from PDF

Calculate eddy viscosity with smagorinsky model for compressible model using gradient of velocity for 2D layout

Calculate eddy viscosity with smagorinsky model for incompressible model using gradient of velocity for 2D layout

Calculate eddy viscosity with smagorinsky model for compressible model using gradient of velocity Reference paper: https://link.springer.com/content/pdf/10.1007/s10494-012-9405-0.pdf?pdf=button The formula is taken from https://caefn.com/openfoam/smagorinsky-sgs-model nu_t = C_k delta sqrt(k_sgs) k_sgs = ((-b+sqrt(b^2+4ac))/2a)^2 a = C_e/delta, b=2/3 tr(dev(Strain)), c = 2 C_k delta (dev(Strain):Strain)

Calculate eddy viscosity with smagorinsky model for incompressible model using gradient of velocity

Calculate eddy viscosity with smagorinsky model for compressible model using pre-collision PDF. Schneider, A. (2015). A Consistent Large Eddy Approach for Lattice Boltzmann Methods and its Application to Complex Flows. Technical University Kaiserslautern.

Calculate eddy viscosity with smagorinsky model for compressible model using pre-collision PDF. Schneider, A. (2015). A Consistent Large Eddy Approach for Lattice Boltzmann Methods and its Application to Complex Flows. Technical University Kaiserslautern.

Calculate eddy viscosity with smagorinsky model for incompressible model using pre-collision PDF

Calculate eddy viscosity with smagorinsky model for incompressible model using pre-collision PDF

Calculate eddy viscosity with Vreman model for 2D stencil model \todo add reference and formula

Calculate eddy viscosity with Vreman model for 3D stencil Fortran implementation of this model: http://www.vremanresearch.nl/Vreman_Subgridmodel_Fortran.txt

Calculate eddy viscosity with WALE (Wall-Adapting Local Eddy-viscosity) model \todo add reference and formula

Calculate eddy viscosity with WALE (Wall-Adapting Local Eddy-viscosity) model \todo add reference and formula

This routine is used to initialize relaxation paramter and update bulk viscosity at every time step Bulk visocisty is defined as space-time function to apply ramping and spatial sponge in bulk viscosity

Update kinematic relaxation parameter from viscosity and check omega

Set relaxation parameters for MRT

Updated all source variables i.e field specific source and global source on all fields.

Update kinematic viscosity from STfun and calculate turbulent viscosity from velocity gradient or nonEqPDF Viscosity obtained from this routine are normalized to the level

Update the connectivity for elements with symmetric boundary condition such that during the propagation they are applied implicitly.

Dummy routine for update source variable

Compute density and velocity in sponge layer for dynamic sponge

Compute dynamic force term using auxField for turbulent channel force.

Dump the weights in lua format.

Write the serialized buffer assembled in mus_serializeData to disk

Write solver specific info to scratch file

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

This routine normalizes the normal vectors of boundary elements including the corner elements as well as assigns the corresponding prevailing direction from the stencil

Outlet Pressure do-nothing boundary is the open boundary condition for incompressible model. This BC sets reference density at boundary so pressure is not loaded config file. Here, the normal velocity is extrapolated from 1st fluid node and tangential velocity is extrapolated from 2nd fluid node in normal direction. Algorithm used in this boundary condition: fEq(1,u) and fEq(rho,u) are computed using macroscopic values from current element. In fNeq, post-collision of current time step is used for normal direction.

Characteristic-based non-reflective open boundary conditions

Characteristic-based non-reflective open boundary conditions

Characteristic-based non-reflective open boundary conditions

Outlet boundary conditions for passive scalar transport (Flekkoy).

Outlet boundary conditions with zero pressure gradient.

Perform run-time checks if interval is active

Linkwise neumann potential non-equilibrium boundary condition for curved and straight walls (zero gradient). For straight wall, values are extrapolated along boundary normal instead of along the link. The accuracy of straight wall depends on the qVal defined in config file and default is set to 0.5