dolfin team mailing list archive

[Anders Logg <logg@xxxxxxxxx>]

On Fri, Feb 15, 2008 at 02:46:25PM +0100, cosby@xxxxxxxxx wrote:
> > 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.

Yes, the manual is in a sorry state.

> If I understand you correctly then u.interpolate() returns the
> coefficients of the basis on a given cell, correct?

Yes.

> 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])).

No, it's enough to multiply what you get from u.interpolate() with the
values of the basis functions. (What the interpolation does is just to
pick the correct values from the vector.)

> One more thing. How are the coefficient extracted from the vector
> from u.vector()

It is done by tabulating the local-to-global mapping (dofmap) on a
cell and then picking the values from the locations in the vector
given by the local-to-global mapping.

> and what is the difference between ufc::cell and
> dolfin::Cell (arguments for the interpolate attribute of Function)?

ufc::cell is a simple class that is used to pass data through the
UFC-interface (which is not DOLFIN-specific and can be used by other
libraries).

dolfin::Cell is the DOLFIN implementation of a cell in a mesh. What we
do is that we take the dolfin::Cell and then extract the values we
need and put into the ufc::cell. There is a simple class UFCCell (yes,
a third cell class) which helps you do this.

-- 
Anders



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