def df(self, semi_implicit=False): """ Returns derivative of the double-well potential as a function of two scalar variables :math:`d^f = d^f(c, c_0)`. The first argument corresponds to order parameter @ CTL, while the second one to order parameter @ PTL. Fully-implicit expression of the derivative, that is :math:`d^f(c, c_0) = \\frac{df}{dc}(c)` is returned by default. However, for higher order temporal discretizations, it can be convenient to work with semi-implicit approximation of the derivative :math:`d^f(c, c_0) = \\frac{f(c) - f(c_0)}{c - c_0}`. :param semi_implicit: if true then semi-implicit approximation of the derivative is returned :type semi_implicit: bool :returns: (approximation of) derivative of the double-well potential :rtype: function """ # FIXME: computation of df could be automated # from dolfin import conditional, eq # df_full = lambda c, c0: df(c) # df_semi = lambda c, c0: \ # conditional(eq(c, c0), df(c), (f(c) - f(c0))/(c - c0)) not_implemented_msg(self)
def load_ic_from_file(self, filenames): """ .. todo:: add possibility to load IC from HDF5 files :param filenames: list of HDF5 files :type filenames: list """ not_implemented_msg(self)
def f(self): """ Returns the double-well potential represented as a function of one scalar variable. :returns: double-well potential :rtype: function """ not_implemented_msg(self)
def load_ic_from_simple_cpp(self, ic): """ An abstract method. Update solution functions on the closest previous time level with values stored in ``ic``. :param ic: initial conditions collected within a special class designed for the purpose of loading them at this point :type ic: :py:class:`muflon.functions.iconds.SimpleCppIC` """ not_implemented_msg(self)
def setup(self): """ An abstract method. When creating a new class by subclassing this generic class, one must override this method in such a way that it sets attributes * ``_solution_ctl`` * ``_solution_ptl`` * ``_fit_primitives`` * ``_ndofs`` to the new class. The first two attributes represent vectors of solution functions at current and previous time levels respectively, while the third attribute must be a callable function with the following signature: .. code-block:: python def _fit_primitives(vec, deepcopy=False, indexed=True): \"\"\" Split/collect components of 'vec' (solution/test/trial fcns) to fit the vector of primitive variables. \"\"\" pass # need to be implemented The last attribute represents a dictionary with keys listed `here`__. __ list_dof_keys_ Each item contains number of degrees of freedom. Symbolically written, we have the relation ``total = (N-1)*(phi + chi) + gdim*v + p + th``, where ``N`` is the number of components and ``gdim`` is geometrical dimension. Moreover, the implementation of this method must equip the private attribute ``_subspace``, which is has been initialized as an empty dictionary, with subspaces for individual primitive variables. These subspaces then can be requested throughout the method :py:meth:`subspace`. Examples: * :py:meth:`Monolithic.setup` * :py:meth:`SemiDecoupled.setup` * :py:meth:`FullyDecoupled.setup` """ not_implemented_msg(self)
def free_energy_coefficents(self): """ Returns free energy coefficients :math:`a` and :math:`b` given by .. math:: a = \\frac{\\max_{[0, 1]} \\sqrt{f}}{\\int_0^1 \\sqrt{f}}, \\qquad b = \\frac{1}{2 \\max_{[0, 1]} \\sqrt{f} \\int_0^1 \\sqrt{f}}, where :math:`f` is the double-potential. :returns: free energy coefficients ``(a, b)`` :rtype: tuple """ # FIXME: computation of a, b could be automated not_implemented_msg(self)
def build_pressure_null_space(self): """ An abstract method. This method takes responsibility for building the null space associated with pressure values for problems in which pressure is not fixed at the boundary. (There is only :math:`\\nabla p` in Navier-Stokes equations, which leads to the fact that in such type of problems the pressure is unique up to a constant.) The null space can be later attached to the system matrix. This method also returns a constant vector with pressure DOFs being set to one and other DOFs being set to zero. This vector forms the basis of the created null space and can be used to postprocess computed pressure in a way that its (integral) mean value is equal to zero. :returns: a pair of null space represented by a :py:class:`dolfin.VectorSpaceBasis` object and the corresponding basis vector as a :py:class:`Function` object :rtype: tuple """ not_implemented_msg(self)
def create(self, *args, **kwargs): msg = "Cannot create solver from a generic class." not_implemented_msg(self, msg)
def create(self, *args, **kwargs): msg = "Cannot create discretization scheme from a generic class. " not_implemented_msg(self, msg)
def _create_figure(self): not_implemented_msg(self)
def _tstepping_loop(self, *args, **kwargs): """ An abstract method. """ msg = "Cannot run time-stepping algorithm." not_implemented_msg(self)