def __init__(self, mesh, element, constrained_domain=None): """Create function space on given mesh for given finite element. *Arguments* mesh A :py:class:`Mesh <dolfin.cpp.Mesh>` element A :py:class:`(UFL) FiniteElement <ufl.FiniteElementBase>` """ # Store reference to constrained domain to avoid possible SWIG # director memory error (see # https://bitbucket.org/fenics-project/dolfin/issue/71) self.constrained_domain = constrained_domain # Check arguments if not isinstance(mesh, (cpp.Mesh, cpp.Restriction)): cpp.dolfin_error( "functionspace.py", "create function space", "Illegal argument, not a mesh or restriction: " + str(mesh)) if not isinstance(element, (ufl.FiniteElementBase)): cpp.dolfin_error( "functionspace.py", "create function space", "Illegal argument, not a finite element: " + str(element)) if constrained_domain is not None: if not isinstance(constrained_domain, cpp.SubDomain): cpp.dolfin_error( "functionspace.py", "create function space", "Illegal argument, not a subdomain: " + str(constrained_domain)) # Store element Note: self._ufl_element cannot be a private # attribute as we want to be able to set the element from a # derived class. self._ufl_element = element # JIT-compile element to get ufc_element and ufc_dofmap ufc_element, ufc_dofmap = jit(self._ufl_element, mpi_comm=mesh.mpi_comm()) # Instantiate DOLFIN FiniteElement and DofMap self._dolfin_element = cpp.FiniteElement(ufc_element) if constrained_domain is not None: if isinstance(mesh, cpp.Restriction): cpp.dolfin_error( "functionspace.py", "create function space", "Cannot use constrained domains together with restrictions." ) dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh, constrained_domain) else: if isinstance(mesh, cpp.Restriction): dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh) mesh = mesh.mesh() else: dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh) # Initialize the cpp_FunctionSpace cpp.FunctionSpace.__init__(self, mesh, self._dolfin_element, dolfin_dofmap)
def __init__(self, mesh, element, constrained_domain=None): """Create function space on given mesh for given finite element. *Arguments* mesh A :py:class:`Mesh <dolfin.cpp.Mesh>` element A :py:class:`(UFL) FiniteElement <ufl.FiniteElementBase>` """ # Store reference to constrained domain to avoid possible SWIG # director memory error (see # https://bitbucket.org/fenics-project/dolfin/issue/71) self.constrained_domain = constrained_domain # Check arguments if not isinstance(mesh, (cpp.Mesh, cpp.Restriction)): cpp.dolfin_error("functionspace.py", "create function space", "Illegal argument, not a mesh or restriction: " + str(mesh)) if not isinstance(element, (ufl.FiniteElementBase)): cpp.dolfin_error("functionspace.py", "create function space", "Illegal argument, not a finite element: " + str(element)) if constrained_domain is not None: if not isinstance(constrained_domain, cpp.SubDomain): cpp.dolfin_error("functionspace.py", "create function space", "Illegal argument, not a subdomain: " + str(constrained_domain)) # Store element Note: self._ufl_element cannot be a private # attribute as we want to be able to set the element from a # derived class. self._ufl_element = element # JIT-compile element to get ufc_element and ufc_dofmap ufc_element, ufc_dofmap = jit(self._ufl_element, mpi_comm=mesh.mpi_comm()) # Instantiate DOLFIN FiniteElement and DofMap self._dolfin_element = cpp.FiniteElement(ufc_element) if constrained_domain is not None: if isinstance(mesh, cpp.Restriction): cpp.dolfin_error("functionspace.py", "create function space", "Cannot use constrained domains together with restrictions.") dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh, constrained_domain) else: if isinstance(mesh, cpp.Restriction): dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh) mesh = mesh.mesh() else: dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh) # Initialize the cpp_FunctionSpace cpp.FunctionSpace.__init__(self, mesh, self._dolfin_element, dolfin_dofmap)
def __init__(self, mesh, element, constrained_domain=None): """Create function space on given mesh for given finite element. *Arguments* mesh A :py:class:`Mesh <dolfin.cpp.Mesh>` element A :py:class:`(UFL) FiniteElement <ufl.FiniteElementBase>` """ # Check arguments if not isinstance(mesh, (cpp.Mesh, cpp.Restriction)): cpp.dolfin_error("functionspace.py", "create function space", "Illegal argument, not a mesh or restriction: " + str(mesh)) if not isinstance(element, (ufl.FiniteElementBase)): cpp.dolfin_error("functionspace.py", "create function space", "Illegal argument, not a finite element: " + str(element)) if constrained_domain is not None: if not isinstance(constrained_domain, cpp.SubDomain): cpp.dolfin_error("functionspace.py", "create function space", "Illegal argument, not a subdomain: " + str(constrained_domain)) # Store element # Note: self._ufl_element cannot be a private attribute as we want to be able to # set the element from a derived class. self._ufl_element = element # JIT-compile element to get ufc_element and ufc_dofmap ufc_element, ufc_dofmap = jit(self._ufl_element) # Instantiate DOLFIN FiniteElement and DofMap self._dolfin_element = cpp.FiniteElement(ufc_element) if constrained_domain is not None: if isinstance(mesh, cpp.Restriction): cpp.dolfin_error("functionspace.py", "create function space", "Cannot use constrained domains together with restrictions.") dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh, constrained_domain) else: if isinstance(mesh, cpp.Restriction): dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh) mesh = mesh.mesh() else: dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh) # Initialize the cpp_FunctionSpace cpp.FunctionSpace.__init__(self, mesh, self._dolfin_element, dolfin_dofmap)
def __init__(self, mesh, element, constrained_domain=None): """Create function space on given mesh for given finite element. *Arguments* mesh A :py:class:`Mesh <dolfin.cpp.Mesh>` element A :py:class:`(UFL) FiniteElement <ufl.FiniteElementBase>` """ # Check arguments if not isinstance(mesh, (cpp.Mesh, cpp.Restriction)): cpp.dolfin_error("functionspace.py", "create function space", "Illegal argument, not a mesh or restriction: " + str(mesh)) if not isinstance(element, (ufl.FiniteElementBase)): cpp.dolfin_error("functionspace.py", "create function space", "Illegal argument, not a finite element: " + str(element)) if constrained_domain is not None: if not isinstance(constrained_domain, cpp.SubDomain): cpp.dolfin_error("functionspace.py", "create function space", "Illegal argument, not a subdomain: " + str(constrained_domain)) # Store element # Note: self._element cannot be a private attribute as we want to be able to # set the element from a derived class. self._ufl_element = element # JIT-compile element to get ufc_element and ufc_dofmap ufc_element, ufc_dofmap = jit(self._ufl_element) # Instantiate DOLFIN FiniteElement and DofMap self._dolfin_element = cpp.FiniteElement(ufc_element) if constrained_domain is not None: if isinstance(mesh, cpp.Restriction): cpp.dolfin_error("functionspace.py", "create function space", "Cannot use constrained domains together with restrictions.") dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh, constrained_domain) else: if isinstance(mesh, cpp.Restriction): dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh) mesh = mesh.mesh() else: dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh) # Initialize the cpp_FunctionSpace cpp.FunctionSpace.__init__(self, mesh, self._dolfin_element, dolfin_dofmap)
def __init__(self, form, function_spaces=None, coefficients=None, subdomains=None, form_compiler_parameters=None, common_cell=None): "Create JIT-compiled form from any given form (compiled or not)." # Check form argument if isinstance(form, ufl.Form): self._compiled_form, module, self.form_data, prefix \ = jit(form, form_compiler_parameters, common_cell) elif isinstance(form, ufc.form): self._compiled_form = form self.form_data = None elif isinstance(form, cpp.Form): self._compiled_form = form._compiled_form self.form_data = form.form_data else: cpp.dolfin_error("form.py", "creating dolfin.Form", "Expected a ufl.Form, ufc.form or a dolfin.Form") # Extract function spaces self.function_spaces = _extract_function_spaces(self.form_data, self._compiled_form, function_spaces) # Extract coefficients (self.coefficients, self._compiled_coefficients) = \ _extract_coefficients(self.form_data, coefficients) # Initialize base class cpp.Form.__init__(self, self._compiled_form, self.function_spaces, self.coefficients) # Extract subdomains from form_data, override if given explicitly self.subdomains = _extract_subdomains(self.form_data, subdomains) # Attach subdomains if we have them subdomains = self.subdomains.get("cell") if subdomains is not None: self.set_cell_domains(subdomains) subdomains = self.subdomains.get("exterior_facet") if subdomains is not None: self.set_exterior_facet_domains(subdomains) subdomains = self.subdomains.get("interior_facet") if subdomains is not None: self.set_interior_facet_domains(subdomains)
def _compile_dolfin_element(element, mesh, constrained_domain=None): "Instantiate DOLFIN FiniteElement and DofMap from ufl element." # JIT-compile element to get ufc_element and ufc_dofmap ufc_element, ufc_dofmap = jit(element, mpi_comm=mesh.mpi_comm()) dolfin_element = cpp.FiniteElement(ufc_element) if constrained_domain is None: dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh) else: dolfin_dofmap = cpp.DofMap(ufc_dofmap, mesh, constrained_domain) return dolfin_element, dolfin_dofmap
def __init__(self, form, form_compiler_parameters=None, function_spaces=None): "Create JIT-compiled form from any given form (compiled or not)." # Developer note: The function_spaces argument is used to # handle forms defined on multimesh function spaces. These are # really defined over a standard function space (the first of # the spaces) then later recreated on each function space part # and added together to form a multimesh form. This happens in # the function assemble_multimesh. # Check form argument if not isinstance(form, ufl.Form): cpp.dolfin_error("form.py", "creating dolfin.Form", "Expected a ufl.Form.") # Cutoff for better error message than ffc would give if not form.empty() and not form.ufl_domains(): cpp.dolfin_error( "form.py", "creating dolfin.Form", "The ufl.Form does not include any reference to a mesh.") # Extract subdomain data. # Until the assembler and ufc has multimesh support, # we impose the limitation of a single domain at this point. sd = form.subdomain_data() if len(sd) != 1: cpp.dolfin_error( "form.py", "creating dolfin.Form", "Expecting subdomain data for a single domain only.") self.subdomains, = list(sd.values()) # Assuming single domain domain, = list(sd.keys()) # Assuming single domain mesh = domain.ufl_cargo() # Having a mesh in the form is now a strict requirement if mesh is None: cpp.dolfin_error("form.py", "creating dolfin.Form", "Expecting to find a Mesh in the form.") # Jit the module, this will take some time... jit_result = jit(form, form_compiler_parameters, mpi_comm=mesh.mpi_comm()) if jit_result is None: cpp.dolfin_error("form.py", "creating dolfin.Form", "jit failure.") self._compiled_form, module, prefix = jit_result # Extract function spaces of form arguments if function_spaces is None: self.function_spaces = [ func.function_space() for func in form.arguments() ] else: self.function_spaces = function_spaces # Type checking argument function_spaces if not all( isinstance(fs, cpp.FunctionSpace) for fs in self.function_spaces): raise ValueError(function_space_error + " Invalid type of test spaces.") # Initialize base class cpp.Form.__init__(self, self._compiled_form, self.function_spaces) # Type checking argument function_spaces #r = self._compiled_form.rank() #if len(self.function_spaces) != r: # raise ValueError(function_space_error + # " Wrong number of test spaces (should be %d)." % r) # Extract coefficients from form (pass only the ones that # the compiled form actually uses to the assembler) original_coefficients = form.coefficients() self.coefficients = [] for i in range(self.num_coefficients()): j = self.original_coefficient_position(i) self.coefficients.append(original_coefficients[j]) # Type checking coefficients if not all( isinstance(c, (cpp.GenericFunction, cpp.MultiMeshFunction)) for c in self.coefficients): # Developer note: # The form accepts a MultiMeshFunction but does not set the # correct coefficients. This is done in assemble_multimesh # at the moment coefficient_error = "Error while extracting coefficients. " raise TypeError(coefficient_error + "Either provide a dict of cpp.GenericFunctions, " + "or use Function to define your form.") for i in range(self.num_coefficients()): if isinstance(self.coefficients[i], cpp.GenericFunction): self.set_coefficient(i, self.coefficients[i]) # Attach mesh (because function spaces and coefficients may be # empty lists) if not function_spaces: self.set_mesh(mesh) # Type checking subdomain data # Delete None entries for k in list(self.subdomains.keys()): if self.subdomains[k] is None: del self.subdomains[k] # Check that we have no additional subdomain data (user # misspelling) # TODO: Get from ufl list? integral_types = ("cell", "exterior_facet", "interior_facet", "vertex") additional_keys = set(self.subdomains.keys()) - set(integral_types) if additional_keys: cpp.warning("Invalid keys in subdomains: %s" % additional_keys) # Check that we have only MeshFunctions for data in list(self.subdomains.values()): if not (data is None or isinstance(data, MeshFunctionSizet)): cpp.warning( "Invalid subdomain data type %s, expecting a MeshFunction" % type(data)) # Attach subdomains to C++ Form if we have them subdomains = self.subdomains.get("cell") if subdomains is not None: self.set_cell_domains(subdomains) subdomains = self.subdomains.get("exterior_facet") if subdomains is not None: self.set_exterior_facet_domains(subdomains) subdomains = self.subdomains.get("interior_facet") if subdomains is not None: self.set_interior_facet_domains(subdomains) subdomains = self.subdomains.get("vertex") if subdomains is not None: self.set_vertex_domains(subdomains)
def __init__(self, form, function_spaces=None, coefficients=None, subdomains=None, form_compiler_parameters=None, common_cell=None, # deprecated mesh=None): "Create JIT-compiled form from any given form (compiled or not)." # Check form argument if isinstance(form, ufl.Form): # Complete form with domain before sending to jit common_domain = get_common_domain(mesh, common_cell) if common_domain is not None: form = replace_integral_domains(form, common_domain) if not form.empty(): assert form.domains(), "Expecting a completed form with domains at this point." self._compiled_form, module, self.form_data, prefix \ = jit(form, form_compiler_parameters) # If we got no mesh, try to get mesh from domain data, # to handle e.g. assemble(1*dx(mesh)) if mesh is None: fd = form.form_data() domains = fd.preprocessed_form.domains() if len(domains) == 1: # Note: mesh here could still be None, depends on what the user did mesh = domains[0].data() elif isinstance(form, ufc.form): self._compiled_form = form self.form_data = None elif isinstance(form, cpp.Form): self._compiled_form = form._compiled_form self.form_data = form.form_data else: cpp.dolfin_error("form.py", "creating dolfin.Form", "Expected a ufl.Form, ufc.form or a dolfin.Form") # Extract function spaces self.function_spaces = _extract_function_spaces(self.form_data, self._compiled_form, function_spaces) # Extract coefficients (self.coefficients, self._compiled_coefficients) = \ _extract_coefficients(self.form_data, coefficients) # Initialize base class cpp.Form.__init__(self, self._compiled_form, self.function_spaces, self.coefficients) # Extract subdomains from form_data, override if given explicitly self.subdomains = _extract_subdomains(self.form_data, subdomains) # Attach subdomains if we have them subdomains = self.subdomains.get("cell") if subdomains is not None: self.set_cell_domains(subdomains) subdomains = self.subdomains.get("exterior_facet") if subdomains is not None: self.set_exterior_facet_domains(subdomains) subdomains = self.subdomains.get("interior_facet") if subdomains is not None: self.set_interior_facet_domains(subdomains) # Set mesh if specified (important for functionals without a function spaces) if mesh is not None: self.set_mesh(mesh)
def __init__(self, form, form_compiler_parameters=None): "Create JIT-compiled form from any given form (compiled or not)." # Check form argument if not isinstance(form, ufl.Form): cpp.dolfin_error("form.py", "creating dolfin.Form", "Expected a ufl.Form.") # Cutoff for better error message than ffc would give if not form.empty() and not form.domains(): cpp.dolfin_error("form.py", "creating dolfin.Form", "The ufl.Form does not include any reference to a mesh.") # Extract subdomain data. # Until the assembler and ufc has multimesh support, # we impose the limitation of a single domain at this point. sd = form.subdomain_data() if len(sd) != 1: cpp.dolfin_error("form.py", "creating dolfin.Form", "Expecting subdomain data for a single domain only.") self.subdomains, = list(sd.values()) # Assuming single domain domain, = list(sd.keys()) # Assuming single domain mesh = domain.data() # Having a mesh in the form is now a strict requirement if mesh is None: cpp.dolfin_error("form.py", "creating dolfin.Form", "Expecting to find a Mesh in the form.") # Jit the module, this will take some time... self._compiled_form, module, prefix \ = jit(form, form_compiler_parameters, mpi_comm=mesh.mpi_comm()) # Extract function spaces of form arguments self.function_spaces = [func.function_space() for func in form.arguments()] # Extract coefficients from form (pass only the ones that # the compiled form actually uses to the assembler) original_coefficients = form.coefficients() self.coefficients = [] for i in range(self._compiled_form.num_coefficients()): j = self._compiled_form.original_coefficient_position(i) self.coefficients.append(original_coefficients[j]) # Type checking argument function_spaces r = self._compiled_form.rank() if len(self.function_spaces) != r: raise ValueError(function_space_error + " Wrong number of test spaces (should be %d)." % r) if not all(isinstance(fs, cpp.FunctionSpace) for fs in self.function_spaces): raise ValueError(function_space_error + " Invalid type of test spaces.") # Type checking coefficients if not all(isinstance(c, cpp.GenericFunction) for c in self.coefficients): coefficient_error = "Error while extracting coefficients. " raise TypeError(coefficient_error + "Either provide a dict of cpp.GenericFunctions, " + "or use Function to define your form.") # Initialize base class cpp.Form.__init__(self, self._compiled_form, self.function_spaces, self.coefficients) # Attach mesh (because function spaces and coefficients may be empty lists) self.set_mesh(mesh) # Type checking subdomain data # Delete None entries for k in list(self.subdomains.keys()): if self.subdomains[k] is None: del self.subdomains[k] # Check that we have no additional subdomain data (user misspelling) # TODO: Get from ufl list? integral_types = ("cell", "exterior_facet", "interior_facet", "vertex") additional_keys = set(self.subdomains.keys()) - set(integral_types) if additional_keys: cpp.warning("Invalid keys in subdomains: %s" % additional_keys) # Check that we have only MeshFunctions for data in list(self.subdomains.values()): if not (data is None or isinstance(data, MeshFunctionSizet)): cpp.warning("Invalid subdomain data type %s, expecting a MeshFunction" % type(data)) # Attach subdomains to C++ Form if we have them subdomains = self.subdomains.get("cell") if subdomains is not None: self.set_cell_domains(subdomains) subdomains = self.subdomains.get("exterior_facet") if subdomains is not None: self.set_exterior_facet_domains(subdomains) subdomains = self.subdomains.get("interior_facet") if subdomains is not None: self.set_interior_facet_domains(subdomains) subdomains = self.subdomains.get("vertex") if subdomains is not None: self.set_vertex_domains(subdomains)
def __init__( self, form, function_spaces=None, coefficients=None, subdomains=None, form_compiler_parameters=None, common_cell=None, # deprecated mesh=None): "Create JIT-compiled form from any given form (compiled or not)." # Check form argument if isinstance(form, ufl.Form): # Complete form with domain before sending to jit common_domain = get_common_domain(mesh, common_cell) if common_domain is not None: form = replace_integral_domains(form, common_domain) if not form.empty(): assert form.domains( ), "Expecting a completed form with domains at this point." self._compiled_form, module, self.form_data, prefix \ = jit(form, form_compiler_parameters) # If we got no mesh, try to get mesh from domain data, # to handle e.g. assemble(1*dx(mesh)) if mesh is None: fd = form.form_data() domains = fd.preprocessed_form.domains() if len(domains) == 1: # Note: mesh here could still be None, depends on what the user did mesh = domains[0].data() elif isinstance(form, ufc.form): self._compiled_form = form self.form_data = None elif isinstance(form, cpp.Form): self._compiled_form = form._compiled_form self.form_data = form.form_data else: cpp.dolfin_error("form.py", "creating dolfin.Form", "Expected a ufl.Form, ufc.form or a dolfin.Form") # Extract function spaces self.function_spaces = _extract_function_spaces( self.form_data, self._compiled_form, function_spaces) # Extract coefficients (self.coefficients, self._compiled_coefficients) = \ _extract_coefficients(self.form_data, coefficients) # Initialize base class cpp.Form.__init__(self, self._compiled_form, self.function_spaces, self.coefficients) # Extract subdomains from form_data, override if given explicitly self.subdomains = _extract_subdomains(self.form_data, subdomains) # Attach subdomains if we have them subdomains = self.subdomains.get("cell") if subdomains is not None: self.set_cell_domains(subdomains) subdomains = self.subdomains.get("exterior_facet") if subdomains is not None: self.set_exterior_facet_domains(subdomains) subdomains = self.subdomains.get("interior_facet") if subdomains is not None: self.set_interior_facet_domains(subdomains) # Set mesh if specified (important for functionals without a function spaces) if mesh is not None: self.set_mesh(mesh)
def __init__(self, form, form_compiler_parameters=None, subdomains=None): "Create JIT-compiled form from any given form (compiled or not)." # Check form argument if isinstance(form, ufl.Form): # Cutoff for better error message than ffc would give if not form.empty() and not form.domains(): raise RuntimeError("Expecting a completed form with domains at this point.") # Extract subdomain data sd = form.subdomain_data() if len(sd) != 1: # Until the assembler and ufc has multimesh support, we impose this limitation raise RuntimeError("Expecting subdomain data for a single domain only.") if subdomains is None: self.subdomains, = list(sd.values()) # Assuming single domain domain, = list(sd.keys()) # Assuming single domain mesh = domain.data() # Jit the module, this will take some time... self._compiled_form, module, prefix \ = jit(form, form_compiler_parameters, mpi_comm=mesh.mpi_comm()) # Extract function spaces of form arguments self.function_spaces = [func.function_space() for func in form.arguments()] # Extract coefficients from form (pass only the ones that the compiled form actually uses to the assembler) original_coefficients = form.coefficients() self.coefficients = [original_coefficients[self._compiled_form.original_coefficient_position(i)] for i in range(self._compiled_form.num_coefficients())] elif isinstance(form, cpp.Form): cpp.deprecation("Passing a cpp.Form to dolfin.Form constructor", "1.3.0", "1.4.0", "Passing a cpp.Form to dolfin.Form constructor" " will be removed.") self._compiled_form = form._compiled_form self.function_spaces = form.function_spaces self.coefficients = form.coefficients self.subdomains = form.subdomains mesh = form.mesh() else: cpp.dolfin_error("form.py", "creating dolfin.Form", "Expected a ufl.Form or a dolfin.Form") # This is now a strict requirement if mesh is None: raise RuntimeError("Expecting to find a Mesh in the form.") # Type checking argument function_spaces r = self._compiled_form.rank() if len(self.function_spaces) != r: raise ValueError(function_space_error + " Wrong number of test spaces (should be %d)." % r) if not all(isinstance(fs, cpp.FunctionSpace) for fs in self.function_spaces): raise ValueError(function_space_error + " Invalid type of test spaces.") # Type checking coefficients if not all(isinstance(c, cpp.GenericFunction) for c in self.coefficients): coefficient_error = "Error while extracting coefficients. " raise TypeError(coefficient_error + "Either provide a dict of cpp.GenericFunctions, " + "or use Function to define your form.") # Type checking subdomain data # Check that we have no additional subdomain data (user misspelling) # TODO: Get from ufl list? integral_types = ("cell", "exterior_facet", "interior_facet", "point") for k in list(self.subdomains.keys()): if self.subdomains[k] is None: del self.subdomains[k] additional_keys = set(self.subdomains.keys()) - set(integral_types) if additional_keys: cpp.warning("Invalid keys in subdomains: %s" % additional_keys) # Check that we have only MeshFunctions for data in list(self.subdomains.values()): # TODO: This wasn't here before, disable if it's too restrictive: if not (data is None or isinstance(data, MeshFunctionSizet)): cpp.warning("Invalid subdomain data type %s, expecting a MeshFunction" % type(data)) # Initialize base class cpp.Form.__init__(self, self._compiled_form, self.function_spaces, self.coefficients) # Attach subdomains if we have them subdomains = self.subdomains.get("cell") if subdomains is not None: self.set_cell_domains(subdomains) subdomains = self.subdomains.get("exterior_facet") if subdomains is not None: self.set_exterior_facet_domains(subdomains) subdomains = self.subdomains.get("interior_facet") if subdomains is not None: self.set_interior_facet_domains(subdomains) subdomains = self.subdomains.get("point") if subdomains is not None: self.set_vertex_domains(subdomains) # Attach mesh self.set_mesh(mesh)