SyFi  0.3
test_geometry_code.py
Go to the documentation of this file.
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"
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines