Mercurial > fem-fenics-eugenio
changeset 46:a64e195d0611
Wrapper class for dolfin::Function
* function.h: definition of the new clas function which derives from
octave_base_value
* fem_func.cc: take as input a functionspace and a vector and creates
an object of type function
* fem_init_env: register also the class function
author | gedeone-octave <marco.vassallo@outlook.com> |
---|---|
date | Mon, 22 Jul 2013 14:56:51 +0200 |
parents | a965f4a3c8d8 |
children | fe29ca22b1ec |
files | src/fem_func.cc src/fem_init_env.cc src/function.h |
diffstat | 3 files changed, 121 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/fem_func.cc Mon Jul 22 14:56:51 2013 +0200 @@ -0,0 +1,50 @@ +#include <dolfin.h> +#include "functionspace.h" +#include "function.h" + +DEFUN_DLD (fem_func, args, , "fem_func: functionspace V, vector u") +{ + + int nargin = args.length (); + octave_value retval=0; + + if (nargin < 2 || nargin > 2) + print_usage (); + else + { + if (! functionspace_type_loaded) + { + functionspace::register_type (); + functionspace_type_loaded = true; + mlock (); + } + if (args(0).type_id () == functionspace::static_type_id ()) + { + const functionspace & fspo = + static_cast<const functionspace&> (args(0).get_rep ()); + Array <double> myu = args(1).array_value (); + + if (!error_state) + { + const boost::shared_ptr<const dolfin::FunctionSpace> & V = fspo.get_pfsp (); + + dolfin::Vector du(myu.length ()); + for (std::size_t i = 0; i < myu.length (); ++i) + du.setitem (i, myu(i)); + + boost::shared_ptr<dolfin::Vector> uu (new dolfin::Vector(du)); + boost::shared_ptr <const dolfin::Function> u (new dolfin::Function(V, uu)); + + if (! function_type_loaded) + { + function::register_type (); + function_type_loaded = true; + mlock (); + } + + retval = new function (u); + } + } + } + return retval; +}
--- a/src/fem_init_env.cc Mon Jul 22 14:49:10 2013 +0200 +++ b/src/fem_init_env.cc Mon Jul 22 14:56:51 2013 +0200 @@ -20,6 +20,7 @@ #include "functionspace.h" #include "boundarycondition.h" #include "coefficient.h" +#include "function.h" DEFINE_OCTAVE_ALLOCATOR (mesh); DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (mesh, "mesh", "mesh"); @@ -33,6 +34,9 @@ DEFINE_OCTAVE_ALLOCATOR (coefficient); DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (coefficient, "coefficient", "coefficient"); +DEFINE_OCTAVE_ALLOCATOR (function); +DEFINE_OV_TYPEID_FUNCTIONS_AND_DATA (function, "function", "function"); + DEFUN_DLD (fem_init_env, args, , "-*- texinfo -*-\n\ @deftypefn {Function File} {[]} = \ fem_init_env ( ) \n\ @@ -58,6 +62,9 @@ coefficient::register_type (); coefficient_type_loaded = true; std::cout << "coefficient_type_loaded" << std::endl; + function::register_type (); + function_type_loaded = true; + std::cout << "function_type_loaded" << std::endl; mlock (); } return retval;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/function.h Mon Jul 22 14:56:51 2013 +0200 @@ -0,0 +1,64 @@ +/* + Copyright (C) 2013 Marco Vassallo + + This program is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free Software + Foundation; either version 2 of the License, or (at your option) any later + version. + + This program is distributed in the hope that it will be useful, but WITHOUT + ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + details. + + You should have received a copy of the GNU General Public License along with + this program; if not, see <http://www.gnu.org/licenses/>. +*/ + +#ifndef _FUNCTION_OCTAVE_ +#define _FUNCTION_OCTAVE_ + +#include <memory> +#include <vector> +#include <dolfin.h> +#include <octave/oct.h> + +class function : public octave_base_value +{ + + public: + + function () : octave_base_value (), fun () { } + + function (boost::shared_ptr <const dolfin::Function> _fun) : + octave_base_value (), fun (_fun) { } + + void print (std::ostream& os, bool pr_as_read_syntax = false) const + { os << "Function : " << (*fun).str(true) << std::endl; } + + ~function(void) {} + + bool is_defined (void) const { return true; } + + const dolfin::Function & get_fun (void) const + { return (*fun); } + + const boost::shared_ptr <const dolfin::Function> & get_pfun (void) const + { return fun; } + + void set_fun (dolfin::Function & _fun) + { + dolfin::Function * p = new dolfin::Function (_fun); + fun = boost::shared_ptr<const dolfin::Function> (p); + } + + private: + + boost::shared_ptr <const dolfin::Function> fun; + + DECLARE_OCTAVE_ALLOCATOR; + DECLARE_OV_TYPEID_FUNCTIONS_AND_DATA; + +}; + static bool function_type_loaded = false; +#endif