Homec4science
Diffusion CADD_mesher (master) Browse

rCADDMESH/test/py_wrapper_test.py.cmake
cfac30bd70a4master

Last Change
Raw File

py_wrapper_test.py.cmake
View Options

#!/usr/bin/env python
from __future__ import print_function
from __future__ import division
import sys
sys.path.append('@CADD_MESH_PY_BUILD_PATH@')
import math
from CADDMesher import *
error_counter = 0
def vector_test():
a = vecReal([1,2,3,4,5])
#print("vector a = [{0}]".format(", ".join([str(item) for item in a])))
return False
def fcc_lattice_test():
consts = vecReal([1, 3, 4])
miller = vecReal([1, 0, 0,
0, 0, 1,
0, 1, 0])
lattice = FccLattice2d(consts, miller)
rep_const = lattice.getRepresentativeConstant()
ref_val = 3**(1/2)
if rep_const != ref_val:
raise Exception(
"Representative Constant wrong: it's {0} but should be {1}\n".format(
rep_const, ref_val) +
"difference = {0}".format(ref_val - rep_const))
return False
def block_test():
b = Block2d([0,1,0,2], 'chicken')
return False
def PointRef_test():
b = PointRef2d(vecReal([1,2]))
c = PointRef3d(vecReal([1,2,3]))
d = PointRef2d(b)
return False
def PointContainer_test():
b = PointRef2d(vecReal([1,2]))
cont = PointContainer2d("MonkeyContainer")
cont.addPoint(b)
cont.addPoint(vecReal([12.4, 15.2, 83.1]))
point = cont.getPoint(0)
return False
def Mesh_test():
lim = 32
points = list()
nodal_vals = list()
for i in range(lim+1):
for j in range(lim+1):
points.append(i/lim)
points.append(j/lim)
nodal_vals.append((i+j)/lim)
minmax = [.45, 10.6,
.45, .55]
exclude = Block2d(minmax, "excludes some stuff")
minmax = [.4, 10.6,
.4, .6]
atomic = Block2d(minmax, "atomistic domain")
mesh = Mesh2d(points, exclude)
mesh.delaunay(1000)
mesh.cleanup(atomic)
mesh.dump_paraview("after_cleanup_2D_python")
return False
def Domain_test():
consts = vecReal([4.04, 4.04])
miller = vecReal([ 1., 1., -1., 1.])
lattice = FccLattice2d(consts, miller)
## print("Lattice = {0}".format(lattice))
# Prepare the domain geometries
min_max = vecReal([-200, 200, -300, 0])
overall = Block2d(min_max, "overall");
min_max = vecReal([-25, 25, -35, 0])
refined = Block2d(min_max, "refined")
min_max = vecReal([-20, 20, -30, 0])
atomistic = Block2d(min_max, "atomistic")
min_max = vecReal([-19, 19, -29, 0])
atomistic_skinned = Block2d(min_max, "atomistic_skinned")
# Create domain
domain = Domain2d(overall, refined, atomistic, atomistic_skinned,
lattice, True)
refinement_point = PointRef2d()
punkte = PointContainer2d("just for debugging")
# set up auxiliary mesh
for i in range(2):
for k in range(2):
refinement_point[0] = (1-2*i)*201
refinement_point[1] = -(k * 301 - (1-k))
refinement = float(8);
domain.setPointRefinement(refinement_point, refinement)
punkte.addPoint(refinement_point)
refinement_point[0] = (1-2*i)*25
refinement_point[1] = -(k * 35 - (1-k))
refinement = 0.;
domain.setPointRefinement(refinement_point, refinement)
punkte.addPoint(refinement_point)
refinement_point[0] = (1-2*i)*100
refinement_point[1] = -(k * 130 - (1-k))
refinement = 4.;
domain.setPointRefinement(refinement_point, refinement)
punkte.addPoint(refinement_point)
## print(punkte)
testmesh = Mesh2d(punkte.getVector())
## print("Test mesh before delaunay = \n{0}".format(testmesh))
testmesh.delaunay(10000);
testmesh.initInterpolation()
## print("Test mesh = \n{0}".format(testmesh))
domain.fill_points();
print("Number of tree boxes = {0}".format(domain.getTree().getNbBoxes()))
domain.getMesh().dump_paraview("domain_test_output_2d_python")
print("domain.getPoint() : \n{0}".format(doman.getPoints()))
return False
def Domain_test_3d():
consts = vecReal([4.04, 4.04, 4.04])
miller = vecReal([ 1, 1, 0,
-1, 1, 0,
0, 0, 1])
lattice = FccLattice3d(consts, miller)
# Prepare the domain geometries
min_max = vecReal([-200, 200, -200, 200, -300, 0])
overall = Block3d(min_max, "overall");
min_max = vecReal([-25, 25, -25, 25, -35, 0])
refined = Block3d(min_max, "refined")
min_max = vecReal([-20, 20, -20, 20, -30, 0])
atomistic = Block3d(min_max, "atomistic")
min_max = vecReal([-19.9, 19.9, -19.9, 19.9, -29.9, 0])
atomistic_skinned = Block3d(min_max, "atomistic_skinned")
# Create domain
domain = Domain3d(overall, refined, atomistic, atomistic_skinned,
lattice, True)
refinement_point = PointRef3d()
# set up auxiliary mesh
for i in range(2):
for j in range(2):
for k in range(2):
refinement_point[0] = (1-2*i)*201
refinement_point[1] = (1-2*j)*201
refinement_point[2] = -(k * 301 - (1-k))
print(refinement_point)
refinement = float(8);
domain.setPointRefinement(refinement_point, refinement)
refinement_point[0] = (1-2*i)*25
refinement_point[1] = (1-2*j)*25
refinement_point[2] = -(k * 35 - (1-k))
refinement = 0.;
domain.setPointRefinement(refinement_point, refinement)
refinement_point[0] = (1-2*i)*100
refinement_point[1] = (1-2*j)*100
refinement_point[2] = -(k * 130 - (1-k))
refinement = 4.;
domain.setPointRefinement(refinement_point, refinement)
domain.fill_points();
print("Number of tree boxes = {0}".format(domain.getTree().getNbBoxes()))
return False
def tester(function, *args, **kwargs):
try:
ret_val = function(*args, **kwargs)
print("Test '{0}' passed".format(function.__name__))
if ret_val != False:
raise Exception("Test '{0}' gave return code '{1}'".format(
function.__name__, ret_val))
return False
except Exception as err:
global error_counter
error_counter += 1
indented_message = '\n'.join(
[" " + line for line in err.message.split('\n')])
print("!!!!! error number {0}".format(error_counter))
print("Test '{0}' failed with the following error:\n{1}".format(
function.__name__, indented_message))
return True
def main():
overall_failure = False
overall_failure |= tester(vector_test)
overall_failure |= tester(fcc_lattice_test)
overall_failure |= tester(block_test)
overall_failure |= tester(PointRef_test)
overall_failure |= tester(PointContainer_test)
overall_failure |= tester(Mesh_test)
overall_failure |= tester(Domain_test)
if not overall_failure:
print("\nOverall sucess. All tests passed.")
else:
print("\nOverall failure, some tests failed!")
main()
c4science · Help