dolfin team mailing list archive

[cosby@xxxxxxxxx]

> On Thu, Feb 14, 2008 at 05:15:46PM +0100, cosby@xxxxxxxxx wrote:
>> > On Thu, Feb 14, 2008 at 10:06:43AM +0100, Kristen Kaasbjerg wrote:
>> >> Anders Logg wrote:
>> >> > On Wed, Feb 13, 2008 at 10:50:23PM +0100, cosby@xxxxxxxxx wrote:
>> >> >
>> >> >>>> On Wed, Feb 13, 2008 at 08:49:09PM +0100, Shilpa Khatri wrote:
>> >> >>>>
>> >> >>>>> We (Dag and I) are doing this because we would like to have
>> Dolfin
>> >> >>>>> solve
>> >> >>>>> the
>> >> >>>>> Stokes/Navier-Stokes equations as one part of a timestep in our
>> >> code
>> >> >>>>> where we
>> >> >>>>> are moving interfaces that are defined as a random set of
>> points
>> >> in the
>> >> >>>>> domain.
>> >> >>>>>
>> >> >>>>> Thanks,
>> >> >>>>> Shilpa
>> >> >>>>>
>> >> >>>> Then I suggest first finding out which cells those points lie
>> in,
>> >> then
>> >> >>>> then for each cell with a point get the expansion coefficients
>> >> within
>> >> >>>> that cell, then multiply those coefficients with the values of
>> the
>> >> >>>> basis functions at the points.
>> >> >>>>
>> >> >>>> The basis functions are available from the ufc::finite_element.
>> >> >>>>
>> >> >>>> We can implement a suitable interface for this at some point but
>> >> >>>> until then, you can do it manually.
>> >> >>>>
>> >> >>> Sounds good. Is the GTS_Interface still in place for searching?
>> >> >>>
>> >> >>> /Dag
>> >> >>>
>> >> >> I'm a little lost here. How is the ufc module used to get hold
>> >> >> of the basis functions ?
>> >> >>
>> >> >> Kristen
>> >> >>
>> >> >
>> >> > You need to get hold of a ufc::finite_element and then call
>> >> > evaluate_basis_function (see UFC manual). If you have a ufc::form,
>> >> > then you can create a ufc::finite_element by calling
>> >> > create_finite_element. If you have a dolfin::Form, then first get
>> the
>> >> > ufc::form by calling form().
>> >> >
>> >> >
>> >> Ok, so this is doable via the python interface ?
>> >> In case yes, where is the dolfin::Form then hidden ?
>> >>
>> >> Kristen
>> >
>> > Yes, you can use it from the Python interface by calling the JIT
>> > compiler:
>> >
>> >   (compiled_form, compiled_module, form_data) = jit(a)
>> >
>> > You can then call compiled_form.create_finite_element(i) etc
>> > since this will be a Python wrapper for a ufc::form.
>> >
>> > BUT: If you are using the Python interface, then everything is already
>> > available through the Python interface, so if you have a
>> > FiniteElement, you can tabulate it's values at any point by calling
>> > element.tabulate(). Note that this gives you values on the reference
>> > element so you need to map the values to the physical element.
>> >
>> > Another comment is that things like this are better (more efficiently)
>> > implemented as C++ components in DOLFIN and then wrapped back to
>> > Python for general use.
>>
>> Yes, I know. I only have to evaluate the potential at very few points
>> (< 100) though, so this wont be too expensive.
>> What about the expansion coefficients - there must be a set for each
>> cell ?
>
> You mean getting hold of the expansion coefficients so you can
> multiply them with the basis functions? These are in the Vector of
> degrees of freedom that each Function has:
>
>   x = u.vector()
>
> Then you need to get hold of the local-to-global mapping (which values
> in this vector that are the coefficients on any given element).
>
> The easiest way to do this is to let DOLFIN handle it by calling
> u.interpolate() to get the coefficients on a given cell.
>

well, it seems to be an awful lot easier than I expected.
It is hard to penetrate these things when an proper overview
of the whole program structure is absent.
If I understand you correctly then u.interpolate() returns the
coefficients of the basis on a given cell, correct? These then
have to be multiplied by expansion coefficient from u.vector()
which again have to multiplied by the returned array from
element.tabulate(0,([x,y])).

One more thing. How are the coefficient extracted from the vector
from u.vector() and what is the difference between ufc::cell and
dolfin::Cell (arguments for the interpolate attribute of Function)?

Kristen


> --
> Anders
> _______________________________________________
> DOLFIN-dev mailing list
> DOLFIN-dev@xxxxxxxxxx
> http://www.fenics.org/mailman/listinfo/dolfin-dev
>