generate_embedded_ausas_navier_stokes_element Namespace Reference

Variables
bool	do_simplifications = False
	Settings explanation DIMENSION TO COMPUTE: This symbolic generator is valid for both 2D and 3D cases. More...
string	dim_to_compute = "Both"
string	linearisation = "Picard"
bool	divide_by_rho = True
bool	artificial_compressibility = True
bool	asgs_stabilization = True
string	mode = "c"
list	dim_vector = [2]
	templatefile = open("embedded_ausas_navier_stokes_cpp_template.cpp")
	Read the template file. More...
	outstring = templatefile.read()
int	nnodes = 3
int	strain_size = 3
bool	impose_partion_of_unity = False
	N
	DN
	v = DefineMatrix('v',nnodes,dim)
	Unknown fields definition. More...
	vn = DefineMatrix('vn',nnodes,dim)
	vnn = DefineMatrix('vnn',nnodes,dim)
	p = DefineVector('p',nnodes)
	pn = DefineVector('pn',nnodes)
	pnn = DefineVector('pnn',nnodes)
	w = DefineMatrix('w',nnodes,dim)
	Test functions definition. More...
	q = DefineVector('q',nnodes)
	f = DefineMatrix('f',nnodes,dim)
	Other data definitions. More...
	C = DefineSymmetricMatrix('C',strain_size,strain_size)
	Constitutive matrix definition. More...
	stress = DefineVector('stress',strain_size)
	Stress vector definition. More...
	c = sympy.Symbol('c',positive= True)
	Other simbols definition. More...
	dt = sympy.Symbol('dt', positive = True)
	rho = sympy.Symbol('rho', positive = True)
	nu = sympy.Symbol('nu', positive = True)
	mu = sympy.Symbol('mu', positive = True)
	h = sympy.Symbol('h', positive = True)
	dyn_tau = sympy.Symbol('dyn_tau', positive = True)
	stab_c1 = sympy.Symbol('stab_c1', positive = True)
	stab_c2 = sympy.Symbol('stab_c2', positive = True)
	bdf0 = sympy.Symbol('bdf0')
	Backward differences coefficients. More...
	bdf1 = sympy.Symbol('bdf1')
	bdf2 = sympy.Symbol('bdf2')
	f_gauss = f.transpose()*N
	Data interpolation to the Gauss points. More...
	v_gauss = v.transpose()*N
	vconv = DefineMatrix('vconv',nnodes,dim)
	Convective velocity definition. More...
	vmesh = DefineMatrix('vmesh',nnodes,dim)
	vconv_gauss = vconv.transpose()*N
float	vconv_gauss_norm = 0.0
	Compute the stabilization parameters. More...
float	tau1 = 1.0/((rho*dyn_tau)/dt + (stab_c2*rho*vconv_gauss_norm)/h + (stab_c1*mu)/(h*h))
	tau2 = mu + (stab_c2*rho*vconv_gauss_norm*h)/stab_c1
tuple	accel_gauss = (bdf0*v + bdf1*vn + bdf2*vnn).transpose()*N
	Compute the rest of magnitudes at the Gauss points. More...
	p_gauss = p.transpose()*N
tuple	pder_gauss = (bdf0*p + bdf1*pn + bdf2*pnn).transpose()*N
	w_gauss = w.transpose()*N
	q_gauss = q.transpose()*N
	grad_w = DfjDxi(DN,w)
	Gradients computation (fluid dynamics gradient) More...
	grad_q = DfjDxi(DN,q)
	grad_p = DfjDxi(DN,p)
	grad_v = DfjDxi(DN,v)
	grad_vconv = DfjDxi(DN,vconv)
	div_w = div(DN,w)
	div_v = div(DN,v)
	div_vconv = div(DN,vconv)
	grad_sym_v = grad_sym_voigtform(DN,v)
	grad_w_voigt = grad_sym_voigtform(DN,w)
tuple	convective_term = (vconv_gauss.transpose()*grad_v)
tuple	rv_galerkin = rho*w_gauss.transpose()*f_gauss - rho*w_gauss.transpose()*accel_gauss - rho*w_gauss.transpose()*convective_term.transpose() - grad_w_voigt.transpose()*stress + div_w*p_gauss + grad_q.transpose()*v_gauss
	Compute galerkin functional Navier-Stokes functional. More...
tuple	vel_residual = rho*f_gauss - rho*accel_gauss -rho*convective_term.transpose() - grad_p
	Stabilization functional terms Momentum conservation residual Note that the viscous stress term is dropped since linear elements are used. More...
	mas_residual = -div_v
float	vel_subscale = tau1*vel_residual
	mas_subscale = tau2*mas_residual
float	rv_stab = grad_q.transpose()*vel_subscale
tuple	rv = rv_galerkin + rv_stab
	Add the stabilization terms to the original residual terms. More...
	dofs = sympy.zeros(nnodes*(dim+1), 1)
	Define DOFs and test function vectors. More...
	testfunc = sympy.zeros(nnodes*(dim+1), 1)
	rhs = Compute_RHS(rv.copy(), testfunc, do_simplifications)
	Compute LHS and RHS For the RHS computation one wants the residual of the previous iteration (residual based formulation). More...
	rhs_out = OutputVector_CollectingFactors(rhs, "rhs", mode)
	lhs = Compute_LHS(rhs, testfunc, dofs, do_simplifications)
	lhs_out = OutputMatrix_CollectingFactors(lhs, "lhs", mode)
	out = open("embedded_ausas_navier_stokes.cpp",'w')
	Write the modified template. More...

Variable Documentation

accel_gauss

tuple generate_embedded_ausas_navier_stokes_element.accel_gauss = (bdf0*v + bdf1*vn + bdf2*vnn).transpose()*N

Compute the rest of magnitudes at the Gauss points.

artificial_compressibility

bool generate_embedded_ausas_navier_stokes_element.artificial_compressibility = True

asgs_stabilization

bool generate_embedded_ausas_navier_stokes_element.asgs_stabilization = True

bdf0

generate_embedded_ausas_navier_stokes_element.bdf0 = sympy.Symbol('bdf0')

Backward differences coefficients.

bdf1

generate_embedded_ausas_navier_stokes_element.bdf1 = sympy.Symbol('bdf1')

bdf2

generate_embedded_ausas_navier_stokes_element.bdf2 = sympy.Symbol('bdf2')

C

generate_embedded_ausas_navier_stokes_element.C = DefineSymmetricMatrix('C',strain_size,strain_size)

Constitutive matrix definition.

c

generate_embedded_ausas_navier_stokes_element.c = sympy.Symbol('c',positive= True)

Other simbols definition.

convective_term

tuple generate_embedded_ausas_navier_stokes_element.convective_term = (vconv_gauss.transpose()*grad_v)

dim_to_compute

string generate_embedded_ausas_navier_stokes_element.dim_to_compute = "Both"

dim_vector

list generate_embedded_ausas_navier_stokes_element.dim_vector = [2]

div_v

generate_embedded_ausas_navier_stokes_element.div_v = div(DN,v)

div_vconv

generate_embedded_ausas_navier_stokes_element.div_vconv = div(DN,vconv)

div_w

generate_embedded_ausas_navier_stokes_element.div_w = div(DN,w)

divide_by_rho

bool generate_embedded_ausas_navier_stokes_element.divide_by_rho = True

DN

generate_embedded_ausas_navier_stokes_element.DN

do_simplifications

bool generate_embedded_ausas_navier_stokes_element.do_simplifications = False

Settings explanation DIMENSION TO COMPUTE: This symbolic generator is valid for both 2D and 3D cases.

Since the element has been programed with a dimension template in Kratos, it is advised to set the dim_to_compute flag as "Both". In this case the generated .cpp file will contain both 2D and 3D implementations. LINEARISATION SETTINGS: FullNR considers the convective velocity as "v-vmesh", hence v is taken into account in the derivation of the LHS and RHS. Picard (a.k.a. QuasiNR) considers the convective velocity as "a", thus it is considered as a constant in the derivation of the LHS and RHS. DIVIDE BY RHO: If set to true, divides the mass conservation equation by rho in order to have a better conditioned matrix. Otherwise the original form is kept. ARTIFICIAL COMPRESSIBILITY: If set to true, the time derivative of the density is introduced in the mass conservation equation together with the state equation dp/drho=c^2 (being c the sound velocity). Besides, the velocity divergence is not considered to be 0. These assumptions add some extra terms to the usual Navier-Stokes equations that are intended to act as a soft artificial compressibility, which is controlled by the value of "c". In the derivation of the residual equations the space variations of the density are considered to be close to 0.

Symbolic generation settings

dofs

generate_embedded_ausas_navier_stokes_element.dofs = sympy.zeros(nnodes*(dim+1), 1)

Define DOFs and test function vectors.

dt

generate_embedded_ausas_navier_stokes_element.dt = sympy.Symbol('dt', positive = True)

dyn_tau

generate_embedded_ausas_navier_stokes_element.dyn_tau = sympy.Symbol('dyn_tau', positive = True)

f

generate_embedded_ausas_navier_stokes_element.f = DefineMatrix('f',nnodes,dim)

Other data definitions.

f_gauss

generate_embedded_ausas_navier_stokes_element.f_gauss = f.transpose()*N

Data interpolation to the Gauss points.

grad_p

generate_embedded_ausas_navier_stokes_element.grad_p = DfjDxi(DN,p)

grad_q

generate_embedded_ausas_navier_stokes_element.grad_q = DfjDxi(DN,q)

grad_sym_v

generate_embedded_ausas_navier_stokes_element.grad_sym_v = grad_sym_voigtform(DN,v)

grad_v

generate_embedded_ausas_navier_stokes_element.grad_v = DfjDxi(DN,v)

grad_vconv

generate_embedded_ausas_navier_stokes_element.grad_vconv = DfjDxi(DN,vconv)

grad_w

generate_embedded_ausas_navier_stokes_element.grad_w = DfjDxi(DN,w)

Gradients computation (fluid dynamics gradient)

grad_w_voigt

generate_embedded_ausas_navier_stokes_element.grad_w_voigt = grad_sym_voigtform(DN,w)

h

generate_embedded_ausas_navier_stokes_element.h = sympy.Symbol('h', positive = True)

impose_partion_of_unity

bool generate_embedded_ausas_navier_stokes_element.impose_partion_of_unity = False

lhs

generate_embedded_ausas_navier_stokes_element.lhs = Compute_LHS(rhs, testfunc, dofs, do_simplifications)

lhs_out

generate_embedded_ausas_navier_stokes_element.lhs_out = OutputMatrix_CollectingFactors(lhs, "lhs", mode)

linearisation

string generate_embedded_ausas_navier_stokes_element.linearisation = "Picard"

mas_residual

generate_embedded_ausas_navier_stokes_element.mas_residual = -div_v

mas_subscale

generate_embedded_ausas_navier_stokes_element.mas_subscale = tau2*mas_residual

mode

string generate_embedded_ausas_navier_stokes_element.mode = "c"

mu

generate_embedded_ausas_navier_stokes_element.mu = sympy.Symbol('mu', positive = True)

N

generate_embedded_ausas_navier_stokes_element.N

nnodes

int generate_embedded_ausas_navier_stokes_element.nnodes = 3

nu

generate_embedded_ausas_navier_stokes_element.nu = sympy.Symbol('nu', positive = True)

out

generate_embedded_ausas_navier_stokes_element.out = open("embedded_ausas_navier_stokes.cpp",'w')

Write the modified template.

outstring

generate_embedded_ausas_navier_stokes_element.outstring = templatefile.read()

p

generate_embedded_ausas_navier_stokes_element.p = DefineVector('p',nnodes)

p_gauss

generate_embedded_ausas_navier_stokes_element.p_gauss = p.transpose()*N

pder_gauss

tuple generate_embedded_ausas_navier_stokes_element.pder_gauss = (bdf0*p + bdf1*pn + bdf2*pnn).transpose()*N

pn

generate_embedded_ausas_navier_stokes_element.pn = DefineVector('pn',nnodes)

pnn

generate_embedded_ausas_navier_stokes_element.pnn = DefineVector('pnn',nnodes)

q

generate_embedded_ausas_navier_stokes_element.q = DefineVector('q',nnodes)

q_gauss

generate_embedded_ausas_navier_stokes_element.q_gauss = q.transpose()*N

rho

generate_embedded_ausas_navier_stokes_element.rho = sympy.Symbol('rho', positive = True)

rhs

generate_embedded_ausas_navier_stokes_element.rhs = Compute_RHS(rv.copy(), testfunc, do_simplifications)

Compute LHS and RHS For the RHS computation one wants the residual of the previous iteration (residual based formulation).

By this reason the stress is included as a symbolic variable, which is assumed to be passed as an argument from the previous iteration database.

rhs_out

generate_embedded_ausas_navier_stokes_element.rhs_out = OutputVector_CollectingFactors(rhs, "rhs", mode)

rv

tuple generate_embedded_ausas_navier_stokes_element.rv = rv_galerkin + rv_stab

Add the stabilization terms to the original residual terms.

rv_galerkin

tuple generate_embedded_ausas_navier_stokes_element.rv_galerkin = rho*w_gauss.transpose()*f_gauss - rho*w_gauss.transpose()*accel_gauss - rho*w_gauss.transpose()*convective_term.transpose() - grad_w_voigt.transpose()*stress + div_w*p_gauss + grad_q.transpose()*v_gauss

Compute galerkin functional Navier-Stokes functional.

rv_stab

float generate_embedded_ausas_navier_stokes_element.rv_stab = grad_q.transpose()*vel_subscale

stab_c1

generate_embedded_ausas_navier_stokes_element.stab_c1 = sympy.Symbol('stab_c1', positive = True)

stab_c2

generate_embedded_ausas_navier_stokes_element.stab_c2 = sympy.Symbol('stab_c2', positive = True)

strain_size

int generate_embedded_ausas_navier_stokes_element.strain_size = 3

stress

generate_embedded_ausas_navier_stokes_element.stress = DefineVector('stress',strain_size)

Stress vector definition.

tau1

float generate_embedded_ausas_navier_stokes_element.tau1 = 1.0/((rho*dyn_tau)/dt + (stab_c2*rho*vconv_gauss_norm)/h + (stab_c1*mu)/(h*h))

tau2

generate_embedded_ausas_navier_stokes_element.tau2 = mu + (stab_c2*rho*vconv_gauss_norm*h)/stab_c1

templatefile

generate_embedded_ausas_navier_stokes_element.templatefile = open("embedded_ausas_navier_stokes_cpp_template.cpp")

Read the template file.

testfunc

generate_embedded_ausas_navier_stokes_element.testfunc = sympy.zeros(nnodes*(dim+1), 1)

v

generate_embedded_ausas_navier_stokes_element.v = DefineMatrix('v',nnodes,dim)

Unknown fields definition.

v_gauss

generate_embedded_ausas_navier_stokes_element.v_gauss = v.transpose()*N

vconv

generate_embedded_ausas_navier_stokes_element.vconv = DefineMatrix('vconv',nnodes,dim)

Convective velocity definition.

vconv_gauss

generate_embedded_ausas_navier_stokes_element.vconv_gauss = vconv.transpose()*N

vconv_gauss_norm

generate_embedded_ausas_navier_stokes_element.vconv_gauss_norm = 0.0

Compute the stabilization parameters.

vel_residual

tuple generate_embedded_ausas_navier_stokes_element.vel_residual = rho*f_gauss - rho*accel_gauss -rho*convective_term.transpose() - grad_p

Stabilization functional terms Momentum conservation residual Note that the viscous stress term is dropped since linear elements are used.

vel_subscale

float generate_embedded_ausas_navier_stokes_element.vel_subscale = tau1*vel_residual

vmesh

generate_embedded_ausas_navier_stokes_element.vmesh = DefineMatrix('vmesh',nnodes,dim)

vn

generate_embedded_ausas_navier_stokes_element.vn = DefineMatrix('vn',nnodes,dim)

vnn

generate_embedded_ausas_navier_stokes_element.vnn = DefineMatrix('vnn',nnodes,dim)

w

generate_embedded_ausas_navier_stokes_element.w = DefineMatrix('w',nnodes,dim)

Test functions definition.

w_gauss

generate_embedded_ausas_navier_stokes_element.w_gauss = w.transpose()*N