.. Documentation for the header file dolfin/adaptivity/adapt.h

.. _programmers_reference_cpp_adaptivity_adapt:

adapt.h
=======

.. note::
    
    The documentation on this page was automatically extracted from the
    DOLFIN C++ code and may need to be edited or expanded.
    



.. cpp:function:: std::shared_ptr<Mesh> adapt(const Mesh& mesh)

    Refine mesh uniformly
    @param[in] mesh (Mesh)
      Input mesh
    @return std::shared_ptr<Mesh> adapted mesh


.. cpp:function:: std::shared_ptr<Mesh> adapt(const Mesh& mesh, const MeshFunction<bool>& cell_markers)

    Refine mesh based on cell markers
    @param[in] mesh (Mesh)
      Input mesh
    @param[in] cell_markers (MeshFunction<bool>)
      Markers denoting cells to be refined


.. cpp:function:: std::shared_ptr<FunctionSpace> adapt(const FunctionSpace& space)

    Refine function space uniformly
    @param[in] space (FunctionSpace)
    @return FunctionSpace


.. cpp:function:: std::shared_ptr<FunctionSpace> adapt(const FunctionSpace& space, const MeshFunction<bool>& cell_markers)

    Refine function space based on cell markers
    @param[in] space (FunctionSpace&)
    @param[in] cell_markers (MehsFunction<bool>&)
    @return FunctionSpace


.. cpp:function:: std::shared_ptr<FunctionSpace> adapt(const FunctionSpace& space, std::shared_ptr<const Mesh> adapted_mesh)

    Refine function space based on refined mesh
    @param[in] space (FunctionSpace&)
    @param[in] adapted_mesh (std::sahred_ptr<const Mesh>)
    @return FunctionSpace


.. cpp:function:: std::shared_ptr<Function> adapt(const Function& function, std::shared_ptr<const Mesh> adapted_mesh, bool interpolate=true)

    Adapt Function based on adapted mesh
    
    @param[in] function (Function&)
            The function that should be adapted
    @param[in] adapted_mesh (std::shared_ptr<const Mesh>)
            The new mesh
    @param[in] interpolate (bool)
            Optional argument, default is true. If false, the
            function's function space is adapted, but the values are
            not interpolated.
    
    @return :cpp:class:`Function`
            The adapted function


.. cpp:function:: std::shared_ptr<GenericFunction> adapt(std::shared_ptr<const GenericFunction> function, std::shared_ptr<const Mesh> adapted_mesh)

    Refine GenericFunction based on refined mesh
    
    @param[in] function (GeericFunction)
            The function that should be adapted
    @param[in] adapted_mesh (Mehs)
            The new mesh
    
    @return :cpp:class:`GenericFunction`
            The adapted function


.. cpp:function:: std::shared_ptr<MeshFunction<std::size_t>> adapt(const MeshFunction<std::size_t>& mesh_function, std::shared_ptr<const Mesh> adapted_mesh)

    Refine mesh function<std::size_t> based on mesh


.. cpp:function:: std::shared_ptr<DirichletBC> adapt(const DirichletBC& bc, std::shared_ptr<const Mesh> adapted_mesh, const FunctionSpace& S)

    Refine Dirichlet bc based on refined mesh


.. cpp:function:: void adapt_markers(std::vector<std::size_t>& refined_markers, const Mesh& adapted_mesh, const std::vector<std::size_t>& markers, const Mesh& mesh)

    Helper function for refinement of boundary conditions


.. cpp:function:: std::shared_ptr<Form> adapt(const Form& form, std::shared_ptr<const Mesh> adapted_mesh, bool adapt_coefficients=true)

    Adapt form based on adapted mesh
    
    @param[in] form  (:cpp:class:`Form`)
            The form that should be adapted
    @param[in] adapted_mesh  (:cpp:class:`Mesh`)
            The new mesh
    @param[in] adapt_coefficients (bool)
            Optional argument, default is true. If false, the form
            coefficients are not explicitly adapted, but pre-adapted
            coefficients will be transferred.
    
    @return  :cpp:class:`Form`
            The adapted form


.. cpp:function:: std::shared_ptr<LinearVariationalProblem> adapt(const LinearVariationalProblem& problem, std::shared_ptr<const Mesh> adapted_mesh)

    Refine linear variational problem based on mesh


.. cpp:function:: std::shared_ptr<NonlinearVariationalProblem> adapt(const NonlinearVariationalProblem& problem, std::shared_ptr<const Mesh> adapted_mesh)

    Refine nonlinear variational problem based on mesh


.. cpp:function:: std::shared_ptr<ErrorControl> adapt(const ErrorControl& ec, std::shared_ptr<const Mesh> adapted_mesh, bool adapt_coefficients=true)

    Adapt error control object based on adapted mesh
    
    @param  ec  (:cpp:class:`ErrorControl`)
            The error control object to be adapted
    @param  adapted_mesh  (:cpp:class:`Mesh`)
            The new mesh
    @param  adapt_coefficients (bool)
            Optional argument, default is true. If false, any form
            coefficients are not explicitly adapted, but pre-adapted
            coefficients will be transferred.
    
    @return :cpp:class:`ErrorControl`
            The adapted error control object