SyFi
0.3
|
00001 #!/usr/bin/env python 00002 00003 __authors__ = "Martin Sandve Alnes" 00004 __date__ = "2008-09-04 -- 2012-05-16" 00005 00006 import unittest 00007 import os, sys, glob, shutil, commands 00008 00009 import ufl 00010 00011 from ufl import FiniteElement 00012 from ufl import VectorElement 00013 from ufl import TensorElement 00014 from ufl import MixedElement 00015 00016 from ufl import Argument 00017 from ufl import TestFunction 00018 from ufl import TrialFunction 00019 00020 from ufl import Coefficient 00021 from ufl import Constant 00022 00023 from ufl import dx, ds 00024 from ufl.common import product 00025 00026 import SyFi 00027 import sfc 00028 import numpy 00029 00030 from test_tempdir_base import TempDirTestBase 00031 from cell_assembly import assemble_on_cell, cell2volume, num_integrals 00032 00033 simplices = (ufl.interval, ufl.triangle, ufl.tetrahedron) 00034 quads = (ufl.quadrilateral, ufl.hexahedron) 00035 00036 from sfc.geometry.sfc_cell import SFCCell 00037 from sfc.representation import GeometryRepresentation 00038 from sfc.representation.geometryrepresentation import create_syfi_polygon 00039 from sfc.codegeneration.geometrycg import GeometryCG 00040 00041 try: 00042 from uflacs.codeutils.format_code_structure import format_code_structure 00043 except: 00044 def format_code_structure(x): return str(x) 00045 00046 class GeometryCodeGenTest(unittest.TestCase): 00047 def test_geometry_representation_interval(self): 00048 ufl_cell = ufl.interval 00049 00050 SyFi.initSyFi(ufl_cell.d) 00051 00052 geomrep = GeometryRepresentation(ufl_cell.domain()) 00053 geomcg = GeometryCG(geomrep) 00054 decl = geomcg.generate_declarations(cellvolume=True, 00055 circumradius=True, 00056 cellsurfacearea=True, 00057 facetarea=True, 00058 facetnormal=True) 00059 00060 self.assertTrue(decl) 00061 if 1: 00062 print 00063 print ufl_cell 00064 print format_code_structure(decl) 00065 print 00066 00067 def test_geometry_representation_triangle(self): 00068 ufl_cell = ufl.triangle 00069 00070 SyFi.initSyFi(ufl_cell.d) 00071 00072 geomrep = GeometryRepresentation(ufl_cell.domain()) 00073 geomcg = GeometryCG(geomrep) 00074 decl = geomcg.generate_declarations(cellvolume=True, 00075 circumradius=True, 00076 cellsurfacearea=True, 00077 facetarea=True, 00078 facetnormal=True) 00079 00080 self.assertTrue(decl) 00081 if 1: 00082 print 00083 print ufl_cell 00084 print format_code_structure(decl) 00085 print 00086 00087 def test_geometry_representation_tetrahedron(self): 00088 ufl_cell = ufl.tetrahedron 00089 00090 SyFi.initSyFi(ufl_cell.d) 00091 00092 geomrep = GeometryRepresentation(ufl_cell.domain()) 00093 geomcg = GeometryCG(geomrep) 00094 decl = geomcg.generate_declarations(cellvolume=True, 00095 circumradius=True, 00096 cellsurfacearea=True, 00097 facetarea=True, 00098 facetnormal=True) 00099 00100 self.assertTrue(decl) 00101 if 1: 00102 print 00103 print ufl_cell 00104 print format_code_structure(decl) 00105 print 00106 00107 def xtest_geometry_representation_quadrilateral(self): 00108 ufl_cell = ufl.quadrilateral 00109 def xtest_geometry_representation_hexahedron(self): 00110 ufl_cell = ufl.hexahedron 00111 00112 00113 class GeometryTestMixin(object): 00114 00115 def assertAlmostEqualNumpy(self, actual, expected, eps=1e-8): 00116 self.assertEqual(actual.shape, expected.shape) 00117 mdiff = expected - actual 00118 vdiff = mdiff.reshape((product(mdiff.shape),)) 00119 sdiff = numpy.dot(vdiff,vdiff) 00120 self.assertAlmostEqual(sdiff, 0.0, eps) 00121 00122 def assertAssembledAlmostEqual(self, ufl_form, ufl_cell, coeffs, expected): 00123 """Test that the integral of 1.0 over a unit cell 00124 equals the length/area/volume of the unit cell.""" 00125 ufc_form, module, formdata, prefix = sfc.jit(ufl_form, parameters=self.options) 00126 assembled = assemble_on_cell(ufc_form, ufl_cell, coeffs=coeffs) 00127 if isinstance(assembled, float): 00128 self.assertAlmostEqual(assembled, expected) 00129 else: 00130 self.assertAlmostEqualNumpy(assembled, expected) 00131 00132 def _test_constant(self, cell): 00133 """Test that the integral of 1.0 over a unit cell 00134 equals the length/area/volume of the unit cell.""" 00135 D = cell2volume[cell] 00136 c = Constant(cell) 00137 a = c*dx 00138 coeffs = [1.2] 00139 expected = 1.2 * D 00140 self.assertAssembledAlmostEqual(a, cell, coeffs, expected) 00141 00142 def test_constant_interval(self): 00143 self._test_constant(ufl.interval) 00144 def test_constant_triangle(self): 00145 self._test_constant(ufl.triangle) 00146 def test_constant_tetrahedron(self): 00147 self._test_constant(ufl.tetrahedron) 00148 00149 def _test_volume(self, cell): 00150 D = cell2volume[cell] 00151 c = cell.volume 00152 a = c*dx 00153 coeffs = [] 00154 expected = D * D 00155 self.assertAssembledAlmostEqual(a, cell, coeffs, expected) 00156 00157 def test_volume_interval(self): 00158 self._test_volume(ufl.interval) 00159 def test_volume_triangle(self): 00160 self._test_volume(ufl.triangle) 00161 def test_volume_tetrahedron(self): 00162 self._test_volume(ufl.tetrahedron) 00163 00164 def xtest_volume_quadrilateral(self): # TODO: Not supported by dolfin yet 00165 self._test_volume(ufl.quadrilateral) 00166 def xtest_volume_hexahedron(self): # TODO: Not supported by dolfin yet 00167 self._test_volume(ufl.hexahedron) 00168 00169 def _test_coordinates(self, cell, expected): 00170 x = cell.x 00171 if cell.d == 1: 00172 a = (x**2)*dx 00173 if cell.d == 2: 00174 a = (x[0]**2+x[1]**2)*dx 00175 if cell.d == 3: 00176 a = (x[0]**2+x[1]**2+x[2]**2)*dx 00177 coeffs = [] 00178 self.assertAssembledAlmostEqual(a, cell, coeffs, expected) 00179 00180 def test_coordinates_interval(self): 00181 self._test_coordinates(ufl.interval, 1.0/3.0) 00182 def test_coordinates_triangle(self): 00183 self._test_coordinates(ufl.triangle, 1.0/6.0) 00184 def test_coordinates_tetrahedron(self): 00185 self._test_coordinates(ufl.tetrahedron, 1.0/20.0) 00186 00187 def xtest_coordinates_quadrilateral(self): # TODO: Not supported by dolfin yet 00188 self._test_coordinates(ufl.quadrilateral, 2.0/3.0) # FIXME 00189 def xtest_coordinates_hexahedron(self): # TODO: Not supported by dolfin yet 00190 self._test_coordinates(ufl.hexahedron, 3.0/3.0) # FIXME 00191 00192 # Testing x, detG, D (through 1.0*dx), vol 00193 # FIXME: test GinvT (through grad), facet_D (through 1.0*ds), n, rad, surf, area 00194 00195 00196 if 0: # FIXME: Disabled to make buildbot green... 00197 class UflacsGeometryTest(TempDirTestBase, GeometryTestMixin): 00198 def __init__(self, *args, **kwargs): 00199 TempDirTestBase.__init__(self, *args, **kwargs) 00200 00201 def setUp(self): 00202 TempDirTestBase.setUp(self) 00203 self.options.code.integral.integration_method = "quadrature" 00204 self.set_uflacs_options() 00205 00206 def set_uflacs_options(self): 00207 try: 00208 import uflacs 00209 self.options.code.integral.use_uflacs = True 00210 except: 00211 print "UFLACS NOT AVAILABLE" 00212 00213 if 0: # FIXME: Disabled to make buildbot green... 00214 class SfcQuadratureGeometryTest(TempDirTestBase, GeometryTestMixin): 00215 def __init__(self, *args, **kwargs): 00216 TempDirTestBase.__init__(self, *args, **kwargs) 00217 00218 def setUp(self): 00219 TempDirTestBase.setUp(self) 00220 self.options.code.integral.integration_method = "quadrature" 00221 00222 if 0: # FIXME: Disabled to make buildbot green... 00223 class SfcSymbolicGeometryTest(TempDirTestBase, GeometryTestMixin): 00224 def __init__(self, *args, **kwargs): 00225 TempDirTestBase.__init__(self, *args, **kwargs) 00226 00227 def setUp(self): 00228 TempDirTestBase.setUp(self) 00229 self.options.code.integral.integration_method = "symbolic"