dolfin team mailing list archive

[Anders Logg <logg@xxxxxxxxx>]

On Mon, Sep 15, 2008 at 03:12:58PM +0100, Garth N. Wells wrote:
> 
> 
> Anders Logg wrote:
> > On Mon, Sep 15, 2008 at 03:06:55PM +0200, Johan Hake wrote:
> >> On Monday 15 September 2008 14:29:08 Garth N. Wells wrote:
> >>> Could a Python expert take a look at site-packges/dolfin/function.py?
> >>> The code directly following the comment
> >>>
> >>>   # Special case, Function(element, mesh, x), need to create simple form
> >>> to get arguments
> >>>
> >>> need to be updated but I don't understand it well.
> >> The first special case is for initializing a Function with a given Vector, by 
> >> constructing a dofmap from the handed element.
> >>
> >> As constructing a Function from a vector is removed from the cpp interface, 
> >> and we have not, (or have we?) figured out how to wrap a shared_ptr in swig, 
> >> we should probably just remove the first case for now.
> >>
> >> Johan
> > 
> > The question is how we want to create discrete Functions in Python.
> > Previously, this was done by
> > 
> >   u = Function(element, mesh, Vector())
> > 
> > but now the third argument is not needed anymore. If we remove it,
> > we get
> > 
> >   u = Function(element, mesh)
> > 
> > but that doesn't work since that is the way to initialize a
> > user-defined function (something overloading eval()).
> > 
> > We could put in a flag and make "discrete" the default. Then all
> > user-defined functions need to set the flag to "user".
> > 
> > Suggestions? This is a good time to worry about how we want to design
> > the Function interface.
> > 
> 
> Sounds ok to me. This is basically what Vector() was doing, and a flag 
> would be more descriptive.
> 
> Garth

Maybe we could first try to think seriously about reducing the number
of different constructors in Function. There are 14 now! See below.

I guess we need the following two basic constructors (empty and copy):

  /// Create empty function (read data from file)
  Function();

  /// Copy constructor
  Function(const Function& f);

Then we have one for reading from file, which seems ok:

  /// Create function from data file
  explicit Function(const std::string filename);

And then the following set of constructors for constants:

  /// Create constant scalar function from given value
  Function(Mesh& mesh, real value);

  /// Create constant vector function from given size and value
  Function(Mesh& mesh, uint size, real value);

  /// Create constant vector function from given size and values
  Function(Mesh& mesh, const Array<real>& values);

  /// Create constant tensor function from given shape and values
  Function(Mesh& mesh, const Array<uint>& shape, const Array<real>& values);

And then there's this constructor which is needed for w.split(u, p):

  /// Create discrete function from sub function
  explicit Function(SubFunction sub_function);

But then there's the following mess of constructors:

  /// Create function from given ufc::function
  Function(Mesh& mesh, const ufc::function& function, uint size);
    
  /// Create discrete function for argument function i of form
  Function(Mesh& mesh, Form& form, uint i = 1);
    
  /// Create discrete function for argument function i of form
  Function(Mesh& mesh, DofMap& dof_map, const ufc::form& form, uint i = 1);

  /// Create discrete function for argument function i of form (data may be shared)
  Function(std::tr1::shared_ptr<Mesh> mesh,
           std::tr1::shared_ptr<GenericVector> x,
           std::tr1::shared_ptr<DofMap> dof_map, const ufc::form& form, uint i = 1);

  /// Create discrete function based on signatures
  Function(std::tr1::shared_ptr<Mesh> mesh,
           const std::string finite_element_signature,
           const std::string dof_map_signature);

  /// Create user-defined function (evaluation operator must be overloaded)
  explicit Function(Mesh& mesh);

Suggestions for cleanup?

-- 
Anders

Attachment: signature.asc
Description: Digital signature