dolfin team mailing list archive

[A Navaei <axnavaei@xxxxxxxxxxxxxx>]

2009/2/18 A Navaei <axnavaei@xxxxxxxxxxxxxx>:
> 2009/2/17 Anders Logg <logg@xxxxxxxxx>:
>> On Tue, Feb 17, 2009 at 03:28:08PM +0000, Garth N. Wells wrote:
>>>
>>>
>>> A Navaei wrote:
>>> > The following minimal test for Function in c++ reveals some bugs. I
>>> > guess this example can help me with dealing with the current issues of
>>> > ImageFunction.
>>> >
>>> > (1) interpolate.py does not work when a Function is created in c++ and
>>> > wrapped (see comment [2]). It seems that the bug is originated from
>>> > the copy constructor (see comment [3])
>>> >
>>> > (2) In order to perform the interpolation, why is it necessary to
>>> > create another Function and then copy it?
>>> >
>>> > (3) Signature checkes seem not working properly (see comment [1]). The
>>> > signature-based assignments are error-prone anyway, why the
>>> > object-oriented approach is not used?
>>> >
>>>
>>> Signatures are used to permit reading/writing Functions to a file. They
>>> are indeed error prone, so I believe that we reached a consensus a short
>>> while ago that we would remove pre-compiled elements.
>>>
>>> Garth
>>
>> Instead of signatures, I'd recommend that you define a simple form
>> file for each of the different types of FunctionSpace you need, for
>> example:
>>
>>  element = FiniteElement("CG", "triangle", 1)
>>
>>  v = TestFunction(element)
>>  u = TrialFunction(element)
>>  a = v*u*dx
>>
>> If you put this in a file named My.form and compile it with FFC using
>> -l dolfin, you will get a class named MyFunctionSpace that you can
>> then instantiate using just a mesh:
>>
>>  MyFunctionSpace V(mesh);
>>
>> Create one form file for each of the different types of FunctionSpace
>> that you need, name the files to something suitable and use the
>> generated code. That way you won't need to worry about signatures,
>> dofmaps and finite elements.
>
> Effectively, I've been using the very same method all this time, it
> does not work.
>
> The copy constructor fix never worked. I've been trying to explain
> this in many different ways, but the right attention was never paid to
> this. Let's see if the sandbox example can convince you this time.
>
> A Function instance still cannot be returned by reference (or value).
> Returning as shared_ptr seems to work initially, but eventually it
> generates segmentation fault -- see attached.

Attached is a work-around to avoid Function copy constructor.


-Ali

>
>
> -Ali
>
>>
>> --
>> Anders
>>
>> -----BEGIN PGP SIGNATURE-----
>> Version: GnuPG v1.4.9 (GNU/Linux)
>>
>> iEYEARECAAYFAkma2rQACgkQTuwUCDsYZdHp4ACfSbCXc2FAulzIdDsKvhz/6EGV
>> aY4An0eyftGV3hxR3L25M9LPu3X7KFg+
>> =z1cY
>> -----END PGP SIGNATURE-----
>>
>> _______________________________________________
>> DOLFIN-dev mailing list
>> DOLFIN-dev@xxxxxxxxxx
>> http://www.fenics.org/mailman/listinfo/dolfin-dev
>>
>>
>

// Place for random tests

#include <dolfin.h>
#include "Poisson.h"

using namespace dolfin;

class MyFunction : public Function
{
public:

  MyFunction(const FunctionSpace& V) : Function(V) {};

  void eval(double* values, const double* x) const
  {
    message("Calling eval");
    double dx = x[0] - 0.5;
    double dy = x[1] - 0.5;
    values[0] = 500.0*exp(-(dx*dx + dy*dy) / 0.02);
  }
};

class FunctionContainer
{
public:
  FunctionContainer(const FunctionSpace& V) : _f(V)
  {
  };
	
  const Function& get_function()
  {
    return _f;
  };
protected:
  Function _f;
};


int main()
{  
  UnitSquare mesh(2, 2);
  PoissonFunctionSpace V(mesh);
  MyFunction f(V);
  Vector x;
  
  message("Interpolating to another vector");
  f.interpolate(x, f.function_space());
  x.disp();

  message("Interpolating to the function vector");
  f.interpolate(f.vector(), f.function_space());
  f.vector().disp();
  
/*  message("Interpolating using initialising by an external function");
  MyFunction f_(f);
  f.interpolate(f_.vector(), f.function_space());
  f.vector().disp();
  */
  message("Returning Function by reference");
  FunctionContainer fc(V);
  fc.get_function();
}