# Procedures

ProcedureLocationProcedure TypeDescription
access_kineOmega_forElementmus_material_var_moduleSubroutine

This routine returns the omega

access_kineVisc_forElementmus_material_var_moduleSubroutine

This routine returns the kinematic viscosity

access_turbVisc_forElementmus_turbulence_var_moduleSubroutine

This routine returns the turbulent viscosity

allocate_momBufmus_pdf_moduleSubroutine
allocateBCListmus_construction_moduleSubroutine

Allocate BC lists, 2nd step in Build_BClists

applySrc_absorbLayermus_derQuan_moduleSubroutine

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.

applySrc_absorbLayer_MRTmus_derQuan_moduleSubroutine

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.

applySrc_absorbLayerDynmus_derQuan_moduleSubroutine

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.

applySrc_absorbLayerDyn_MRTmus_derQuan_moduleSubroutine

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.

applySrc_absorbLayerIncompmus_derQuanIncomp_moduleSubroutine

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.

applySrc_chargeDensity_1stOrdmus_derQuanPoisson_moduleSubroutine

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"

applySrc_chargeDensity_2ndOrdmus_derQuanPoisson_moduleSubroutine

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

applySrc_electricFieldMSLiquid_2ordermus_derQuanMSLiquid_moduleSubroutine

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

applySrc_electricFieldNPmus_derQuanNernstPlanck_moduleSubroutine

Update state with source variable "electric field"

applySrc_electricMSLiquid_1stOrdmus_derQuanMSLiquid_moduleSubroutine

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

applySrc_electricMSLiquid_1stOrd_WTDFmus_derQuanMSLiquid_moduleSubroutine

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

applySrc_electricMSLiquid_2ndOrdmus_derQuanMSLiquid_moduleSubroutine

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"

applySrc_electricMSLiquid_2ndOrd_WTDFmus_derQuanMSLiquid_moduleSubroutine

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"

applySrc_equalInjectionPSmus_derQuanPS_moduleSubroutine

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

applySrc_forcemus_derQuan_moduleSubroutine

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

applySrc_force1stOrdmus_derQuan_moduleSubroutine

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

applySrc_force_MRTmus_derQuan_moduleSubroutine

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 and

applySrc_force_MRT_d3q19mus_derQuan_moduleSubroutine

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 and

applySrc_forceMSLiquid_1stOrdmus_derQuanMSLiquid_moduleSubroutine

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"

applySrc_forceMSLiquid_1stOrd_WTDFmus_derQuanMSLiquid_moduleSubroutine

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"

applySrc_forceMSLiquid_2ndOrdmus_derQuanMSLiquid_moduleSubroutine

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"

applySrc_forceMSLiquid_2ndOrd_WTDFmus_derQuanMSLiquid_moduleSubroutine

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"

applySrc_injectionPSmus_derQuanPS_moduleSubroutine

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

assign_intp_fluidmus_interpolate_moduleSubroutine

Set up interpolation routines for fluid (weakly compressible) scheme

assign_intp_fluidIncompmus_interpolate_moduleSubroutine

Set up interpolation routines for fluid_incomp scheme

assign_intp_fluidIncompLESmus_interpolate_moduleSubroutine

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

assign_intp_fluidLESmus_interpolate_moduleSubroutine

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

assignBCListmus_construction_moduleSubroutine

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

bc_pdfmus_bc_fluid_moduleSubroutine

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

No comment yet!

No comment yet!

Advection relaxation routine for the D3Q19 model with BGK.

No comment yet!

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

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 D3Q27 model with BGK with standard equilibrium function

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

Advection relaxation routine for the flekkoy diffusion model.

Advection relaxation routine for the flekkoy diffusion model without prior definition of a dependent fluid scheme. Velocity is read from the depend table.

Advection relaxation routine for the BGK model.

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

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

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

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

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.

2D Biquadratic interpolation for fill fine from coarse. array f contains function values at 9 coarse elements. they are arranged as: 7 8 9 4 5 6 1 2 3 position of element 1 is set as original, i.e. (0,0), element 9 is set as (1,1) x,y are the coordinates of target position. fOut is the interpolated value at target position

build_BClistsmus_construction_moduleSubroutine

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

calc_MLUPSmus_tools_moduleFunction

Calculate the MLUPS or MFLUPS for the simulation

calc_momentsmus_interpolate_d3q19_moduleSubroutine
calc_ms_diff_matrix_from_moledensmus_eNRTL_moduleInterface

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

calc_ms_diff_matrix_from_molefracmus_eNRTL_moduleInterface

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

calc_therm_factor_locmus_eNRTL_moduleInterface

This routine calculates thermodynamic factor for given mole_frac of all species

calcDensAndVelsFromPDFmus_bc_species_moduleSubroutine

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.

calculate_nElemsmus_construction_moduleSubroutine

Calculate global and sum of levels numbers of elements

calcVisc_CSmus_nonNewtonian_moduleSubroutine

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

calcVisc_CYmus_nonNewtonian_moduleSubroutine

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

calcVisc_incomp_CSmus_nonNewtonian_moduleSubroutine

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

calcVisc_incomp_CYmus_nonNewtonian_moduleSubroutine

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

calcVisc_incomp_PLmus_nonNewtonian_moduleSubroutine

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

calcVisc_PLmus_nonNewtonian_moduleSubroutine

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!

central_momentmus_d3q27_moduleFunction

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

central_moment_splitmus_d3q27_moduleFunction

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_BCs_preRequisite_MSmus_bc_general_moduleSubroutine

Check prerequisite for some boundary conditions

check_densitymus_tools_moduleSubroutine

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

check_flow_statusmus_aux_moduleSubroutine

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

check_potentialmus_tools_moduleSubroutine

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_streaming_layoutmus_tools_moduleSubroutine

Check for the streaming layout.

check_varSys_forPdfVarmus_variable_moduleSubroutine

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

check_velocityFluidmus_tools_moduleSubroutine

Check the maximum velocity whether it is above Ma>0.1

check_velocityMSmus_tools_moduleSubroutine

Check the maximum velocity whether it is above Ma>0.1

cm_to_pdfmus_d3q27_moduleFunction
communicate_propertymus_construction_moduleSubroutine

Initialize the communication buffers for a single level

compute_bulkViscOmegamus_species_moduleSubroutine

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

compute_molWeightRatiomus_species_moduleSubroutine

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

compute_weightmus_interpolate_moduleSubroutine

This routine computes weights for weighted_average interpolation.

convPrePostmus_derivedQuantities_module2Function

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

countnBndsmus_construction_moduleSubroutine

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

cumulant_d3q27mus_d3q27_moduleSubroutine

No comment yet!

debug_connectivitymus_debug_moduleSubroutine

Detailed Debug output to the PDF neighbor (connectivity) list

debug_dependenciesmus_interpolate_tools_moduleSubroutine

check the dependencies from Finer

debug_dependenciesFromCoarsermus_debug_moduleSubroutine

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_dependenciesFromFinermus_debug_moduleSubroutine

Debug the dependencies for the ghostFromFiner elements

debug_normalsmus_debug_moduleSubroutine

Dump the neighbors found for the boundaries with neighbor elements

derDensityIsothermAcEqmus_derQuanIsothermAcEq_moduleSubroutine

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

derEquilIsothermAcEqmus_derQuanIsothermAcEq_moduleSubroutine

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

derEquilIsothermAcEq_fromIndexmus_derQuanIsothermAcEq_moduleSubroutine

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

derive_absorbLayermus_derQuan_moduleSubroutine

Derive absorb layer variable defined as a source term.

derive_absorbLayerIncompmus_derQuanIncomp_moduleSubroutine

Derive absorb layer variable defined as a source term.

derive_auxFromState_dummymus_derVarPos_moduleSubroutine

Dummy routine for auxFromState

derive_equalInjectionPSmus_derQuanPS_moduleSubroutine

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

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_force1stOrdmus_derQuan_moduleSubroutine

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_injectionPSmus_derQuanPS_moduleSubroutine

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

deriveAux_fromStatemus_derQuan_moduleSubroutine

This routine computes auxField from state array

deriveAuxIncomp_fromStatemus_derQuanIncomp_moduleSubroutine

This routine computes auxField from state array

deriveAuxMSGas_fromStatemus_derQuanMSGas_moduleSubroutine

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

deriveAuxMSLiquid_fromStatemus_derQuanMSLiquid_moduleSubroutine

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.

deriveAuxMSLiquid_fromState_WTDFmus_derQuanMSLiquid_moduleSubroutine

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.

deriveAuxNP_fromStatemus_derQuanNernstPlanck_moduleSubroutine

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

deriveAuxPoisson_fromStatemus_derQuanPoisson_moduleSubroutine

This routine computes auxField 'potential' from state array

deriveAuxPS_fromStatemus_derQuanPS_moduleSubroutine

This routine computes auxField from state array

deriveBndForcemus_derQuan_moduleSubroutine

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

deriveChargeDensitymus_derQuanMSLiquid_moduleSubroutine

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

deriveChargeDensity_fromIndexmus_derQuanMSLiquid_moduleSubroutine

Calculate charge density from species concentration

deriveChargeDensityBoltzAppr_forElementmus_derQuanPoisson_moduleSubroutine

Calculate charge density from potential field using Boltzmann approximation

deriveChargeDensityBoltzAppr_fromIndexmus_derQuanPoisson_moduleSubroutine

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

deriveChargeDensityPhymus_derQuanPhysics_moduleSubroutine

Calculate the charge density of a given set of elements

deriveChargeDensityPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the charge density of a given idx

deriveCurrentDensitymus_derQuanMSLiquid_moduleSubroutine

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

deriveCurrentDensity_fromIndexmus_derQuanMSLiquid_moduleSubroutine

Calculate current density from species momentum

deriveCurrentDensityPhymus_derQuanPhysics_moduleSubroutine

Calculate the current density of a given set of elements

deriveCurrentDensityPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

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

deriveDensitymus_derQuan_moduleSubroutine

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

deriveDensity_fromIndexmus_derQuan_moduleSubroutine

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

deriveDensityPhymus_derQuanPhysics_moduleSubroutine

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

deriveDensityPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

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

deriveElectric_FieldPhymus_derQuanPhysics_moduleSubroutine

Calculate the electric_field of a given set of elements

deriveElectric_FieldPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the electrical field of a given idx

deriveElectricfield_forElementmus_derQuanPoisson_moduleSubroutine

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

deriveElectricfield_fromIndexmus_derQuanPoisson_moduleSubroutine

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

deriveEq_FromStatemus_derQuan_moduleSubroutine

This routine computes velocity from state array

deriveEq_FromState_IsothermAcEqmus_derQuanIsothermAcEq_moduleSubroutine

This routine computes equil from state array

deriveEqIncomp_FromStatemus_derQuanIncomp_moduleSubroutine

This routine computes equilibirium from state array Here it is assumed that rho0 = 1.0

deriveEqMSGas_FromStatemus_derQuanMSGas_moduleSubroutine

This routine computes equilibrium from state array

deriveEqMSLiquid_FromStatemus_derQuanMSLiquid_moduleSubroutine

This routine computes equilibrium from state array

deriveEquilmus_derQuan_moduleSubroutine

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

deriveEquil_fromAuxmus_derQuan_moduleSubroutine

This routine computes equilbrium from auxField

deriveEquil_fromIndexmus_derQuan_moduleSubroutine

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

deriveEquil_FromMacromus_derQuan_moduleSubroutine

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

deriveEquil_FromMacro_IsothermAcEqmus_derQuanIsothermAcEq_moduleSubroutine

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

deriveEquilIncompmus_derQuanIncomp_moduleSubroutine

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

deriveEquilIncomp_fromAuxmus_derQuanIncomp_moduleSubroutine

This routine computes equilbrium from auxField

deriveEquilIncomp_fromIndexmus_derQuanIncomp_moduleSubroutine

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

deriveEquilIncomp_FromMacromus_derQuanIncomp_moduleSubroutine

This routine computes equilbrium from density and velocity

deriveEquilIncomp_FromMacro_d3q19mus_derQuanIncomp_moduleSubroutine

This routine computes equilbrium from density and velocity

deriveEquilIsoThermAcEq_fromAuxmus_derQuanIsothermAcEq_moduleSubroutine

This routine computes equilbrium from auxField

deriveEquilMSGasmus_derQuanMSGas_moduleSubroutine

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

deriveEquilMSGas_fromAuxmus_derQuanMSGas_moduleSubroutine

This routine computes equilbrium from auxField

deriveEquilMSGas_FromMacromus_derQuanMSGas_moduleSubroutine

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

deriveEquilMSLiquidmus_derQuanMSLiquid_moduleSubroutine

Equilibrium from density and momentum stored in auxField

deriveEquilMSLiquid_fromAuxmus_derQuanMSLiquid_moduleSubroutine

This routine computes equilbrium from auxField

deriveEquilMSLiquid_FromMacromus_derQuanMSLiquid_moduleSubroutine

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

deriveEquilNP_fromAuxmus_derQuanNernstPlanck_moduleSubroutine

This routine computes equilbrium from auxField

deriveEquilPoisson_fromAuxmus_derQuanPoisson_moduleSubroutine

This routine computes equilbrium from auxField

deriveEquilPS_fromAuxmus_derQuanPS_moduleSubroutine

This routine computes equilbrium from auxField

deriveEquilPS_FromMacromus_derQuanPS_moduleSubroutine

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

deriveEquilVelMSGasmus_derQuanMSGas_moduleSubroutine

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

deriveEquilVelMSLiquidmus_derQuanMSLiquid_moduleSubroutine

Equilibrium velocity from density and momentum in auxField.

deriveEquilVelWTDF_MSLiquidmus_derQuanMSLiquid_moduleSubroutine

Equilibrium velocity from density and momentum in auxField with thermodynamic factor

deriveEquilWTDF_MSLiquidmus_derQuanMSLiquid_moduleSubroutine

Equilibrium from density and momentum in auxField with thermodynamic factor

deriveForcePhymus_derQuanPhysics_moduleSubroutine

Compute and convert following variable force into physical units

deriveForcePhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the bnd_force of a given idx

deriveKEmus_derQuan_moduleSubroutine

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

deriveKe_fromIndexmus_derQuan_moduleSubroutine

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

deriveKeIncompmus_derQuanIncomp_moduleSubroutine

Calculate kinetic energy from velocity in auxField

deriveKeIncomp_fromIndexmus_derQuanIncomp_moduleSubroutine

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

deriveKineEnerPhymus_derQuanPhysics_moduleSubroutine

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

deriveKineEnerPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the kinetic energy of a given idx

deriveKinePressMSLiquidmus_derQuanMSLiquid_moduleSubroutine

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,

deriveKinePressPhymus_derQuanPhysics_moduleSubroutine

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

deriveKinePressPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the kinematic pressure of a given idx

deriveMassFracMSmus_derQuanMSLiquid_moduleSubroutine

mass fraction from density stored in auxField

deriveMixVelMSmus_derQuanMSLiquid_moduleSubroutine

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.

deriveMixVelMS_fromIndexmus_derQuanMSLiquid_moduleSubroutine

Calculate mixture velocity from density from species momentum

deriveMoleDensity_forElementmus_derQuanNernstPlanck_moduleSubroutine

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

deriveMoleDensity_fromIndexmus_derQuanNernstPlanck_moduleSubroutine

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

deriveMoleDensityMSmus_derQuanMSLiquid_moduleSubroutine

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)

deriveMoleDensityMS_fromIndexmus_derQuanMSLiquid_moduleSubroutine

Calculate mole density from species concentration for getValOfIndex

deriveMoleDensityPhymus_derQuanPhysics_moduleSubroutine

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

deriveMoleDensityPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the mole density of a given idx

deriveMoleFluxMSmus_derQuanMSLiquid_moduleSubroutine

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

deriveMoleFluxMS_fromIndexmus_derQuanMSLiquid_moduleSubroutine

Calculate mole flux from species momentum for getValOfIndex

deriveMoleFluxPhymus_derQuanPhysics_moduleSubroutine

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

deriveMoleFluxPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the mole flux of a given idx

deriveMoleFracMSmus_derQuanMSLiquid_moduleSubroutine

mole fraction from density stored in auxField

deriveMomentmus_derQuan_moduleSubroutine

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

deriveMomentaMSGas_FromStatemus_derQuanMSGas_moduleSubroutine

This routine computes momentum from state array

deriveMomentaMSLiquid_FromStatemus_derQuanMSLiquid_moduleSubroutine

This routine computes momentum of all species from state array

deriveMomentPhymus_derQuanPhysics_moduleSubroutine

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

deriveMomentPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the momentum of a given idx

deriveMomentummus_derQuan_moduleSubroutine

Calculate momentum from density and velocity stored in auxField

deriveMomentum_fromIndexmus_derQuan_moduleSubroutine

Calculate Momentum from density and velocity in auxField.

deriveMomentumChangemus_derQuan_moduleSubroutine
deriveMomentumIncompmus_derQuanIncomp_moduleSubroutine

Calculate momentum from velocity stored in auxField

deriveMomentumIncomp_fromIndexmus_derQuanIncomp_moduleSubroutine

Calculate Momentum from density and velocity in auxField.

deriveMomentumPhymus_derQuanPhysics_moduleSubroutine

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

deriveMomentumPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the momentum of a given idx

deriveMomMSGas_FromStatemus_derQuanMSGas_moduleSubroutine

This routine computes momentum from state array

deriveMomMSLiquid_FromStatemus_derQuanMSLiquid_moduleSubroutine

This routine computes momentum from state array

deriveNonEquilmus_derQuan_moduleSubroutine

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

deriveNonEquil_fromIndexmus_derQuan_moduleSubroutine

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

deriveNonEquilIncompmus_derQuanIncomp_moduleSubroutine

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

deriveNonEquilIncomp_fromIndexmus_derQuanIncomp_moduleSubroutine

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

derivePotential_forElementmus_derQuanPoisson_moduleSubroutine

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

derivePotential_fromIndexmus_derQuanPoisson_moduleSubroutine

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

derivePotentialPhymus_derQuanPhysics_moduleSubroutine

Calculate the potential of a given set of elements

derivePotentialPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the potential of a given idx

derivePressuremus_derQuan_moduleSubroutine

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

derivePressure_fromIndexmus_derQuan_moduleSubroutine

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

derivePressureMSmus_derQuanMSLiquid_moduleSubroutine

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

derivePressurePhymus_derQuanPhysics_moduleSubroutine

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

derivePressurePhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the pressure of a given idx

deriveQCriterionPhymus_derQuanPhysics_moduleSubroutine

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

deriveRho_FromStatemus_derQuan_moduleSubroutine

This routine computes density from state array

deriveShearMagmus_derQuan_moduleSubroutine

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

deriveShearRatemus_derQuan_moduleSubroutine

Calculate the shear rate

deriveShearStressmus_derQuan_moduleSubroutine

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

deriveSrc_chargeDensitymus_derQuanPoisson_moduleSubroutine

Calculate charge density source variable referred in config file

deriveStrainRatemus_derQuan_moduleSubroutine

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

deriveStrainRate_fromIndexmus_derQuan_moduleSubroutine

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

deriveStrainRateIncompmus_derQuanIncomp_moduleSubroutine

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

deriveStrainRateIncomp_fromIndexmus_derQuanIncomp_moduleSubroutine

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

deriveStrainRatePhymus_derQuanPhysics_moduleSubroutine

Calculate the strain rate (or called rate of strain)

deriveStrainRatePhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the strain rate of a given idx

deriveTempmus_derQuan_moduleSubroutine

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

deriveTempPhymus_derQuanPhysics_moduleSubroutine

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

deriveTempPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the temperature of a given idx

deriveVel_FromPreColStatemus_derQuan_moduleSubroutine

This routine computes velocity from pre collision state array using Fetch

deriveVel_FromStatemus_derQuan_moduleSubroutine

This routine computes velocity from state array

deriveVelIncomp_FromPreColStatemus_derQuanIncomp_moduleSubroutine

This routine computes velocity from precollision state array using FETCH macro.

deriveVelIncomp_FromStatemus_derQuanIncomp_moduleSubroutine

This routine computes velocity from state array

deriveVelIncomp_FromState_d3q19mus_derQuanIncomp_moduleSubroutine

This routine computes velocity from state array

deriveVelMSGas_FromStatemus_derQuanMSGas_moduleSubroutine

This routine computes velocity from state array

deriveVelMSLiquid_FromStatemus_derQuanMSLiquid_moduleSubroutine

This routine computes velocity from state array

deriveVelocitiesMSGas_FromStatemus_derQuanMSGas_moduleSubroutine

This routine computes velocity from state array

deriveVelocitiesMSLiquid_FromStatemus_derQuanMSLiquid_moduleSubroutine

This routine computes velocities of all species from state array

deriveVelocitymus_derQuan_moduleSubroutine

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

deriveVelocity_fromIndexmus_derQuan_moduleSubroutine

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

deriveVelocity_FromState_IsothermAcEqmus_derQuanIsothermAcEq_moduleSubroutine

This routine computes velocity from state array

deriveVelocityIncompmus_derQuanIncomp_moduleSubroutine

Calculate the velocity on given elements for incompressible model $\vec{u} = \frac{\sum(f_i c_i)}{\rho_0}$

deriveVelocityIncomp_fromIndexmus_derQuanIncomp_moduleSubroutine

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

deriveVelocityMSmus_derQuanMSLiquid_moduleSubroutine

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.

deriveVelocityMS_fromIndexmus_derQuanMSLiquid_moduleSubroutine

Calculate velocity from species density and momentum in auxField for getValOfIndex

deriveVelocityPhymus_derQuanPhysics_moduleSubroutine

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

deriveVelocityPhy_fromIndexmus_derQuanPhysics_moduleSubroutine

Calculate the velocity of a given idx

deriveViscosityPhymus_derQuanPhysics_moduleSubroutine

Convert lattice viscosity to physical viscosity

deriveWSS2Dmus_derQuan_moduleSubroutine
deriveWSS3Dmus_derQuan_moduleSubroutine

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

derPressureIsothermAcEqmus_derQuanIsothermAcEq_moduleSubroutine

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

derVelocityIsothermAcEqmus_derQuanIsothermAcEq_moduleSubroutine

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

derVelocityIsothermAcEq_fromIndexmus_derQuanIsothermAcEq_moduleSubroutine

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

do_benchmarkmus_control_moduleSubroutine
do_computeFinerIntpAndExchangemus_control_moduleSubroutine

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

do_fast_singleLevelmus_control_moduleSubroutine

Control routine for an optimized workflow with reduced functionality.

do_intpCoarserAndExchangemus_control_moduleSubroutine

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.

do_nothingmus_bc_fluid_wall_moduleSubroutine

No comment yet!

do_nothingmus_interpolate_debug_moduleSubroutine

Fill GhostFromFiner elements on my level with debug value

do_nothing_arbimus_interpolate_debug_moduleSubroutine

Fill GhostFromFiner elements on my level with debug value

do_recursive_multiLevelmus_control_moduleSubroutine

Main control routine: Update the time step for all levels. Main steps: * do BC at iLevel * do compute kernel at iLevel * do do_computeFinerIntpAndExchange at iLevel if iLevel < maxLevel * do recursive at iLevel+1 * 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

dump_bc_timingmus_tools_moduleSubroutine

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

dump_debug_infomus_debug_moduleSubroutine

Dump pdf values into debug files

dump_elemDepmus_interpolate_tools_moduleSubroutine

dump dependencies for one element

dump_FinerGhostsFromMemus_interpolate_tools_moduleSubroutine

check the dependencies from Coarser

dump_FinerGhostsFromMeBuffermus_interpolate_tools_moduleSubroutine

check the dependencies from Coarser

dump_intpListmus_interpolate_tools_moduleSubroutine

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

dump_intpListsmus_interpolate_tools_moduleSubroutine

check the dependencies from Finer

dump_level_timingmus_program_moduleSubroutine
dump_linear_partitionmus_tools_moduleSubroutine
dump_MyGhostsFromFinermus_interpolate_tools_moduleSubroutine

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

dump_timingmus_tools_moduleSubroutine

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

dumpPdfAllmus_debug_tools_moduleSubroutine

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

dumpPdfSingleElemmus_debug_tools_moduleSubroutine

write all pdf entries of a single element to the debug unit

dumpPdfSingleElemSAVEmus_debug_tools_moduleSubroutine

write all pdf entries of a single element to the debug unit with SAVE access to the state array

equilFromMacromus_derQuanMSLiquid_moduleFunction

derive equilibrium from macro

equilFromMacroWTDFmus_derQuanMSLiquid_moduleFunction

derive equilibrium from macro

equilVelFromMacromus_derQuanMSLiquid_moduleFunction

Equlibrium velocity from macro

equilVelFromMacroWTDFmus_derQuanMSLiquid_moduleFunction

Equlibrium velocity from macro with thermodynamic factor

eval_polynomial_3Dmus_interpolate_d3q19_moduleFunction
eval_polynomial_3Dmus_interpolate_d3q27_moduleFunction
feq_d3q27mus_d3q27_moduleFunction

D3Q27 equilibirium definition in product form. Given in paper: The cumulant lattice Boltzmann equation in three dimensions: Theory and validation, Martin Geier .et al, Computers and Mathematics with Applicaitons, 2015.

fill_bcBuffermus_bc_general_moduleSubroutine

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

fill_neighBuffermus_bc_general_moduleSubroutine

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

fillArbiFinerGhostsFromMe_linearmus_interpolate_linear_moduleSubroutine

Interpolate auxiliary field from coarse source to fine target

fillArbiFinerGhostsFromMe_linear2Dmus_interpolate_linear_moduleSubroutine

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

fillArbiFinerGhostsFromMe_weighAvgmus_interpolate_average_moduleSubroutine

Interpolate auxiliary field from coarse source to fine target

fillArbiMyGhostsFromFiner_avgmus_interpolate_average_moduleSubroutine

Interpolate auxiliary field from fine source to coarse target

fillCoarser_compact2DIncompmus_interpolate_d2q9_moduleSubroutine

No comment yet!

fillCoarser_compactd3q19mus_interpolate_d3q19_moduleSubroutine

No comment yet!

fillCoarser_compactd3q27mus_interpolate_d3q27_moduleSubroutine

No comment yet!

fillFiner_compact2Dmus_interpolate_d2q9_moduleSubroutine

Fill Finer ghost from Coarser fluid by 2D linear interpolation

fillFiner_compact2DIncompmus_interpolate_d2q9_moduleSubroutine

Fill Finer ghost from Coarser fluid by 2D linear interpolation

fillFiner_compactD3Q27mus_interpolate_d3q27_moduleSubroutine

Fill Finer ghost from Coarser fluid by 2D linear interpolation

Fill Finer ghost from Coarser fluid by 2D quadratic interpolation This routine serves as a HIGH order interpolation, which means every ghost should have 9 source elements. It only works for D2Q9.

fillFinerGhostsFromMe_Averagemus_interpolate_debug_moduleSubroutine

Interpolation routine that is based on a simple weighted average of source nodes

fillFinerGhostsFromMe_CopyFirstmus_interpolate_debug_moduleSubroutine

This simple method does not perform actual interpolation, but simply copies one of the source element's pdf values to the target element. It is mostly there for debugging purposes, the quality is not good enough for production use!

fillFinerGhostsFromMe_Debugmus_interpolate_debug_moduleSubroutine

Fill the ghost elements on the finer level with debug value

fillFinerGhostsFromMe_linearmus_interpolate_linear_moduleSubroutine

Fill fine ghost from coarse fluid by linear least square fit interpolation. 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 3D acoustic linear interpolation.

fillFinerGhostsFromMe_linear2Dmus_interpolate_linear_moduleSubroutine

Fill fine ghost from coarse fluid by linear interpolation. 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 3D acoustic linear interpolation.

fillFinerGhostsFromMe_linear2DIncompmus_interpolate_linear_moduleSubroutine

Fill fine ghost from coarse fluid by linear interpolation. 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 3D acoustic linear interpolation for incompressible model.

fillFinerGhostsFromMe_linearIncompmus_interpolate_linear_moduleSubroutine

Fill fine ghost from coarse fluid by linear interpolation: 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate moments (10 moms for 3D; 6 moms for 2D) 3. Store target auxilary field 4. Get viscosity on target element and compute source and target omega 5. Get nonEq scaling factor depeding on scheme layout and relaxation 6. Convert moments to PDF 7. Calculate target: Eq + Scale * nonEquilibrium This routine is used by 3D acoustic linear interpolation for incompressible model.

fillFinerGhostsFromMe_linearIncomp_2Dmus_interpolate_d2q9_moduleSubroutine

Fill Finer ghost from Coarser fluid by 2D linear interpolation

fillFinerGhostsFromMe_linearIncompLESmus_interpolate_linear_moduleSubroutine

Fill fine ghost from coarse fluid by linear interpolation. 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate moments (10 moms for 3D; 6 moms for 2D) 3. Store target auxilary field 4. Compute viscosity on target element and compute source and target omega 5. Get nonEq scaling factor depeding on scheme layout and relaxation 6. Calculate Equilibrium and nonEquilibrium 7. calculate target: Eq + Scale * nonEquilibrium This routine is used by 3D acoustic linear interpolation for incompressible LES model.

fillFinerGhostsFromMe_linearLESmus_interpolate_linear_moduleSubroutine

Fill fine ghost from coarse fluid by linear least square fit interpolation. 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 3D acoustic linear interpolation.

Fill fine ghost from coarse fluid by quadratic interpolation. 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate all moments using quadratic least square fit 3. Store target auxilary field 4. Compute viscosity on target element and compute source and target omega 5. Get nonEq scaling factor depeding on scheme layout and relaxation 6. Calculate Equilibrium and nonEquilibrium 7. calculate target: Eq + Scale * nonEquilibrium This routine is used by 3D acoustic quadratic interpolation.

Fill fine ghost from coarse fluid by quadratic interpolation. 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 3D acoustic quadratic interpolation.

Fill fine ghost from coarse fluid by quadratic interpolation. 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 3D acoustic quadratic interpolation for incompressible model.

Fill fine ghost from coarse fluid by quadratic interpolation. 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate all moments using quadratic least square fit 3. Store target auxilary field 4. Get viscosity on target element and compute source and target omega 5. Get nonEq scaling factor depeding on scheme layout and relaxation 6. Convert moments to PDF 7. Calculate target: Eq + Scale * nonEquilibrium This routine is used by 3D acoustic quadratic interpolation for incompressible model.

Fill fine ghost from coarse fluid by quadratic interpolation. 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate all moments using quadratic least square fit 3. Store target auxilary field 4. Compute viscosity on target element and compute source and target omega 5. Get nonEq scaling factor depeding on scheme layout and relaxation 6. Calculate Equilibrium and nonEquilibrium 7. Calculate target: Eq + Scale * nonEquilibrium This routine is used by 3D acoustic quadratic interpolation for incompressible LES model.

Fill fine ghost from coarse fluid by quadratic interpolation. 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate all moments using quadratic least square fit 3. Store target auxilary field 4. Compute viscosity on target element and compute source and target omega 5. Get nonEq scaling factor depeding on scheme layout and relaxation 6. Calculate Equilibrium and nonEquilibrium 7. calculate target: Eq + Scale * nonEquilibrium This routine is used by 3D acoustic quadratic interpolation.

Fill Finer Ghost elements from My Coarser element by 2D compact stencil.

Interpolation with momentum gradients from the stress tensor source points to the target position located at targetCoord. The source points are arranged in a square from (0,0,0)x(1,1,1) The order of the source points are according to the morton curve See tem_param for the explicit ordering

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 for incompressible.

fillFinerGhostsFromMe_TGV2Dmus_interpolate_debug_moduleSubroutine

This simple method does not perform actual interpolation, but get analytical solution and set pdf to target element. It is for debugging purposes, not for production use!

fillFinerGhostsFromMe_TGV3Dmus_interpolate_debug_moduleSubroutine

No comment yet!

fillFinerGhostsFromMe_weighAvgmus_interpolate_average_moduleSubroutine

Linear interpolation of ghostFromFiner

fillFinerGhostsFromMe_weighAvg2Dmus_interpolate_average_moduleSubroutine

Linear interpolation of ghostFromFiner

fillFinerGhostsFromMe_weighAvg2DIncompmus_interpolate_average_moduleSubroutine

Fill finer ghost from coarser fluid. This routine is used by 2D and 3D incomp weighted average interpolation.

fillFinerGhostsFromMe_weighAvgIncompmus_interpolate_average_moduleSubroutine

Fill finer ghost from coarser fluid: 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate all moments 3. Store target auxilary field 4. Get viscosity on target element and compute source and target omega 5. Get nonEq scaling factor depeding on scheme layout and relaxation 6. Convert moments to PDF 7. Calculate target: Eq + Scale * nonEquilibrium This routine is used by 2D and 3D acoustic weighted average interpolation for incompressible model.

fillFinerGhostsFromMe_weighAvgIncompLESmus_interpolate_average_moduleSubroutine

Fill finer ghost from coarser fluid: 1. Compute moments for all source elements, save in momBuf 2. For each target, interpolate all moments 3. Store target auxilary field 4. Compute viscosity on target element and compute source and target omega 5. Get nonEq scaling factor depeding on scheme layout and relaxation 6. Convert moments to PDF 7. Calculate target: Eq + Scale * nonEquilibrium This routine is used by 2D and 3D acoustic weighted average interpolation for incompressible LES model.

fillFinerGhostsFromMe_weighAvgLESmus_interpolate_average_moduleSubroutine

Linear interpolation of ghostFromFiner

fillHelperElementsCoarseToFinemus_flow_moduleSubroutine

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

fillHelperElementsFineToCoarsemus_flow_moduleSubroutine

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

fillMomBufmus_interpolate_tools_moduleFunction

Convert PDF of a list of elements to moment, save to buf

fillMyGhostsFromFiner_Averagemus_interpolate_debug_moduleSubroutine

Interpolation routine that is based on a simple weighted average of source nodes

fillMyGhostsFromFiner_avgmus_interpolate_average_moduleSubroutine

Average interpolation of ghostFromFiner The interpolation procedure used in this routine is:\n 1. Calculate moments from source 2. Interpolate moments on target by simple average 3. Store target auxilary field 4. Compute viscosity on target element and compute source and target omega 5. Get nonEq scaling factor depeding on scheme layout and relaxation 6. Calculate Equilibrium and nonEquilibrium 7. calculate target: Eq + Scale * nonEquilibrium

fillMyGhostsFromFiner_avg2Dmus_interpolate_average_moduleSubroutine

Fill coarse target ghost from fine source fluid by average interpolation. 1. For each target, calculate rho, vel and fNeq of its sources. 2. Average rho and vel, then calculate fEq. 3. Average fNeq and scale. 4. set target by f = fEq + fNeq This routine is used by 2D acoustic average interpolation.

fillMyGhostsFromFiner_avg2DIncompmus_interpolate_average_moduleSubroutine

Fill coarse target ghost from fine source fluid by average interpolation. 1. For each target, calculate rho, vel and fNeq of its sources. 2. Average rho and vel, then calculate fEq. 3. Average fNeq and scale. 4. set target by f = fEq + fNeq This routine is used by 2D incomp acoustic average interpolation.

fillMyGhostsFromFiner_avgIncompmus_interpolate_average_moduleSubroutine

Average interpolation of ghostFromFiner The interpolation procedure used in this routine is:\n 1. Calculate moments from source 2. Interpolate moments on target by simple average 3. Store target auxilary field 4. Get viscosity on target element and compute source and target omega 5. Get nonEq scaling factor depeding on scheme layout and relaxation 6. Calculate Equilibrium and nonEquilibrium 7. calculate target: Eq + Scale * nonEquilibrium This routine is used by 3D acoustic average interpolation for incompressible model.

fillMyGhostsFromFiner_avgIncompLESmus_interpolate_average_moduleSubroutine

Average interpolation of ghostFromFiner The interpolation procedure used in this routine is:\n 1. Calculate moments from source 2. Interpolate moments on target by simple average 3. Store target auxilary field 4. Get viscosity on target element and compute source and target omega 5. Get nonEq scaling factor depeding on scheme layout and relaxation 6. Calculate Equilibrium and nonEquilibrium 7. calculate target: Eq + Scale * nonEquilibrium This routine is used by 3D acoustic average interpolation for incompressible LES model.

fillMyGhostsFromFiner_avgLESmus_interpolate_average_moduleSubroutine

Average interpolation of ghostFromFiner The interpolation procedure used in this routine is:\n 1. calculate moments from source 2. Interpolate moments on target by simple average 3. Calculate Equilibrium and nonEquilibrium 4. calculate target: Eq + Scale * nonEquilibrium

fillMyGhostsFromFiner_CopyFirstmus_interpolate_debug_moduleSubroutine

This simple method does not perform actual interpolation, but simply copies one of the source elements pdf values to the target element. It is for DEBUG purpose, the quality is not good enough for production use!

fillMyGhostsFromFiner_Debugmus_interpolate_debug_moduleSubroutine

Fill GhostFromFiner elements on my level with debug value

Fill parent from 4 children

No comment yet!

fillMyGhostsFromFiner_TGV2Dmus_interpolate_debug_moduleSubroutine

This simple method does not perform actual interpolation, but get analytical solution and set pdf to target element It is mostly there for debugging purposes, the quality is not good enough for production use!

fillMyGhostsFromFiner_TGV3Dmus_interpolate_debug_moduleSubroutine

No comment yet!

finalize_BClistmus_construction_moduleSubroutine
find_possIntpOrderAndUpdateMySourcesmus_interpolate_moduleSubroutine

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

findDepFieldmus_derQuanMSLiquid_moduleFunction

This function find the corresponding iField of variables in varPos by comparing input_varPos of the variable against its position in derVarPos

get_auxTimemus_timer_moduleInterface
get_auxTime_atLevelmus_timer_moduleFunction
get_auxTime_totalmus_timer_moduleFunction
get_bcBufferRatiomus_timer_moduleInterface
get_bcBufferRatio_atLevelmus_timer_moduleFunction
get_bcBufferRatio_totalmus_timer_moduleFunction
get_bcBufferTimemus_timer_moduleInterface
get_bcBufferTime_atLevelmus_timer_moduleFunction
get_bcBufferTime_totalmus_timer_moduleFunction
get_boundaryRatiomus_timer_moduleFunction
get_boundaryTimemus_timer_moduleInterface
get_boundaryTime_byIDmus_timer_moduleFunction
get_boundaryTime_totalmus_timer_moduleFunction
get_communicateRatiomus_timer_moduleFunction
get_communicateTimemus_timer_moduleFunction
get_computeRatiomus_timer_moduleInterface
get_computeRatio_atLevelmus_timer_moduleFunction
get_computeRatio_totalmus_timer_moduleFunction
get_computeTimemus_timer_moduleInterface
get_computeTime_atLevelmus_timer_moduleFunction
get_computeTime_totalmus_timer_moduleFunction
get_fNeqFac_c2fmus_interpolate_tools_moduleFunction

Calculate fNeq scale factor from coarse level to(2) fine level. Such scale make sure continuuity of strain rate and shear stress over levels. To achive equal strain rate, we want: fNeq_c * omega_c / dt_c = fNeq_f * omega_f / dt_f rearrange this, we get: fNeq_f = fNeq_c * ( omega_c / omega_f ) * ( dt_f / dt_c ) dt_f/dt_c is strain rate from coarse to fine scale factor (i.e. sFac)

get_fNeqFac_f2cmus_interpolate_tools_moduleFunction

Calculate fNeq scale factor from fine level to(2) coarse level. Such scale make sure continuuity of strain rate and shear stress over levels. To achive equal strain rate, we want: fNeq_c * omega_c / dt_c = fNeq_f * omega_f / dt_f rearrange this, we get: fNeq_c = fNeq_f * ( omega_f / omega_c ) * ( dt_c / dt_f ) dt_c/dt_f is strain rate scale factor (i.e. sFac)

get_intpFromCoarserRatiomus_timer_moduleInterface
get_intpFromCoarserRatio_atLevelmus_timer_moduleFunction
get_intpFromCoarserRatio_totalmus_timer_moduleFunction
get_intpFromCoarserTimemus_timer_moduleInterface
get_intpFromCoarserTime_atLevelmus_timer_moduleFunction
get_intpFromCoarserTime_totalmus_timer_moduleFunction
get_intpFromFinerRatiomus_timer_moduleInterface
get_intpFromFinerRatio_atLevelmus_timer_moduleFunction
get_intpFromFinerRatio_totalmus_timer_moduleFunction
get_intpFromFinerTimemus_timer_moduleInterface
get_intpFromFinerTime_atLevelmus_timer_moduleFunction
get_intpFromFinerTime_totalmus_timer_moduleFunction
get_intpRatiomus_timer_moduleFunction
get_intpTimemus_timer_moduleFunction
get_mainLoopTimemus_timer_moduleFunction
get_momentmus_moments_moduleFunction

Calculate the moment of a centain order The moment of a distribution $f_i$ is defined as:\n The fucntion argument expX is array of size 3, which contains the values of \f$p, q, r\f$

get_momentVectormus_moments_moduleFunction

get the moment vector to calculate the moment from the pdf

get_polynomial_3Dmus_interpolate_d3q19_moduleSubroutine

Construct polynomial and interpolate at target position. To construct polynomial, velocity and strain rate of 4 source locations are needed: H(0,0,0), K(1,1,0), M(1,0,1), N(0,1,1)

get_polynomial_3Dmus_interpolate_d3q27_moduleSubroutine

Construct polynomial and interpolate at target position. To construct polynomial, velocity and strain rate of 4 source locations are needed: H(0,0,0), K(1,1,0), M(1,0,1), N(0,1,1)

get_relaxTimemus_timer_moduleInterface
get_relaxTime_atLevelmus_timer_moduleFunction
get_relaxTime_totalmus_timer_moduleFunction
get_stageRatiomus_timer_moduleFunction
get_stageTimemus_timer_moduleFunction
get_transport_paramsmus_transport_var_moduleFunction

Function returns transport parameter as a string to set params for transport data variable KM: Currently this function is unused but might be needed in the future if more parameters are need to set for a variable

getConversionFacmus_solSpecHelpers_moduleFunction

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

getDensitymus_derivedQuantities_module2Interface
getDensity_forElemFromStatemus_derivedQuantities_module2Function

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

getDensity_forPdfSubsetmus_derivedQuantities_module2Function

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

getEqByDensVelmus_derivedQuantities_module2Function

Calculate the equilibrium distribution function in all directions

getEqByDensVelPerDir_incompmus_derivedQuantities_module2Function

Incompressible formulation of the equilibrium for specific direction.

getEqDistrmus_derivedQuantities_module2Function

Get the equilibrium distribution in the specified direction iDir

getEquilibriummus_derivedQuantities_module2Interface
getEquilibriummus_interpolate_compact_moduleFunction

Calculate the equilibrium distribution function in all directions

getEquilibrium_forElemfromStatemus_derivedQuantities_module2Function

Calculate the equilibrium distribution function in all directions

getEquilibrium_forPdfSubsetmus_derivedQuantities_module2Function

Calculate the equilibrium distribution function in all directions

getEquilibriumIncompmus_derivedQuantities_module2Function

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

getFieldPrefixesmus_solSpecHelpers_moduleFunction

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

getFieldVariablemus_solSpecHelpers_moduleInterface
getFieldVariable_arraymus_solSpecHelpers_moduleFunction

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

getFieldVariable_scalarmus_solSpecHelpers_moduleFunction

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

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

getIdentifyCharmus_solSpecHelpers_moduleFunction

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

getMomentum_forPdfSubset_forcemus_derivedQuantities_module2Function

Calculate the momentum in all 3 directions for a subset of pdfs the subset is provided and must be of the size of DOFs per element

getNEqmus_interpolate_d3q19_moduleFunction
getNEqmus_interpolate_d2q9_moduleFunction
getNEq_acousticmus_derivedQuantities_module2Function

Setting the non-equilibrium part based on the acoustic scaling

getNEq_diffusivemus_derivedQuantities_module2Function

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

getNFieldsmus_solSpecHelpers_moduleFunction

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

getNonEqFacmus_derivedQuantities_module2Function

Calculate the conversion factor for nonEq in difference levels

getNonEqFac_intpmus_derivedQuantities_module2Function

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

getShearRatemus_derivedQuantities_module2Function

Calculate the Shear Rate

getShearRateTensor_acousticmus_derivedQuantities_module2Interface
getShearRateTensor_acoustic_forPdfSubsetmus_derivedQuantities_module2Function

Calculate the shear rate tensor (strain rate) by acoustic scaling.

getShearRateTensor_acoustic_incompmus_derivedQuantities_module2Function

This routine calculates shear rate tensor (i.e. strain rate tensor) by acoustic scaling (i.e. CE analysis)

getShearRateTensor_acoustic_lbmmus_derivedQuantities_module2Function

This routine calculates shear rate tensor (i.e. strain rate tensor) by acoustic scaling (i.e. CE analysis)

getShearRateTensor_diffusivemus_derivedQuantities_module2Interface
getShearRateTensor_diffusive_forPdfSubsetmus_derivedQuantities_module2Function

Calculate the strain rate tensor through 2nd moment. This function returns a two-dimensional 3 x 3 symmetirc array:

getShearStressPostmus_derivedQuantities_module2Function

Calculate the viscous shear stress (exclude pressure)

getShearStressTensormus_derivedQuantities_module2Interface
getShearStressTensor_forElemFromStatemus_derivedQuantities_module2Function

Calculate the viscous shear stress (exclude pressure) This function returns a one-dimensional array with 6 entries: tau(1:6) = [ Sxx, Syy, Szz, Sxy, Syz, Sxz ]

getShearStressTensor_forPdfSubsetmus_derivedQuantities_module2Function

Calculate the viscous shear stress (exclude pressure) This function returns a one-dimensional array with 6 entries: tau(1:6) = [ Sxx, Syy, Szz, Sxy, Syz, Sxz ]

getShearStressTensorIncomp_forPdfSubsetmus_derivedQuantities_module2Function

Calculate the viscous shear stress (exclude pressure) This function returns a one-dimensional array with 6 entries: tau(1:6) = [ Sxx, Syy, Szz, Sxy, Syz, Sxz ]

getStrainmus_interpolate_d3q19_moduleFunction
getStrainmus_interpolate_d2q9_moduleFunction
getStrainFacDffsmus_derivedQuantities_module2Function

Calculate the conversion factor for nonEq in difference levels

getVariable_FromTablemus_solSpecHelpers_moduleFunction

Get the value of variable inside the table name 'key' in scheme KM:

getVelocitymus_derivedQuantities_module2Interface
getVelocity_forElemFromState_Forcemus_derivedQuantities_module2Function

Calculate the velocity in all 3 directions

getVelocity_forElemFromState_noForcemus_derivedQuantities_module2Function

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.

getVelocity_forPdfSubsetmus_derivedQuantities_module2Function

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

getVelocity_forPdfSubset_incompmus_derivedQuantities_module2Function

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

getVelocity_incompmus_derivedQuantities_module2Interface
getWeightsmus_solSpecHelpers_moduleFunction

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

getWSSmus_derivedQuantities_module2Function

Calculate the wall shear stress (WSS)

getWSSmus_derQuan_moduleFunction

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

getWSS2Dmus_derivedQuantities_module2Function

Calculate the wall shear stress (WSS) 2D

getWSS_vonMisesmus_derivedQuantities_module2Function

Calculate the wall shear stress (WSS)

Choose the relaxation model

init_boundary_singlemus_bc_general_moduleSubroutine

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

Initialize compact setencil

Initialize stencil for weighted average interpolation

init_enrtl_locmus_eNRTL_moduleInterface

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

init_intpArraysPerLevelmus_interpolate_moduleSubroutine
init_levelBuffersmus_construction_moduleSubroutine

Initialize the communication buffers for a single level

init_momentsBCmus_bc_general_moduleSubroutine

Initialize the values required for the moments BC

init_nrbcmus_bc_general_moduleSubroutine

Initialize the values required for the characteristic boundary conditions

init_qValsmus_bc_general_moduleSubroutine

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.

init_recvBuffersmus_construction_moduleSubroutine

Create the communication buffers

init_sendBuffersmus_construction_moduleSubroutine

Create the communication buffers

init_transformation_matrix_fluidmus_moments_moduleSubroutine

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

init_transformation_matrix_MSmus_moments_moduleSubroutine

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

inlet_nrbcmus_bc_fluid_moduleSubroutine

Characteristic-based non-reflective inlet boundary conditions

inlet_nrbc_incompmus_bc_fluid_moduleSubroutine

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

inlet_pasScalmus_bc_passiveScalar_moduleSubroutine

Inlet boundary conditions for passive scalar transport (Flekkoy).

Dump interpolation method to logUnit

mfr_bouncebackmus_bc_fluid_moduleSubroutine

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

mfr_eqmus_bc_fluid_moduleSubroutine

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

moleDens_neumannmus_bc_nernstPlanck_moduleSubroutine

No comment yet!

moleDens_neumann_curvedmus_bc_nernstPlanck_moduleSubroutine

No comment yet!

moleDens_nonEqExpolmus_bc_nernstPlanck_moduleSubroutine

No comment yet!

moleDens_nonEqExpol_curvedmus_bc_nernstPlanck_moduleSubroutine

No comment yet!

moments_inflowmus_bc_fluid_experimental_moduleSubroutine

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

moments_outflowmus_bc_fluid_experimental_moduleSubroutine

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

moments_wallmus_bc_fluid_moduleSubroutine

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

momentumFromMacroLSEmus_derQuanMSLiquid_moduleFunction

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

momentumFromMacroLSE_WTDFmus_derQuanMSLiquid_moduleFunction

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

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

No comment yet!

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

No comment yet!

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

Semi-optimized explicit implementation

Unoptimized explicit implementation

Semi-optimized explicit implementation for incompressible model

Unoptimized explicit implementation

Unoptimized explicit implementation

Unoptimized explicit implementation

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

mrt_bgkmus_mrtRelaxation_moduleFunction

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

mrt_d2q9mus_mrtRelaxation_moduleFunction

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.

mrt_d3q15mus_mrtRelaxation_moduleFunction

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.

mrt_d3q19mus_mrtRelaxation_moduleFunction

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.

mrt_d3q27mus_mrtRelaxation_moduleFunction

This function returns mrt relaxation diagonal matrix for d3q27 layout

Loading Musubi specific abort criteria from the abort_criteria table.

mus_access_auxFieldVar_forElementmus_auxFieldVar_moduleSubroutine

Return the solver aux variable for a given set of elements

mus_access_state_forElementmus_stateVar_moduleSubroutine

Return the solver state variable for a given set of elements

mus_access_stateFetch_forElementmus_stateVar_moduleSubroutine

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

mus_access_stateFetch_now_forElementmus_stateVar_moduleSubroutine

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

mus_accessVar_setupIndicesmus_stateVar_moduleSubroutine

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

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

mus_append_auxFieldmus_variable_moduleSubroutine

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

mus_append_derLiquidMixVarmus_derQuanMSLiquid_moduleSubroutine

Append mixture variables for multicomponent liquid models

mus_append_derMixVar_MSmus_derQuanMSLiquid_moduleSubroutine

Append mixture variables for multicomponent models

mus_append_derVar_fluidmus_derQuan_moduleSubroutine

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

mus_append_derVar_fluidIncompmus_derQuanIncomp_moduleSubroutine

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

mus_append_derVar_isotherm_acEqmus_derQuanIsothermAcEq_moduleSubroutine

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

mus_append_derVar_lbmPSmus_derQuanPS_moduleSubroutine

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

mus_append_derVar_MSGasmus_derQuanMSGas_moduleSubroutine

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

mus_append_derVar_MSLiquidmus_derQuanMSLiquid_moduleSubroutine

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

mus_append_derVar_physicsmus_derQuanPhysics_moduleSubroutine

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

mus_append_derVar_poissonmus_derQuanPoisson_moduleSubroutine

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

mus_append_materialVarmus_material_var_moduleSubroutine

Append variable read from restart file as state variables

mus_append_sourceVarmus_variable_moduleSubroutine

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

mus_append_stateVarmus_variable_moduleSubroutine

Append state variable depends on the scheme kind

mus_append_turbVarmus_turbulence_var_moduleSubroutine

subroutine to add variables for turbulence model

mus_apply_sourceTermsmus_source_moduleSubroutine

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

mus_applyForce_Xmus_IBM_moduleSubroutine

This subroutine applies the force calculated to the eulerian elements.

mus_assign_calcAuxField_ptrmus_auxFieldVar_moduleSubroutine

This routine assign function pointer to compute auxField var

mus_assign_intp_nonEqScalingFacs_ptrmus_mrtRelaxation_moduleSubroutine

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

mus_assign_mrt_ptrmus_mrtRelaxation_moduleSubroutine

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.

mus_assign_nNwtnVisc_ptrmus_nonNewtonian_moduleSubroutine

This routine assigns function pointer to compute non-Newtonian viscosity

mus_assign_turbVisc_ptrmus_turb_viscosity_moduleSubroutine

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

mus_auxFieldVar_forPointmus_auxFieldVar_moduleSubroutine

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.

mus_auxFieldVar_fromIndexmus_auxFieldVar_moduleSubroutine

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

mus_bannermus_aux_moduleSubroutine

Initialize musubi solverHead and print musubi banner to screen

mus_BC_timingmus_tools_moduleSubroutine

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

mus_build_BCStencilsmus_construction_moduleSubroutine

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

mus_build_IBMStencilsmus_construction_moduleSubroutine

This routine build and append IBM stencils to scheme stencil array

mus_build_posInPropmus_geom_moduleSubroutine

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

mus_build_varSysmus_variable_moduleSubroutine

Build global variable system for Musubi

mus_buildBuffIBMmus_IBM_moduleSubroutine
mus_calc_commAmountmus_statistics_moduleSubroutine

Calculate the number of links to be communicated

mus_calc_MS_DiffMatrixmus_eNRTL_moduleInterface
mus_calc_MS_DiffMatrixmus_eNRTL_moduleInterface
mus_calc_MS_DiffMatrix_singlemus_eNRTL_moduleSubroutine

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

mus_calc_MS_DiffMatrix_singlemus_eNRTL_moduleSubroutine

Dummy routine which sets diffusivity coeff matrix to diagonal matrix

mus_calc_nElemsmus_pdf_moduleSubroutine

Compute nElems for different types

mus_calc_thermFactormus_eNRTL_moduleInterface
mus_calc_thermFactormus_eNRTL_moduleInterface
mus_calc_thermFactor_singlemus_eNRTL_moduleSubroutine

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

mus_calc_thermFactor_singlemus_eNRTL_moduleSubroutine

Dummy routine which sets thermodynamic factor matrix to diagonal matrix

mus_calcAuxField_dummymus_auxFieldVar_moduleSubroutine

Dummy routine for calcAuxField

mus_calcAuxField_fluidmus_auxFieldVar_moduleSubroutine

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

mus_calcAuxField_fluid_d2q9mus_auxFieldVar_moduleSubroutine

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

mus_calcAuxField_fluid_d3q19mus_auxFieldVar_moduleSubroutine

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

mus_calcAuxField_fluid_d3q27mus_auxFieldVar_moduleSubroutine

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

mus_calcAuxField_fluidIncompmus_auxFieldVar_moduleSubroutine

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

mus_calcAuxField_fluidIncomp_d2q9mus_auxFieldVar_moduleSubroutine

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

mus_calcAuxField_fluidIncomp_d3q19mus_auxFieldVar_moduleSubroutine

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

mus_calcAuxField_fluidIncomp_d3q27mus_auxFieldVar_moduleSubroutine

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

mus_calcAuxField_MSmus_auxFieldVar_moduleSubroutine

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.

mus_calcAuxField_nernst_planckmus_auxFieldVar_moduleSubroutine

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

mus_calcAuxField_zerothMomentmus_auxFieldVar_moduleSubroutine

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

mus_calcAuxFieldAndExchangemus_control_moduleSubroutine

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

mus_calcForce_Xmus_IBM_moduleSubroutine

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

mus_calcOmegaFromViscmus_relaxationParam_moduleFunction

This function compute relaxation paramter omega from viscosity

mus_calculate_speed_of_soundmus_scheme_layout_moduleFunction

Calculate lattice speed of sound for given stencil

mus_check_allWallmus_field_moduleFunction

Check if a BC is wall or symmetry for all fields

mus_check_omegaKinemus_relaxationParam_moduleSubroutine

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

mus_constructmus_construction_moduleSubroutine

Initialize Musubi data strucutres based on data provided by Treelm

mus_construct_connectivitymus_connectivity_moduleSubroutine

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

mus_corrForce_Xkmus_IBM_moduleSubroutine
mus_corrVel_Xmus_IBM_moduleSubroutine

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

mus_create_funcStrmus_physics_moduleSubroutine

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

mus_create_poss_srcVarmus_source_var_moduleSubroutine

Routine initialize possible source variable depends on scheme kind

mus_create_poss_transVarmus_transport_var_moduleSubroutine

Routine initialize possible transport variable depends on scheme kind

mus_define_d1q3mus_scheme_layout_moduleSubroutine

This subroutine sets the parameters for the predefined d2q9 stencil.

mus_define_d2q5mus_scheme_layout_moduleSubroutine

This subroutine sets the parameters for the predefined d2q5 stencil.

mus_define_d2q9mus_scheme_layout_moduleSubroutine

This subroutine sets the parameters for the predefined d2q9 stencil.

mus_define_d3q13mus_scheme_layout_moduleSubroutine

This subroutine sets the parameters for the predefined d3q13 stencil.

mus_define_d3q19mus_scheme_layout_moduleSubroutine

This subroutine sets the parameters for the predefined d3q19 stencil.

mus_define_d3q27mus_scheme_layout_moduleSubroutine

This subroutine sets the parameters for the predefined d3q27 stencil.

mus_define_d3q6mus_scheme_layout_moduleSubroutine

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

mus_define_d3q7mus_scheme_layout_moduleSubroutine

This subroutine sets the parameters for the predefined d3q7 stencil.

mus_define_layoutmus_scheme_layout_moduleSubroutine

This routine defines layout for predefined stencils

mus_derEquilIsothermAcEqmus_derQuanIsothermAcEq_moduleSubroutine

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

mus_derive_FromMacro_dummymus_derVarPos_moduleSubroutine
mus_derive_FromPreColState_dummymus_derVarPos_moduleSubroutine
mus_derive_FromState_dummymus_derVarPos_moduleSubroutine
mus_derivedensitymus_derQuan_moduleSubroutine

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

mus_deriveElectricFieldmus_derQuanPoisson_moduleSubroutine

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

mus_deriveEquilmus_derQuan_moduleSubroutine

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

mus_deriveEquilIncompmus_derQuanIncomp_moduleSubroutine

Calculate the equlibrium of a given element number with the given input state vector for incompressible model $\rho0 = 1.0$ $f_eq = w_\alpha*(\rho + \rho0( (u . c_i) + (u . c_i)^2 - u^2 ) )$

mus_deriveKEmus_derQuan_moduleSubroutine

Calculate the kinetic energy as E = 1/2 rho ( ux^2 + uy^2 +uz^2 )

mus_deriveKeIncompmus_derQuanIncomp_moduleSubroutine

Calculate the kinetic energy as

mus_deriveMoleDensitymus_derQuanNernstPlanck_moduleSubroutine

Calculate the potential of a given set of pdfs of elements

mus_deriveMomentmus_derQuan_moduleSubroutine

For 2D only!

mus_deriveMomentummus_derQuan_moduleSubroutine

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

mus_deriveNonEquilmus_derQuan_moduleSubroutine

Calculate the Non-Equlibrium

mus_deriveNonEquilIncompmus_derQuanIncomp_moduleSubroutine

Calculate the Non-Equlibrium

mus_derivePotentialmus_derQuanPoisson_moduleSubroutine

Calculate the potential of a given set of pdfs of elements

mus_derivePressuremus_derQuan_moduleSubroutine
mus_deriveStrainRatemus_derQuan_moduleSubroutine

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

mus_deriveStrainRateIncompmus_derQuanIncomp_moduleSubroutine

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

mus_deriveVar_forPointmus_varSys_moduleSubroutine

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.

mus_deriveVelocitymus_derQuan_moduleSubroutine

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

mus_deriveVelocityIncompmus_derQuanIncomp_moduleSubroutine

Calculate the velocity on given elements for incompressible model $\vec{u} = \frac{\sum(f_i c_i)}{\rho_0}$

mus_derVelocityIsothermAcEqmus_derQuanIsothermAcEq_moduleSubroutine

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

mus_destroy_stencilmus_scheme_layout_moduleSubroutine

Destroy the stencil

mus_dump_levelDescIntp_nElemsmus_interpolate_moduleSubroutine

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

mus_dump_momentsmus_moments_moduleSubroutine

Dump moments matrix: toPDF and toMoment

mus_dumpDatamus_aux_moduleSubroutine

This routine dumps tracking and restart when timeControl is active

mus_dumpWeightsmus_weights_moduleSubroutine

Dump weights to a file.

mus_field_cleanupmus_field_moduleSubroutine

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

mus_field_getSymmetricBCsmus_field_moduleSubroutine

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

mus_field_out_scalmus_field_moduleSubroutine

write single field into a lua file

mus_field_prop_outmus_field_prop_moduleSubroutine

write field prop into a lua file

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

mus_fields_outmus_field_moduleInterface

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

mus_fields_out_vecmus_field_moduleSubroutine

write array of fields into a lua file

mus_fillNeigh_surfDatamus_IBM_moduleSubroutine

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.

mus_finalizemus_program_moduleSubroutine

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

mus_finalize_layoutmus_scheme_layout_moduleSubroutine

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

mus_finishIBMmus_IBM_moduleSubroutine

This routine dumps the timings%timedat to disc

mus_fluid_cleanupmus_fluid_moduleSubroutine

This routines act as a destructor for fluid type

mus_fluid_dumpmus_fluid_moduleSubroutine
mus_fluid_save2luamus_fluid_moduleSubroutine

write fluid prop into a lua file

mus_free_IBMDatamus_IBM_moduleSubroutine

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

mus_generic_fromPDF_forElementmus_varSys_moduleSubroutine

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.

mus_generic_varFromPDF_fromIndexmus_varSys_moduleSubroutine

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

mus_geomIncrmus_geomIncr_moduleSubroutine

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

mus_get_new_solver_ptrmus_varSys_moduleFunction

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.

mus_get_points_fromBCmus_bc_general_moduleSubroutine

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.

mus_get_timerHandlesmus_timer_moduleFunction

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

mus_getSrcElemPosForIntpmus_connectivity_moduleSubroutine
mus_getWeightsmus_weights_moduleSubroutine

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

mus_hvs_constructmus_hvs_construction_moduleSubroutine

Initialize Musubi data strucutres based on data provided by Treelm

mus_hvs_init_auxmus_hvs_aux_moduleSubroutine

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

This routines load solver data from config file except tracking

mus_IBM_buildSendRecv_Xkmus_IBM_moduleSubroutine

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

mus_IBM_commNewPosmus_IBM_moduleSubroutine

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

mus_IBM_fillRecvPos_Xmus_IBM_moduleSubroutine
mus_IBM_fillSendPos_Xmus_IBM_moduleSubroutine
mus_IBM_getSurfVelmus_IBM_moduleSubroutine

This routine calculates the surface velocity for all local xk.

mus_IBM_prepareSendRecv_Xmus_IBM_moduleSubroutine

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.

mus_IBM_setParentIDsmus_IBM_moduleSubroutine

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

mus_IBMFinishBuffmus_IBM_moduleSubroutine

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)

mus_iMomVectormus_moments_moduleFunction

The integer moment vector for a given cxDir and order.

mus_inamuro_IBMmus_IBM_moduleSubroutine

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 .

mus_inamuroInimus_IBM_moduleSubroutine

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.

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

Initialize the relaxation model for lbm incompressible model

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

mus_init_auxmus_aux_moduleSubroutine

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

mus_init_auxFieldArraysmus_auxField_moduleSubroutine

This routine initialize auxField var val array and communication buffers

mus_init_bcTimermus_timer_moduleSubroutine
mus_init_boundarymus_bc_general_moduleSubroutine

Check prerequisite for multi-species boundary conditions

mus_init_byICmus_flow_moduleSubroutine

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

mus_init_controlmus_control_moduleSubroutine

This routines sets the function pointer to main control routine

mus_init_eNRTLmus_eNRTL_moduleFunction

This function loads property file using external c-function

mus_init_eNRTLmus_eNRTL_moduleFunction

Dummy function to init_enrtl

mus_init_flowmus_flow_moduleSubroutine

Initialize flow field depends on read restart or initial condition

mus_init_fluidmus_fluid_moduleSubroutine

This routine initilizes fluid visocity and relaxation paramters for each level

mus_init_geomIncrmus_geomIncr_moduleSubroutine

This subroutine initializes the geometry increment.

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

mus_init_IBMmus_IBM_moduleSubroutine

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.

mus_init_IBMDatamus_IBM_moduleSubroutine

This subroutine initializes all arrays in the mus_IBM_tmpData_type.

mus_init_interpolatemus_interpolate_moduleSubroutine

This subroutine initialzes the interpolation

mus_init_isotherm_acEqmus_flow_moduleSubroutine

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

mus_init_latticeUnitmus_param_moduleSubroutine

This routine initialize lattice dx and dt

mus_init_layoutmus_scheme_layout_moduleSubroutine

Initialize growing array of stencils

mus_init_levelDescIntpArraysmus_interpolate_moduleSubroutine

Initialize levelwise ghost and source list for interpolation

mus_init_levelTimermus_timer_moduleSubroutine
mus_init_longBuffersmus_comm_moduleSubroutine

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.

mus_init_mainTimermus_timer_moduleSubroutine

Timers initialization routine for whatever

mus_init_momentsmus_moments_moduleSubroutine

Initialize the moment space

mus_init_MSGasmus_flow_moduleSubroutine

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

mus_init_MSLiquidmus_flow_moduleSubroutine

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

mus_init_nernst_planckmus_flow_moduleSubroutine

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

mus_init_omegamus_flow_moduleSubroutine

This routine initialize omega values in state vector for nonNewtonian fluid

mus_init_passiveScalarmus_flow_moduleSubroutine

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

mus_init_pdfmus_flow_moduleSubroutine

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

mus_init_poissonmus_flow_moduleSubroutine

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

mus_init_relaxParammus_relaxationParam_moduleSubroutine

This routine initialize relaxation parameter

mus_init_schememus_scheme_moduleSubroutine

Initialize single scheme stencil and variable system

mus_init_sourceTermsmus_source_moduleSubroutine

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

mus_init_trackermus_tracking_moduleSubroutine

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

mus_init_transport_varmus_transport_var_moduleSubroutine

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

mus_init_turbulenceDatamus_turbulence_moduleSubroutine

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

mus_init_varSys_solverDatamus_varSys_moduleSubroutine
mus_initAuxFieldmus_flow_moduleSubroutine

This routine initialize auxField variable from initial PDF values using local IDX access for fluid elements

mus_initializemus_program_moduleSubroutine

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

mus_interpolate_Compact2dmus_interpolate_d2q9_moduleFunction

Given the velocity and strain rate (S) at four corner, interpolate the velocity at a given position (cx, cy) vel and S contain values at the following position: [0,0], [1,0], [0,1], [1,1] Checked!

mus_interpolate_linear2D_leastSqmus_interpolate_linear_moduleFunction

Bilinear interpolation for a vector quantity phi

mus_interpolate_linear3D_leastSqmus_interpolate_linear_moduleFunction

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

mus_intp_convertMomToPDF2Dmus_interpolate_tools_moduleFunction

This function computes converts moments to pdf by computing equilibrium from dens and vel and use it to compute higher moments and transform moments to PDF

mus_intp_convertMomToPDF2D_incompmus_interpolate_tools_moduleFunction

This function computes converts moments to pdf by computing equilibrium from dens and vel and use it to compute higher moments and transform moments to PDF

mus_intp_convertMomToPDF3Dmus_interpolate_tools_moduleFunction

This function computes converts moments to pdf by computing equilibrium from dens and vel and use it to compute higher moments and transform moments to PDF

mus_intp_convertMomToPDF3D_incompmus_interpolate_tools_moduleFunction

This function computes converts moments to pdf by computing equilibrium from dens and vel and use it to compute higher moments and transform moments to PDF

mus_intp_eq_d2q9_amus_interpolate_tools_moduleFunction
mus_intp_errormus_interpolate_verify_moduleSubroutine

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

mus_intp_getMomentsmus_interpolate_tools_moduleFunction

This function returns macroscopic moments from state

mus_intp_getNonEqScalingFacsmus_mrtRelaxation_moduleFunction

This function returns scaling factor for nonequilibrium moments for transformation from coarser to finer elements and vice versa. To get scaling factor to convert fine to coarse, scaleFac = 2.0 and to convert coarse to fine, scaleFac = 0.5. The order of return fac must be consistent with transformation matrix used in compute kernels

mus_intp_getSrcMomentsmus_interpolate_tools_moduleSubroutine

This routine computes moments for all sources elements in momBuf which can be accessed using depFromCoarser(iElem)%elemBuffer. In FillFiner, fine elements can have same sources so to avoid calculating moments for same source elements multiple times, momBuf is used.

mus_intp_scaleMoments2Dmus_interpolate_tools_moduleFunction

This function scales interpolated moments like density, momentum and shear stress to target level for 2D compressible model

mus_intp_scaleMoments2D_incompmus_interpolate_tools_moduleFunction

This function scales interpolated moments like density, velocity and shear stress to target level for 2D incompressible model

mus_intp_scaleMoments3Dmus_interpolate_tools_moduleFunction

This function scales interpolated moments like density, momentum and shear stress to target level for 3D compressible model

mus_intp_scaleMoments3D_incompmus_interpolate_tools_moduleFunction

This function scales interpolated moments like density, velocity and shear stress to target level for 3D incompressible model

mus_intp_update_depFromCoarsermus_interpolate_moduleSubroutine

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

mus_intp_update_depFromFinermus_interpolate_moduleSubroutine

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

mus_intpVel_Xkmus_IBM_moduleSubroutine

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

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

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. KM:

load input to solve nernst_planck equation

load a new stencil definition from the lua file

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

mus_mixture_outmus_mixture_moduleSubroutine

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

mus_nNwtn_CS_dumpmus_nonNewtonian_moduleSubroutine

Dump nonNewtonian (CY) parameters to outUnit

Read in the nonNewtonian Casson model parameters from Lua file

mus_nNwtn_CS_savemus_nonNewtonian_moduleSubroutine

write nonNewtonian Casson parameters into a lua file

mus_nNwtn_CY_dumpmus_nonNewtonian_moduleSubroutine

Dump nonNewtonian (CY) parameters to outUnit

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

mus_nNwtn_CY_savemus_nonNewtonian_moduleSubroutine

write nonNewtonian (CY) parameters into a lua file

mus_nNwtn_dump2outUnitmus_nonNewtonian_moduleSubroutine

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.

mus_nNwtn_PL_dumpmus_nonNewtonian_moduleSubroutine

Dump nonNewtonian Power Law (PL) parameters to outUnit

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

mus_nNwtn_PL_savemus_nonNewtonian_moduleSubroutine

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

mus_nNwtn_save2luamus_nonNewtonian_moduleSubroutine

write nonNewtonian fluid parameters into a lua file

mus_open_configmus_config_moduleSubroutine

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

This routine returns the velocity gradient from velocity in auxField

mus_opVar_QCriterion_forElementmus_operation_var_moduleSubroutine

This routine computes Q-criterion from velocity in auxField. , where and S are asymmetric (vorticity tensor) and symmetric (rate of strain) part of velocity gradient. i.e and .

mus_opVar_setupIndicesmus_operation_var_moduleSubroutine
mus_opVar_vorticity_forElementmus_operation_var_moduleSubroutine

This routine computes vorticity from curl of velocity in auxField.

mus_param_outmus_param_moduleSubroutine

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. Where k^2 is inverse of debye length and in this kernel refered as RHS_coeff

Advection relaxation routine for the nonlinear poisson boltzmann equation for electrolyte solution

mus_pdf_allocatemus_pdf_moduleSubroutine
mus_pdf_serializemus_buffer_moduleSubroutine

Preparation of the serialize PDF data

mus_pdf_unserializemus_buffer_moduleSubroutine

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

mus_perf_measuremus_tools_moduleSubroutine

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

Wrap up the routines required for dynamic load balancing

mus_physics_dump2outUnitmus_physics_moduleSubroutine
mus_physics_outmus_physics_moduleSubroutine

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

mus_physics_out_convmus_physics_moduleSubroutine

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. 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. The right hand side of equation is added as a source term in mus_apply_sourceTerms routine

mus_print_ppInfomus_ppInfo_moduleSubroutine

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

Read the serialized restart file into the state vectors

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

mus_reset_bcTimermus_timer_moduleSubroutine
mus_reset_levelTimermus_timer_moduleSubroutine
mus_reset_mainTimermus_timer_moduleSubroutine
mus_scheme_cleanupmus_scheme_moduleSubroutine

This subroutine acts as a destructor for the construct routine

mus_scheme_outmus_scheme_moduleSubroutine

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

mus_set_convFacmus_physics_moduleSubroutine

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.

mus_set_ic_statesmus_field_moduleSubroutine

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)

mus_set_opVar_getElementmus_operation_var_moduleSubroutine

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

mus_set_scaleFacmus_physics_moduleSubroutine
mus_set_stFun_getElementmus_varSys_moduleSubroutine

Routine to store musubi varSys Data in stFun variable

mus_set_timerHandlesmus_timer_moduleSubroutine

This routine sets mus_timerHandles passed by apesmate

mus_set_weights_d1q3mus_scheme_layout_moduleSubroutine
mus_set_weights_d2q5mus_scheme_layout_moduleSubroutine
mus_set_weights_d2q9mus_scheme_layout_moduleSubroutine
mus_set_weights_d3q13mus_scheme_layout_moduleSubroutine
mus_set_weights_d3q19mus_scheme_layout_moduleSubroutine
mus_set_weights_d3q27mus_scheme_layout_moduleSubroutine
mus_set_weights_d3q6mus_scheme_layout_moduleSubroutine
mus_set_weights_d3q7mus_scheme_layout_moduleSubroutine
mus_setPropmus_geomIncr_moduleSubroutine

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

mus_setupIndices_forBCmus_bc_general_moduleSubroutine

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

mus_setupIndices_forSrcmus_source_moduleSubroutine

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

mus_solvemus_program_moduleSubroutine

This routine does the main musubi computation loop

mus_source_cleanupmus_source_var_moduleSubroutine

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

mus_species_outmus_species_moduleSubroutine

writes species propertries into a lua file

mus_stateVar_Fetch_fromIndexmus_stateVar_moduleSubroutine

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

mus_stateVar_Fetch_now_fromIndexmus_stateVar_moduleSubroutine

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

mus_stateVar_forPointmus_stateVar_moduleSubroutine

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

mus_stateVar_fromIndexmus_stateVar_moduleSubroutine

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

mus_store_bcVarPosmus_variable_moduleSubroutine

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.

mus_store_derVarPosmus_variable_moduleSubroutine

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

mus_swap_Now_Nextmus_pdf_moduleSubroutine
mus_testInterpolationmus_interpolate_verify_moduleSubroutine

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

mus_time_homogenizemus_time_moduleSubroutine

Convert itime from restart to real time

mus_time_modulomus_time_moduleFunction

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

mus_timeControl_homogenizemus_time_moduleSubroutine

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

mus_turb_calcViscmus_turbulence_moduleSubroutine

This routine compute turbulence viscosity and stores in turbulence data type

Dummy function for turbulent viscosity from Gradu procedure

mus_turbVisc_fromPreColPDF_dummymus_turb_viscosity_moduleSubroutine

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

mus_turbVisc_Smagorinsky_fromPreColPDFmus_Smagorinsky_moduleSubroutine

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.

mus_turbVisc_Smagorinsky_fromPreColPDF_incompmus_Smagorinsky_moduleSubroutine

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

mus_turbVisc_Vreman_2Dmus_Vreman_moduleSubroutine

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

mus_turbVisc_Vreman_3Dmus_Vreman_moduleSubroutine

Calculate eddy viscosity with Vreman model for 3D stencil Fortran implementation of this model: http://www.vremanresearch.nl/Vreman_Subgridmodel_Fortran.txt \todo add reference and formula

mus_turbVisc_WALE_2Dmus_WALE_moduleSubroutine

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

mus_turbVisc_WALE_3Dmus_WALE_moduleSubroutine

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

mus_update_BcghostElemmus_construction_moduleSubroutine
mus_update_relaxParamFromViscSTfunmus_relaxationParam_moduleSubroutine

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

mus_update_relaxParamKinemus_relaxationParam_moduleSubroutine

Update kinematic relaxation parameter from viscosity and check omega

mus_update_relaxParamsmus_aux_moduleSubroutine

Set relaxation parameters for MRT

mus_update_viscKinemus_relaxationParam_moduleSubroutine

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

mus_updateConnectivity_forSymmetricBCmus_connectivity_moduleSubroutine

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

mus_weights_outmus_scheme_layout_moduleSubroutine

Dump the weights in lua format.

mus_writeRestartmus_restart_moduleSubroutine

Write the serialized buffer assembled in mus_serializeData to disk

mus_writeSolverSpecInfomus_tools_moduleSubroutine

Write solver specific info to scratch file

nonEqScalingFacs_bgk_d2q9mus_mrtRelaxation_moduleFunction

This function returns nonequilibrium scaling factor for bgk model

nonEqScalingFacs_bgk_d3q19mus_mrtRelaxation_moduleFunction

This function returns nonequilibrium scaling factor for bgk model

nonEqScalingFacs_bgk_d3q27mus_mrtRelaxation_moduleFunction

This function returns nonequilibrium scaling factor for bgk model

nonEqScalingFacs_d2q9mus_mrtRelaxation_moduleFunction

This function returns nonequilibrium scaling factor for d2q9 layout

nonEqScalingFacs_d3q15mus_mrtRelaxation_moduleFunction

This function returns nonequilibrium scaling factor for d3q15 layout

nonEqScalingFacs_d3q19mus_mrtRelaxation_moduleFunction

This function returns nonequilibrium scaling factor for d3q19 layout

nonEqScalingFacs_d3q27mus_mrtRelaxation_moduleFunction

This function returns nonequilibrium scaling factor for d3q27 layout

normalizeBCmus_construction_moduleSubroutine

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_dntmus_bc_fluid_moduleSubroutine

Outlet Pressure do-nothing boundary is the open boundary condition for incompressible model. This BC sets reference density at boundary so the background pressure should be zero. 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.

outlet_nrbcmus_bc_fluid_moduleSubroutine

Characteristic-based non-reflective open boundary conditions

outlet_nrbc_eqmus_bc_fluid_moduleSubroutine

Characteristic-based non-reflective open boundary conditions

outlet_nrbc_incompmus_bc_fluid_moduleSubroutine

Characteristic-based non-reflective open boundary conditions

outlet_pasScalmus_bc_passiveScalar_moduleSubroutine

Outlet boundary conditions for passive scalar transport (Flekkoy).

outlet_zero_prsgrdmus_bc_fluid_moduleSubroutine

Outlet boundary conditions with zero pressure gradient.

perform_checksmus_tools_moduleSubroutine

Perform run-time checks if interval is active

potential_neumannmus_bc_poisson_moduleSubroutine

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

potential_neumann_curvedmus_bc_poisson_moduleSubroutine

No comment yet!

potential_nonEqExpolmus_bc_poisson_moduleSubroutine

Linkwise Dirichlet potential non-equilibrium boundary condition for curved and straight walls. For straight wall, physical boundary overlaps with boundary node i.e. qVal=0.0.

potential_nonEqExpol_curvedmus_bc_poisson_moduleSubroutine

Linkwise Dirichlet potential non-equilibrium boundary condition for curved wall

prepare_target_elem_listmus_geomIncr_moduleSubroutine

This routine compares the macroscopic quantity obtained for an element against specified threshold and populates the list of target elements which participate in geometry change. In addition it sets the property bit(s) of target elements to fluidify in case of solidification and clears this bit in case of fluidification

press_neqmus_bc_fluid_moduleSubroutine

Pressure Non-Equilibrium type boundary conditions from Guo, Z., & Shi, B. (2002). "Non-equilibrium extrapolation method for velocity and pressure boundary conditions in the lattice Boltzmann method." Chinese Physics, (November 2016).

pressure_antiBounceBackmus_bc_fluid_moduleSubroutine

Outlet Pressure Bounce Back boundary condition

pressure_eqmus_bc_fluid_moduleSubroutine

Outlet Pressure Equilibrium type boundary conditions

pressure_expolmus_bc_fluid_moduleSubroutine

Outlet Pressure extrapolation boundary. qVal for this boundary must be 0.0

pressure_expol_slowmus_bc_fluid_experimental_moduleSubroutine

No comment yet!

pressure_momentsbasedmus_bc_fluid_moduleSubroutine

Moment based open boundary condition from Sam Bennent PhD thesis "A Lattice Boltzmann Model for Diffusion of Binary Gas Mixtures" for weakly compressible LBM model

pressure_momentsbased_incompmus_bc_fluid_moduleSubroutine

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

pressure_nonEqExpolmus_bc_fluid_nonEqExpol_moduleSubroutine

Linkwise Dirichlet pressure non-equilibrium boundary condition for straight using the subroutine "mus_set_nonEqExpol" For straight wall, values are extrapolated along boundary normal instead of along the link and qVal=0.

pressure_nonEqExpol_incompmus_bc_fluid_nonEqExpol_moduleSubroutine

Linkwise Dirichlet pressure non-equilibrium boundary condition for straight using the subroutine "mus_set_nonEqExpol" for incompressible model For straight wall, values are extrapolated along boundary normal instead of along the link and qVal=0.

pressure_nonEqExpol_mrtmus_bc_fluid_nonEqExpol_moduleSubroutine

Linkwise Dirichlet pressure non-equilibrium boundary condition for straight for mrt collision using the subroutine "mus_set_nonEqExpol"

pressure_nonEqExpol_mrt_incompmus_bc_fluid_nonEqExpol_moduleSubroutine

Linkwise Dirichlet pressure non-equilibrium boundary condition for straight for mrt collision using the subroutine "mus_set_nonEqExpol" for incompressible model

proximitymus_geomIncr_moduleSubroutine

A subroutine which checks the proximity condition and generates a new treeID list of potential target elements which can then be checked against various thresholds as defined in the lua configuration file.

It removes non-valid elements while still maintaining the origianl order. The given bc elements (elems) contains both valid and non-valid elements. Position of valid elements are given by posInBCElem. Valid elements are moved towards the start of the elems so that they become continuous in the elems.

remove_solid_in_bcmus_field_moduleSubroutine

First check count number of valid elements (non-solid) in each BC. Then rearrange BC elements list so it contains only valid elements. Update fields%bc%elemLvl%stencilPos fields%bc%elemLvl%posInNghElems accordingly.

secondMommus_derivedQuantities_module2Function

Calculate second moments of some quantity $f$ where Q is number of discrete velocity.\n The output is 1 dimentional array which has 6 componenents.\n Specifically, This function is used by shear stress and strain rate.

set_boundarymus_bc_general_moduleSubroutine

Call the functions associated with each boundary condition

Set the coefficients of bouzidi linear interpolation boundary condition.

Select the halo elements which require all links

set_momentIndicesmus_moments_moduleSubroutine

set indices for accessing the pressure, velocity and the shear from a 1d vector

set_omegasLvlmus_mixture_moduleSubroutine

Set the omegas according to the time step setting

set_pdfAcousticmus_derivedQuantities_module2Function

Calculate the distribution function in all directions by using the fEq + fNeq

set_pdfDiffusivemus_derivedQuantities_module2Function

Calculate the distribution function in all directions by using the fEq + fNeq

set_sendHaloBitsmus_construction_moduleSubroutine

set the sendHalo bit for all fluid elements which are send to remote procs

set_values_by_levelsmus_physics_moduleFunction
setFieldBCNeighmus_construction_moduleSubroutine

This routine sets field BC neigh array with position of neighbor element in the inward normal direction of boundary in the levelwise list. if valid 1st neighbor does not exist return current element position. if valid higher order neighbor does not exist return last valid neighbor

setParameters_multispeciesmus_field_moduleSubroutine

Set parameters for multispecies

setThirdOrder_diffusivemus_derivedQuantities_module2Function

Set third order for diffusive scaling (for push algorithm?!) Have a look at the initial condition file for TGV in Hasert/2013/multilevel_diffusive/ic Note that this is only for a 2d taylor green test case in the region x = y = 0:2pi with reference velocity u0 = 1

slip_wallmus_bc_fluid_wall_moduleSubroutine

slip-wall boundary condition. Slip defined by a slip factor

spc_bb_vel_testmus_bc_fluid_experimental_moduleSubroutine

species bounce back velocity boundary Usage

spc_bb_wallmus_bc_fluid_experimental_moduleSubroutine

species bounce back wall boundary Usage

spc_blackbox_mem_ionmus_bc_species_moduleSubroutine

This routine computes mole diffusion flux of the ionic species at the membrance using black box model and then mass density at the membrane boundary from mole diffusion flux. Then equilibrium is set at the boundary which is computed from mass density and velocity

spc_blackbox_mem_solventmus_bc_species_moduleSubroutine

This routine computes mole diffusion flux of the solvent at the membrance using black box model and then mass density at the membrane boundary from mole diffusion flux. Then equilibrium is set at the boundary which is computed from mass density and velocity

spc_inflowmus_bc_species_moduleSubroutine

Inflow boundary condition based on non-Equilbrium extrapolation method. Usage

spc_inletmus_bc_species_moduleSubroutine

Inlet boundary condition for defined species velocity and mole fraction Usage

spc_inlet_eqmus_bc_species_moduleSubroutine

Inlet species velocity equilibrium boundary with specified mixture averaged mass velocity and its molefraction mixture kinematic pressure is extrapolated here. Density and velocity of all fields are used to compute equilibrium Usage

spc_mole_fraction_noneq_expolmus_bc_species_moduleSubroutine

Mole fraction boundary condition for nonequilibrium extrapolation based. Default qVal=0.0. Usage

spc_moleDens_eqmus_bc_species_moduleSubroutine

Mole density boundary condition Usage

spc_moleDiff_Fluxmus_bc_species_moduleSubroutine

molar diffusion flux boundary condition Usage

spc_moleFluxmus_bc_species_moduleSubroutine

molar flux boundary condition like velocity bounce back bc type Usage

spc_moleFlux_eqmus_bc_species_moduleSubroutine

molar flux equilibrium boundary condition Usage

spc_moleFracmus_bc_species_moduleSubroutine

Mole fraction boundary condition Usage

spc_moleFrac_eqmus_bc_species_moduleSubroutine

Mole fraction boundary condition Usage

spc_moleFrac_wtdfmus_bc_species_moduleSubroutine

Mole fraction boundary condition with thermodynamic factor Usage

spc_moments_moleFluxmus_bc_species_moduleSubroutine

molar flux boundary condition like moments velocity bc type Usage

spc_moments_moleFracmus_bc_species_moduleSubroutine

Mole fraction boundary condition Usage

spc_moments_outflowmus_bc_fluid_experimental_moduleSubroutine

molar flux boundary condition like moments velocity bc type Usage

spc_moments_velmus_bc_species_moduleSubroutine

velocity boundary condition like moments velocity bc type Usage

spc_moments_wallmus_bc_species_moduleSubroutine

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

spc_outflowmus_bc_species_moduleSubroutine

Open outflow boundary condition based on nonequilibrium extrapolation method. Default qVal = 0.0 Usage

spc_outlet_eqmus_bc_species_moduleSubroutine

Outlet mixture pressure species equilibrium boundary kinematic pressure is computed from pressure species density and velocity are extrapolated Usage

spc_outlet_expolmus_bc_species_moduleSubroutine

species Outlet Pressure extrapolation boundary. NOT VERIFIED

spc_outlet_velmus_bc_species_moduleSubroutine

Outlet species velocity equilibrium boundary with specified mixture averaged mass velocity. molefraction is extrapolated here. Usage

spc_outlet_zero_prsgrdmus_bc_species_moduleSubroutine

Outlet boundary conditions with zero pressure gradient.

spc_slip_wallmus_bc_fluid_wall_moduleSubroutine

slip-wall boundary condition. Slip defined by a slip factor

spc_solvent_inflowmus_bc_species_moduleSubroutine

Inflow boundary condition for solvent based on non-Equilbrium extrapolation method. Similar to spc_velocity_noneq_expol except the mass density for solvent is enforced such that total moleDens0 is maintained. Default qVal=1.0. Usage

spc_solvent_outflowmus_bc_species_moduleSubroutine

Open outflow boundary condition for solvent based on nonequilibrium extrapolation. total moledens at boundary is enforced. method. Default qVal = 0.0 Usage

spc_vel_bbmus_bc_species_moduleSubroutine

Inlet species velocity bounce back boundary with specified mixture averaged mass velocity and its molefraction mixture kinematic pressure is extrapolated here. Usage

spc_velocity_noneq_expolmus_bc_species_moduleSubroutine

Velocity boundary condition based on non-Equilbrium extrapolation method. Default qVal=1.0. Usage

start_stageTimermus_control_moduleSubroutine
stop_stageTimermus_control_moduleSubroutine
TGV_2Dmus_interpolate_debug_moduleFunction

This routine returns the analytical solution of TGV 2D testcase for a given position and time (coord, t)

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.

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

No comment yet!

turbulent_wall_powerLaw_incompmus_bc_fluid_wall_moduleSubroutine

Power-law wall function for turbulent flow. Calculate velocity and along with that the corresponding PFD at the wall using a wall function based on the power-law. The implementation is based on the following paper: Haussmann, M. et al. (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’, Computers & Mathematics with Applications. Elsevier Ltd, 78(10), pp. 3285–3302. The main formulas used from it are mentioned in the code below.

update_BClistsmus_construction_moduleSubroutine

Update the neighbor stencil positions for the Boundaries

update_connectivitymus_geomIncr_moduleSubroutine

Construct the propagation stencil for each element

vec_fmamus_test_moduleSubroutine

Testing routine which performs fused multiplication and addtion on the state variable. The calculation is simple, so that the cost is mostly due to the data transfer through the memory interface.

vel_neqmus_bc_fluid_moduleSubroutine

Velocity Non-Equilibrium type boundary conditions from Guo, Z., & Shi, B. (2002). "Non-equilibrium extrapolation method for velocity and pressure boundary conditions in the lattice Boltzmann method." Chinese Physics, (November 2016).

velocity_bflmus_bc_fluid_moduleSubroutine

Inlet Velocity BFL rule boundary condition

velocity_bfl_incompmus_bc_fluid_moduleSubroutine

No comment yet!

velocity_bouncebackmus_bc_fluid_moduleSubroutine

Inlet Velocity Bounce Back boundary condition with qvalues for compressible flows. It is similar to velocity_bounceback except the density is extrapolated from fluid element.

velocity_bounceback_incompmus_bc_fluid_moduleSubroutine

Inlet Velocity Bounce Back boundary condition with qvalues

velocity_eqmus_bc_fluid_moduleSubroutine

Inlet Velocity Equilibrium type boundary conditions for weakly compressible lbm scheme

velocity_momentsbasedmus_bc_fluid_moduleSubroutine

Moment based velocity boundary condition for weakly compressible LBM model Based on Sam Bennent PhD thesis "A Lattice Boltzmann Model for Diffusion of Binary Gas Mixtures" Usage

velocity_momentsbased_incompmus_bc_fluid_moduleSubroutine

Moment based velocity boundary condition for incompressible LBM model Based on Sam Bennent PhD thesis "A Lattice Boltzmann Model for Diffusion of Binary Gas Mixtures" Usage

velocity_nonEqExpolmus_bc_fluid_nonEqExpol_moduleSubroutine

Linkwise Dirichlet velocity non-equilibrium boundary condition for straight using the subroutine "mus_set_nonEqExpol". For straight wall, values are extrapolated along boundary normal instead of along the link and qVal =0.0 for straight wall.

velocity_nonEqExpol_curvedmus_bc_fluid_nonEqExpol_moduleSubroutine

Linkwise Dirichlet velocity non-equilibrium boundary condition for straight using the subroutine "mus_set_nonEqExpol". For straight wall, values are extrapolated along boundary normal instead of along the link

velocity_nonEqExpol_curved_incompmus_bc_fluid_nonEqExpol_moduleSubroutine

Linkwise Dirichlet velocity non-equilibrium boundary condition for curved wal using the subroutine "mus_set_nonEqExpol" for incompressible model.

velocity_nonEqExpol_incompmus_bc_fluid_nonEqExpol_moduleSubroutine

Linkwise Dirichlet velocity non-equilibrium boundary condition for straight using the subroutine "mus_set_nonEqExpol" for incompressible model For straight wall, values are extrapolated along boundary normal instead of along the link and qVal=0.

velocity_nonEqExpol_mrtmus_bc_fluid_nonEqExpol_moduleSubroutine

Linkwise Dirichlet velocity non-equilibrium boundary condition for straight wall for mrt collision using the subroutine "mus_set_nonEqExpol".

velocity_nonEqExpol_mrt_incompmus_bc_fluid_nonEqExpol_moduleSubroutine

Linkwise Dirichlet velocity non-equilibrium boundary condition for straight for mrt collision using the subroutine "mus_set_nonEqExpol" for incompressible model. For straight wall, values are extrapolated along boundary normal instead of along the link and qVal=0.

viscPhy_CSmus_nonNewtonian_moduleFunction

nonNewtonian Casson model

viscPhy_CYmus_nonNewtonian_moduleFunction

nonNewtonian Carreau-Yasuda model

viscPhy_PLmus_nonNewtonian_moduleFunction

nonNewtonian power-law model

wall_libbmus_bc_fluid_wall_moduleSubroutine

No comment yet!