edgebased_PureConvection Namespace Reference

Functions
def	BenchmarkCheck (time, model_part)

Variables
	domain_size = edgebased_var.domain_size
string	kratos_benchmarking_path = '../../../../benchmarking'
	fluid_model_part = ModelPart("FluidPart")
	input_file_name = edgebased_var.problem_name
	gid_mode = GiDPostMode.GiD_PostBinary
	multifile = MultiFileFlag.SingleFile
	deformed_mesh_flag = WriteDeformedMeshFlag.WriteUndeformed
	write_conditions = WriteConditionsFlag.WriteConditions
	gid_io = GidIO(input_file_name, gid_mode, multifile, deformed_mesh_flag, write_conditions)
	model_part_io_fluid = ModelPartIO(input_file_name)
int	number_of_avg_elems = 10
int	number_of_avg_nodes = 10
	neighbour_search = FindNodalNeighboursProcess(fluid_model_part)
	vel = Vector(3);
float	xc = 1.00 / 6.00
float	yc = 1.00 / 6.00
float	sigma = 0.2
tuple	X1 = (node.X - xc) / sigma
tuple	X2 = (node.Y - yc) / sigma
float	dist = 0.25 * (1.00 + math.cos(math.pi * X1)) * (1.00+math.cos(math.pi*X2))
	matrix_container = MatrixContainer2D()
	convection_solver = PureConvectionEdgeBased2D(matrix_container, fluid_model_part)
	max_Dt = edgebased_var.max_time_step
float	initial_Dt = 0.001 * max_Dt
	final_time = edgebased_var.max_time
	output_dt = edgebased_var.output_dt
	safety_factor = edgebased_var.safety_factor
	number_of_inital_steps = edgebased_var.number_of_inital_steps
	initial_time_step = edgebased_var.initial_time_step
int	out = 0
	ProcessInfo = fluid_model_part.ProcessInfo
float	mesh_name = 0.0
	max_safety_factor = safety_factor
float	time = 0.0
int	step = 0
	next_output_time = output_dt
	Dt = ProcessInfo[DELTA_TIME]

Function Documentation

BenchmarkCheck()

def edgebased_PureConvection.BenchmarkCheck	(		time,
			model_part
	)

Variable Documentation

convection_solver

edgebased_PureConvection.convection_solver = PureConvectionEdgeBased2D(matrix_container, fluid_model_part)

deformed_mesh_flag

edgebased_PureConvection.deformed_mesh_flag = WriteDeformedMeshFlag.WriteUndeformed

dist

float edgebased_PureConvection.dist = 0.25 * (1.00 + math.cos(math.pi * X1)) * (1.00+math.cos(math.pi*X2))

domain_size

edgebased_PureConvection.domain_size = edgebased_var.domain_size

Dt

edgebased_PureConvection.Dt = ProcessInfo[DELTA_TIME]

final_time

edgebased_PureConvection.final_time = edgebased_var.max_time

fluid_model_part

edgebased_PureConvection.fluid_model_part = ModelPart("FluidPart")

gid_io

edgebased_PureConvection.gid_io = GidIO(input_file_name, gid_mode, multifile, deformed_mesh_flag, write_conditions)

gid_mode

edgebased_PureConvection.gid_mode = GiDPostMode.GiD_PostBinary

initial_Dt

float edgebased_PureConvection.initial_Dt = 0.001 * max_Dt

initial_time_step

edgebased_PureConvection.initial_time_step = edgebased_var.initial_time_step

input_file_name

edgebased_PureConvection.input_file_name = edgebased_var.problem_name

kratos_benchmarking_path

string edgebased_PureConvection.kratos_benchmarking_path = '../../../../benchmarking'

matrix_container

edgebased_PureConvection.matrix_container = MatrixContainer2D()

max_Dt

edgebased_PureConvection.max_Dt = edgebased_var.max_time_step

max_safety_factor

edgebased_PureConvection.max_safety_factor = safety_factor

mesh_name

float edgebased_PureConvection.mesh_name = 0.0

model_part_io_fluid

edgebased_PureConvection.model_part_io_fluid = ModelPartIO(input_file_name)

multifile

edgebased_PureConvection.multifile = MultiFileFlag.SingleFile

neighbour_search

edgebased_PureConvection.neighbour_search = FindNodalNeighboursProcess(fluid_model_part)

next_output_time

float edgebased_PureConvection.next_output_time = output_dt

number_of_avg_elems

int edgebased_PureConvection.number_of_avg_elems = 10

number_of_avg_nodes

int edgebased_PureConvection.number_of_avg_nodes = 10

number_of_inital_steps

edgebased_PureConvection.number_of_inital_steps = edgebased_var.number_of_inital_steps

out

int edgebased_PureConvection.out = 0

output_dt

edgebased_PureConvection.output_dt = edgebased_var.output_dt

ProcessInfo

edgebased_PureConvection.ProcessInfo = fluid_model_part.ProcessInfo

safety_factor

edgebased_PureConvection.safety_factor = edgebased_var.safety_factor

sigma

float edgebased_PureConvection.sigma = 0.2

step

int edgebased_PureConvection.step = 0

time

float edgebased_PureConvection.time = 0.0

vel

edgebased_PureConvection.vel = Vector(3);

write_conditions

edgebased_PureConvection.write_conditions = WriteConditionsFlag.WriteConditions

X1

tuple edgebased_PureConvection.X1 = (node.X - xc) / sigma

X2

tuple edgebased_PureConvection.X2 = (node.Y - yc) / sigma

xc

float edgebased_PureConvection.xc = 1.00 / 6.00

yc

float edgebased_PureConvection.yc = 1.00 / 6.00