Merge lp:~ldeo-magma/dolfin/devfixes into lp:~fenics-core/dolfin/trunk

[Cian Wilson]

This merge includes changes that (if they are considered the best way forward) would fix bug 882908 and provide the functionality requested in blueprint https://blueprints.launchpad.net/dolfin/+spec/extend-meshvaluecollection (also see question https://answers.launchpad.net/dolfin/+question/174566 ).

It provides operator=(const {MeshFunction,MeshValueCollection}) functionality to MeshValueCollections.

[Garth Wells (garth-wells)]

Looks good at first glance. Now for the unpleasant side: could add some unit tests?

review: Needs Fixing

[Johan Hake (johan-hake)]

On Friday October 28 2011 12:56:26 Garth Wells wrote:
> Review: Needs Fixing
>
> Looks good at first glance. Now for the unpleasant side: could add some
> unit tests?

If this is about adding the operator= to MeshValueCollection you might want to
look at how we have mapped this to Python for some of the la classes. There we
rename the operator= to assign so one can do:

  mesh.domains().markers(0).assign(mesh_function)

This is needed as there are no such thing as a operator= in Python

Disclaimer: I have not looked at the code yet, and you might already have done
this :P

Johan

[lp:~ldeo-magma/dolfin/devfixes]

6388. By Cian Wilson on 2011-10-29

C++ unit tests for MeshValueCollections.

6389. By Cian Wilson on 2011-10-29

Incorrect logic.

[Cian Wilson (cwilson)]

Garth: I've added some unit tests and set up a buildbot queue for this branch (slave is natty 64bit, debugging enabled):
http://diana.apam.columbia.edu:8010/waterfall?show=dolfin-x86-64-debug-devfixes

Johan: I'm not familiar with swig but naively replacing my
%ignore dolfin::MeshValueCollection::operator=;
with
%rename(assign) dolfin::MeshValueCollection::operator=;
doesn't seem to work - I get a warning about operator= being ignored. Google suggests that '%ignore *::operator=;' is taking precedence for templated classes.
Can you point me to a working example for this?

More general question: is the docstring for MeshValueCollection in swig/mesh_post.i incorrect or is the python interface for MeshValueCollections just different to the C++ interface? It suggests that one of the arguments is a mesh object.

Cheers,
Cian

[lp:~ldeo-magma/dolfin/devfixes]

6390. By Johan Hake on 2011-10-31

Fixes for Python wrapper of MeshValueCollection
  -- Added python unittest but some test fails

[Johan Hake (johan-hake)]

On Saturday October 29 2011 09:14:22 Cian Wilson wrote:
> Garth: I've added some unit tests and set up a buildbot queue for this

Looks nice! Would be cool if we could have the tests running in parallel too.

> branch (slave is natty 64bit, debugging enabled):
> http://diana.apam.columbia.edu:8010/waterfall?show=dolfin-x86-64-debug-dev
> fixes
>
> Johan: I'm not familiar with swig but naively replacing my
> %ignore dolfin::MeshValueCollection::operator=;
> with
> %rename(assign) dolfin::MeshValueCollection::operator=;
> doesn't seem to work - I get a warning about operator= being ignored.
> Google suggests that '%ignore *::operator=;' is taking precedence for
> templated classes. Can you point me to a working example for this?

I fixed this in a commit to your branch. Have a look at:

  lp:~johan-hake/dolfin/python-wrapper-meshvaluecollection

I also converted your unittest to Python. It fails for some test. Not sure
why. Maybe you can have a look? Maybe also make it run in parallel, if that is
possible.

> More general question: is the docstring for MeshValueCollection in
> swig/mesh_post.i incorrect or is the python interface for
> MeshValueCollections just different to the C++ interface? It suggests
> that one of the arguments is a mesh object.

Thanks for reporting. This is corrected in the above branch.

Johan

[Garth Wells (garth-wells)]

Some tests are failing for me:

In file included from /home/garth/code/fenics/dolfin.d/trunk.d/testing/local/include/dolfin/mesh/dolfin_mesh.h:29:0,
                 from /home/garth/code/fenics/dolfin.d/trunk.d/testing/local/include/dolfin.h:12,
                 from /home/garth/code/fenics/dolfin.d/trunk.d/testing/test/unit/mesh/cpp/test.cpp:23:
/home/garth/code/fenics/dolfin.d/trunk.d/testing/local/include/dolfin/mesh/MeshValueCollection.h: In member function ‘dolfin::MeshValueCollection<T>& dolfin::MeshValueCollection<T>::operator=(const dolfin::MeshValueCollection<T>&) [with T = int]’:
/home/garth/code/fenics/dolfin.d/trunk.d/testing/test/unit/mesh/cpp/test.cpp:248:9: instantiated from here
/home/garth/code/fenics/dolfin.d/trunk.d/testing/local/include/dolfin/mesh/MeshValueCollection.h:335:3: error: no return statement in function returning non-void [-Werror=return-type]
/home/garth/code/fenics/dolfin.d/trunk.d/testing/local/include/dolfin/mesh/MeshValueCollection.h: In member function ‘dolfin::MeshValueCollection<T>& dolfin::MeshValueCollection<T>::operator=(const dolfin::MeshFunction<T>&) [with T = int]’:
/home/garth/code/fenics/dolfin.d/trunk.d/testing/local/include/dolfin/mesh/MeshValueCollection.h:328:3: error: control reaches end of non-void function [-Werror=return-type]
cc1plus: all warnings being treated as errors

review: Needs Fixing

[lp:~ldeo-magma/dolfin/devfixes]

6391. By Cian Wilson on 2011-10-31

Return statements omitted.

6392. By Cian Wilson on 2011-10-31

Fixes for MeshValueCollection python test in serial.

6393. By Cian Wilson on 2011-10-31

Indentation fixes.

6394. By Cian Wilson on 2011-10-31

Possible fixes for parallel in python tests.

6395. By Cian Wilson on 2011-10-31

Same possibly parallel safe updates for c++ tests. Still don't think these are actually getting run in parallel though.

6396. By Cian Wilson on 2011-10-31

Register the test suite in parallel and serial.

[Cian Wilson (cwilson)]

Sorry about that Garth, stupid mistake on my part. Don't know why I was getting away with it with my compiler. Should be fixed now but let me know if you hit something else.

Thanks for those change Johan. Interesting to see how you do that in swig - definitely beyond my knowledge of it! I've fixed the failing tests and hopefully made them parallel safe.

Cheers,
Cian

[Johan Hake (johan-hake)]

Thanks!

> Sorry about that Garth, stupid mistake on my part. Don't know why I was
> getting away with it with my compiler. Should be fixed now but let me
> know if you hit something else.
>
> Thanks for those change Johan. Interesting to see how you do that in swig
> - definitely beyond my knowledge of it!

Comes with some (read alot) trial and error. Basically rename cannot be done
on methods from templated classes. I then had to reimplement the function in
the C++ wrapper interface of the Python class. This is done in mesh_post.i.
For more gory details about SWIGing have alook in chapter 19 in the FEniCS
book.

  https://launchpad.net/fenics-book

> I've fixed the failing tests and hopefully made them parallel safe.

Thanks! Looks like the tests pass locally for me (serial and parallel). I will
push them to my buildbot branch and if that is green I push it into trunk.

Johan

[Garth Wells (garth-wells)]

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2011-10-23 08:23:30 +0000
+++ .bzrignore	2011-10-31 20:45:51 +0000
@@ -37,6 +37,7 @@
 RE:demo/adaptivity/.*/(cpp|python)/.*\.(pvd|vtu|pvtu|xml|bin|bin.gz)
 RE:demo/adaptivity/.*/indicators.py
 RE:demo/.*/cpp/demo_.*
+RE:test/.*/cpp/test_.*
 RE:test/unit/mesh/(cpp|python)/.*.(xml|m)
 RE:test/unit/parameter/(cpp|python)/.*.(xml|xml.gz)
 RE:test/unit/io/(cpp|python)/.*.(xml|xml.gz|vtu|pvtu|pvd)

=== modified file 'ChangeLog'
--- ChangeLog	2011-10-26 15:31:33 +0000
+++ ChangeLog	2011-10-31 20:45:51 +0000
@@ -1,6 +1,8 @@
+ - Added get_value to MeshValueCollection
+ - Added assignment operator to MeshValueCollection
 1.0-beta2 [2011-10-26]
  - Change search path of parameter file to ~/.fenics/dolfin_parameters.xml
- - Add functions Parameters::has_parameter, Parameters::has_parameter_set 
+ - Add functions Parameters::has_parameter, Parameters::has_parameter_set
  - Added option to store all connectivities in a mesh for TimeSeries (false by default)
  - Added option for gzip compressed binary files for TimeSeries
  - Propagate global parameters to Krylov and LU solvers

=== modified file 'dolfin/mesh/MeshValueCollection.h'
--- dolfin/mesh/MeshValueCollection.h	2011-10-04 15:02:09 +0000
+++ dolfin/mesh/MeshValueCollection.h	2011-10-31 20:45:51 +0000
@@ -16,7 +16,7 @@
 // along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
 //
 // First added:  2006-08-30
-// Last changed: 2011-10-04
+// Last changed: 2011-10-30
 
 #ifndef __MESH_VALUE_COLLECTION_H
 #define __MESH_VALUE_COLLECTION_H
@@ -86,6 +86,20 @@
     ~MeshValueCollection()
     {}
 
+    /// Assignment operator
+    ///
+    /// *Arguments*
+    ///     mesh_function (_MeshFunction_)
+    ///         A _MeshFunction_ object used to construct a MeshValueCollection.
+    MeshValueCollection<T>& operator=(const MeshFunction<T>& mesh_function);
+
+    /// Assignment operator
+    ///
+    /// *Arguments*
+    ///     mesh_value_collection (_MeshValueCollection_)
+    ///         A _MeshValueCollection_ object used to construct a MeshValueCollection.
+    MeshValueCollection<T>& operator=(const MeshValueCollection<T>& mesh_value_collection);
+
     /// Set the topological dimension
     ///
     /// *Arguments*
@@ -140,6 +154,20 @@
     ///         an existing value.
     bool set_value(uint entity_index, const T& value, const Mesh& mesh);
 
+    /// Get marker value for given entity defined by a cell index and
+    /// a local entity index
+    ///
+    /// *Arguments*
+    ///     cell_index (uint)
+    ///         The index of the cell.
+    ///     local_entity (uint)
+    ///         The local index of the entity relative to the cell.
+    ///
+    /// *Returns*
+    ///     marker_value (T)
+    ///         The value of the marker.
+    T get_value(uint cell_index, uint local_entity);
+
     /// Get all values
     ///
     /// *Returns*
@@ -269,6 +297,62 @@
   }
   //---------------------------------------------------------------------------
   template <typename T>
+  MeshValueCollection<T>& MeshValueCollection<T>::operator=(const MeshFunction<T>& mesh_function)
+  {
+    _dim = mesh_function.dim();
+
+    const Mesh& mesh = mesh_function.mesh();
+    const uint D = mesh.topology().dim();
+
+    // FIXME: Use iterators
+
+    // Handle cells as a special case
+    if (D == _dim)
+    {
+      for (uint cell_index = 0; cell_index < mesh_function.size(); ++cell_index)
+      {
+        const std::pair<uint, uint> key(cell_index, 0);
+        _values.insert(std::make_pair(key, mesh_function[cell_index]));
+      }
+    }
+    else
+    {
+      mesh.init(_dim, D);
+      const MeshConnectivity& connectivity = mesh.topology()(_dim, D);
+      assert(connectivity.size() > 0);
+      for (uint entity_index = 0; entity_index < mesh_function.size(); ++entity_index)
+      {
+        // Find the cell
+        assert(connectivity.size(entity_index) > 0);
+        const MeshEntity entity(mesh, _dim, entity_index);
+        for (uint i = 0; i < entity.num_entities(D) ; ++i)
+        {
+          // Create cell
+          const Cell cell(mesh, connectivity(entity_index)[i]);
+
+          // Find the local entity index
+          const uint local_entity = cell.index(entity);
+
+          // Insert into map
+          const std::pair<uint, uint> key(cell.index(), local_entity);
+          _values.insert(std::make_pair(key, mesh_function[entity_index]));
+        }
+      }
+    }
+
+    return *this;
+  }
+  //---------------------------------------------------------------------------
+  template <typename T>
+  MeshValueCollection<T>& MeshValueCollection<T>::operator=(const MeshValueCollection<T>& mesh_value_collection)
+  {
+    _dim = mesh_value_collection.dim();
+    _values = mesh_value_collection.values();
+
+    return *this;
+  }
+  //---------------------------------------------------------------------------
+  template <typename T>
   void MeshValueCollection<T>::set_dim(uint dim)
   {
     _dim = dim;
@@ -334,6 +418,19 @@
   }
   //---------------------------------------------------------------------------
   template <typename T>
+  T MeshValueCollection<T>::get_value(uint cell_index,
+				      uint local_entity)
+  {
+    const std::pair<uint, uint> pos(std::make_pair(cell_index, local_entity));
+    const typename std::map<std::pair<uint, uint>, T>::const_iterator it = 
+      _values.find(pos);
+    if (it == _values.end())
+      error("No value stored for cell index: %d and local index: %d", 
+	    cell_index, local_entity);
+    return it->second;
+  }
+  //---------------------------------------------------------------------------
+  template <typename T>
   std::map<std::pair<uint, uint>, T>& MeshValueCollection<T>::values()
   {
     return _values;

=== modified file 'dolfin/swig/docstrings.i'
--- dolfin/swig/docstrings.i	2011-10-23 08:23:30 +0000
+++ dolfin/swig/docstrings.i	2011-10-31 20:45:51 +0000
@@ -1882,7 +1882,7 @@
 
 *Arguments*
     boundary_values (boost::unordered_map<uint, double>)
-        The boundary values.
+        Map from dof to boundary value.
     method (str)
         Optional argument: A string specifying which
         method to use.
@@ -10832,6 +10832,15 @@
 %feature("docstring")  dolfin::MeshFunction::operator= "
 **Overloaded versions**
 
+* operator=\ (f)
+
+  Assign mesh function to other mesh function
+  Assignment operator
+  
+  *Arguments*
+      f (:py:class:`MeshFunction`)
+          A :py:class:`MeshFunction` object to asssign to another MeshFunction.
+
 * operator=\ (mesh)
 
   Assignment operator
@@ -10840,10 +10849,6 @@
       mesh (:py:class:`MeshValueCollection`)
           A :py:class:`MeshValueCollection` object used to construct a MeshFunction.
 
-* operator=\ (f)
-
-  Assign mesh function to other mesh function
-
 * operator=\ (value)
 
   Set all values to given value
@@ -11158,6 +11163,26 @@
           The mesh entity dimension for the mesh value collection.
 ";
 
+%feature("docstring")  dolfin::MeshValueCollection::operator= "
+**Overloaded versions**
+
+* operator=\ (mesh_function)
+
+  Assignment operator
+  
+  *Arguments*
+      mesh_function (:py:class:`MeshFunction`)
+          A :py:class:`MeshFunction` object used to construct a MeshValueCollection.
+
+* operator=\ (mesh_value_collection)
+
+  Assignment operator
+  
+  *Arguments*
+      mesh_value_collection (:py:class:`MeshValueCollection`)
+          A :py:class:`MeshValueCollection` object used to construct a MeshValueCollection.
+";
+
 %feature("docstring")  dolfin::MeshValueCollection::set_dim "
 Set the topological dimension
 
@@ -11221,6 +11246,21 @@
           an existing value.
 ";
 
+%feature("docstring")  dolfin::MeshValueCollection::get_value "
+Get marker value for given entity defined by a cell index and
+a local entity index
+
+*Arguments*
+    cell_index (int)
+        The index of the cell.
+    local_entity (int)
+        The local index of the entity relative to the cell.
+
+*Returns*
+    marker_value (T)
+        The value of the marker.
+";
+
 %feature("docstring")  dolfin::MeshValueCollection::values "
 **Overloaded versions**
 
@@ -12312,7 +12352,15 @@
 ";
 
 %feature("docstring")  dolfin::MPI::distribute "
-Distribute local arrays on all processors according to given partition
+**Overloaded versions**
+
+* distribute\ (in_values, destinations, out_values, sources)
+
+  Distribute local arrays on all processors according to given partition
+
+* distribute\ (in_values, destinations, out_values)
+
+  Distribute local arrays on all processors according to given partition
 ";
 
 %feature("docstring")  dolfin::MPI::scatter "
@@ -13042,6 +13090,8 @@
         The time series name
     compressed (bool)
         Use compressed file format (default false)
+    store_connectivity (bool)
+        Store all computed connectivity (default false)
 ";
 
 %feature("docstring")  dolfin::TimeSeries::store "
@@ -13921,7 +13971,15 @@
 ";
 
 %feature("docstring")  dolfin::Parameters::has_key "
-Check if parameter set has given key
+Check if parameter set has key (parameter or nested parameter set)
+";
+
+%feature("docstring")  dolfin::Parameters::has_parameter "
+Check if parameter set has given parameter
+";
+
+%feature("docstring")  dolfin::Parameters::has_parameter_set "
+Check if parameter set has given nested parameter set
 ";
 
 %feature("docstring")  dolfin::Parameters::get_parameter_keys "

=== modified file 'dolfin/swig/mesh_post.i'
--- dolfin/swig/mesh_post.i	2011-09-28 04:24:45 +0000
+++ dolfin/swig/mesh_post.i	2011-10-31 20:45:51 +0000
@@ -167,14 +167,14 @@
 
 # Create the named MeshFunction types
 VertexFunction = type("VertexFunction", (), \
-		                {"__new__":_new_closure("VertexFunction"),\
-                       "__doc__":"Create MeshFunction of topological" \
+		      {"__new__":_new_closure("VertexFunction"),\
+                       "__doc__":"Create MeshFunction of topological"\
                        " dimension 0 on given mesh."})
 EdgeFunction = type("EdgeFunction", (), \
                     {"__new__":_new_closure("EdgeFunction"),\
                      "__doc__":"Create MeshFunction of topological"\
                      " dimension 1 on given mesh."})
-FaceFunction = type("FaceFunction", (), \
+FaceFunction = type("FaceFunction", (),\
                     {"__new__":_new_closure("FaceFunction"),\
                      "__doc__":"Create MeshFunction of topological"\
                      " dimension 2 on given mesh."})
@@ -191,26 +191,36 @@
 //-----------------------------------------------------------------------------
 // MeshValueCollection macro
 //-----------------------------------------------------------------------------
-%define DECLARE_MESHVALUECOLLECTION(MESHVALUECOLLECTION, TYPE, TYPENAME)
-%shared_ptr(dolfin::MESHVALUECOLLECTION<TYPE>)
-%template(MESHVALUECOLLECTION ## TYPENAME) dolfin::MESHVALUECOLLECTION<TYPE>;
-
-%enddef
-
-//-----------------------------------------------------------------------------
-// Macro for declaring MeshValueCollection
-//-----------------------------------------------------------------------------
-%define DECLARE_MESHVALUECOLLECTIONS(MESHVALUECOLLECTION)
-DECLARE_MESHVALUECOLLECTION(MESHVALUECOLLECTION, unsigned int, UInt)
-DECLARE_MESHVALUECOLLECTION(MESHVALUECOLLECTION, int, Int)
-DECLARE_MESHVALUECOLLECTION(MESHVALUECOLLECTION, double, Double)
-DECLARE_MESHVALUECOLLECTION(MESHVALUECOLLECTION, bool, Bool)
-%enddef
-
-//-----------------------------------------------------------------------------
-// Run Macros to declare the different MeshValueCollections
-//-----------------------------------------------------------------------------
-DECLARE_MESHVALUECOLLECTIONS(MeshValueCollection)
+%define DECLARE_MESHVALUECOLLECTION(TYPE, TYPENAME)
+%shared_ptr(dolfin::MeshValueCollection<TYPE>)
+%template(MeshValueCollection ## TYPENAME) dolfin::MeshValueCollection<TYPE>;
+
+%feature("docstring") dolfin::MeshValueCollection::assign "Missing docstring";
+
+// Extend MeshFunction interface for assign methods
+%extend dolfin::MeshValueCollection<TYPE>
+{
+  
+  void assign(const dolfin::MeshFunction<TYPE>& mesh_function) 
+  { 
+    (*self) = mesh_function; 
+  }
+  
+  void assign(const dolfin::MeshValueCollection<TYPE>& mesh_value_collection)
+  { 
+    (*self) = mesh_value_collection; 
+  }
+}
+
+%enddef
+
+//-----------------------------------------------------------------------------
+// Run macros for declaring MeshValueCollection
+//-----------------------------------------------------------------------------
+DECLARE_MESHVALUECOLLECTION(unsigned int, UInt)
+DECLARE_MESHVALUECOLLECTION(int, Int)
+DECLARE_MESHVALUECOLLECTION(double, Double)
+DECLARE_MESHVALUECOLLECTION(bool, Bool)
 
 // Create docstrings to the MeshValueCollection
 %pythoncode
@@ -218,13 +228,25 @@
 _meshvaluecollection_doc_string = MeshValueCollectionInt.__doc__
 _meshvaluecollection_doc_string += """
   *Arguments*
-    tp (str)
-      String defining the type of the MeshValueCollection
-      Allowed: 'int', 'uint', 'double', and 'bool'
-    mesh (_Mesh_)
-      A DOLFIN mesh.
-    dim (uint)
-      The topological dimension of the MeshValueCollection.
+      tp (str)
+         String defining the type of the MeshValueCollection
+          Allowed: 'int', 'uint', 'double', and 'bool'
+      dim (uint)
+          The topological dimension of the MeshValueCollection.
+          Optional.
+      mesh_function (_MeshFunction_)
+          The MeshValueCollection will get the values from the mesh_function
+          Optional.
+       mesh (Mesh)
+          A mesh associated with the collection. The mesh is used to
+          map collection values to the appropriate process.
+          Optional, used when read from file.
+      filename (std::string)
+          The XML file name.
+          Optional, used when read from file.
+      dim (uint)
+          The mesh entity dimension for the mesh value collection.
+          Optional, used when read from file
 """
 class MeshValueCollection(object):
     __doc__ = _meshvaluecollection_doc_string

=== modified file 'dolfin/swig/mesh_pre.i'
--- dolfin/swig/mesh_pre.i	2011-10-10 17:49:14 +0000
+++ dolfin/swig/mesh_pre.i	2011-10-31 20:45:51 +0000
@@ -87,6 +87,7 @@
 %ignore dolfin::MeshData::operator=;
 %ignore dolfin::MeshFunction::operator=;
 %ignore dolfin::MeshFunction::operator[];
+%ignore dolfin::MeshValueCollection::operator=;
 %ignore dolfin::MeshGeometry::operator=;
 %ignore dolfin::MeshTopology::operator=;
 %ignore dolfin::MeshConnectivity::operator=;

=== modified file 'test/unit/mesh/cpp/test.cpp'
--- test/unit/mesh/cpp/test.cpp	2011-06-02 19:26:59 +0000
+++ test/unit/mesh/cpp/test.cpp	2011-10-31 20:45:51 +0000
@@ -16,7 +16,7 @@
 // along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
 //
 // First added:  2007-05-14
-// Last changed: 2011-03-31
+// Last changed: 2011-10-30
 //
 // Unit tests for the mesh library
 
@@ -218,6 +218,166 @@
 
 };
 
+class MeshValueCollections : public CppUnit::TestFixture
+{
+  CPPUNIT_TEST_SUITE(MeshValueCollections);
+  CPPUNIT_TEST(testAssign2DCells);
+  CPPUNIT_TEST(testAssign2DFacets);
+  CPPUNIT_TEST(testAssign2DVertices);
+  CPPUNIT_TEST(testMeshFunctionAssign2DCells);
+  CPPUNIT_TEST(testMeshFunctionAssign2DFacets);
+  CPPUNIT_TEST(testMeshFunctionAssign2DVertices);
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+
+  void testAssign2DCells()
+  {
+    UnitSquare mesh(3, 3);
+    const dolfin::uint ncells = mesh.num_cells();
+    MeshValueCollection<int> f(2);
+    bool all_new = true;
+    for (CellIterator cell(mesh); !cell.end(); ++cell)
+    {
+      bool this_new;
+      const int value = ncells - cell->index();
+      this_new = f.set_value(cell->index(), value, mesh);
+      all_new = all_new && this_new;
+    }
+    MeshValueCollection<int> g(2);
+    g = f;
+    CPPUNIT_ASSERT_EQUAL(ncells, f.size());
+    CPPUNIT_ASSERT_EQUAL(ncells, g.size());
+    CPPUNIT_ASSERT(all_new);
+    for (CellIterator cell(mesh); !cell.end(); ++cell)
+    {
+      const int value = ncells - cell->index();
+      CPPUNIT_ASSERT_EQUAL(value, g.get_value(cell->index(), 0));
+    }
+  }
+
+  void testAssign2DFacets()
+  {
+    UnitSquare mesh(3, 3);
+    mesh.init(2,1);
+    const dolfin::uint ncells = mesh.num_cells();
+    MeshValueCollection<int> f(1);
+    bool all_new = true;
+    for (CellIterator cell(mesh); !cell.end(); ++cell)
+    {
+      const int value = ncells - cell->index();
+      for (dolfin::uint i = 0; i < cell->num_entities(1); ++i)
+      {
+        bool this_new;
+        this_new = f.set_value(cell->index(), i, value+i);
+        all_new = all_new && this_new;
+      }
+    }
+    MeshValueCollection<int> g(1);
+    g = f;
+    CPPUNIT_ASSERT_EQUAL(ncells*3, f.size());
+    CPPUNIT_ASSERT_EQUAL(ncells*3, g.size());
+    CPPUNIT_ASSERT(all_new);
+    for (CellIterator cell(mesh); !cell.end(); ++cell)
+    {
+      for (dolfin::uint i = 0; i < cell->num_entities(1); ++i)
+      {
+        const int value = ncells - cell->index() + i;
+        CPPUNIT_ASSERT_EQUAL(value, g.get_value(cell->index(), i));
+      }
+    }
+  }
+
+  void testAssign2DVertices()
+  {
+    UnitSquare mesh(3, 3);
+    mesh.init(2,0);
+    const dolfin::uint ncells = mesh.num_cells();
+    MeshValueCollection<int> f(0);
+    bool all_new = true;
+    for (CellIterator cell(mesh); !cell.end(); ++cell)
+    {
+      const int value = ncells - cell->index();
+      for (dolfin::uint i = 0; i < cell->num_entities(0); ++i)
+      {
+        bool this_new;
+        this_new = f.set_value(cell->index(), i, value+i);
+        all_new = all_new && this_new;
+      }
+    }
+    MeshValueCollection<int> g(0);
+    g = f;
+    CPPUNIT_ASSERT_EQUAL(ncells*3, f.size());
+    CPPUNIT_ASSERT_EQUAL(ncells*3, g.size());
+    CPPUNIT_ASSERT(all_new);
+    for (CellIterator cell(mesh); !cell.end(); ++cell)
+    {
+      for (dolfin::uint i = 0; i < cell->num_entities(0); ++i)
+      {
+        const int value = ncells - cell->index() + i;
+        CPPUNIT_ASSERT_EQUAL(value, g.get_value(cell->index(), i));
+      }
+    }
+  }
+
+  void testMeshFunctionAssign2DCells()
+  {
+    UnitSquare mesh(3, 3);
+    const dolfin::uint ncells = mesh.num_cells();
+    MeshFunction<int> f(mesh, 2, 0);
+    for (CellIterator cell(mesh); !cell.end(); ++cell)
+    {
+      f[cell->index()] = ncells - cell->index();
+    }
+    MeshValueCollection<int> g(2);
+    g = f;
+    CPPUNIT_ASSERT_EQUAL(ncells, f.size());
+    CPPUNIT_ASSERT_EQUAL(ncells, g.size());
+    for (CellIterator cell(mesh); !cell.end(); ++cell)
+    {
+      const int value = ncells - cell->index();
+      CPPUNIT_ASSERT_EQUAL(value, g.get_value(cell->index(), 0));
+    }
+  }
+
+  void testMeshFunctionAssign2DFacets()
+  {
+    UnitSquare mesh(3, 3);
+    mesh.init(1);
+    MeshFunction<int> f(mesh, 1, 25);
+    MeshValueCollection<int> g(1);
+    g = f;
+    CPPUNIT_ASSERT_EQUAL(mesh.num_facets(), f.size());
+    CPPUNIT_ASSERT_EQUAL(mesh.num_cells()*3, g.size());
+    for (CellIterator cell(mesh); !cell.end(); ++cell)
+    {
+      for (dolfin::uint i = 0; i < cell->num_entities(1); ++i)
+      {
+        CPPUNIT_ASSERT_EQUAL(25, g.get_value(cell->index(), i));
+      }
+    }
+  }
+
+  void testMeshFunctionAssign2DVertices()
+  {
+    UnitSquare mesh(3, 3);
+    mesh.init(0);
+    MeshFunction<int> f(mesh, 0, 25);
+    MeshValueCollection<int> g(0);
+    g = f;
+    CPPUNIT_ASSERT_EQUAL(mesh.num_vertices(), f.size());
+    CPPUNIT_ASSERT_EQUAL(mesh.num_cells()*3, g.size());
+    for (CellIterator cell(mesh); !cell.end(); ++cell)
+    {
+      for (dolfin::uint i = 0; i < cell->num_entities(0); ++i)
+      {
+        CPPUNIT_ASSERT_EQUAL(25, g.get_value(cell->index(), i));
+      }
+    }
+  }
+
+};
+
 class InputOutput : public CppUnit::TestFixture
 {
   CPPUNIT_TEST_SUITE(InputOutput);
@@ -305,6 +465,7 @@
 int main()
 {
   CPPUNIT_TEST_SUITE_REGISTRATION(MeshIterators);
+  CPPUNIT_TEST_SUITE_REGISTRATION(MeshValueCollections);
 
   // FIXME: The following test breaks in parallel
   if (dolfin::MPI::num_processes() == 1)

=== added file 'test/unit/mesh/python/MeshValueCollection.py'
--- test/unit/mesh/python/MeshValueCollection.py	1970-01-01 00:00:00 +0000
+++ test/unit/mesh/python/MeshValueCollection.py	2011-10-31 20:45:51 +0000
@@ -0,0 +1,134 @@
+"""Unit tests for MeshValueCollection"""
+
+# Copyright (C) 2011 Johan Hake
+#
+# This file is part of DOLFIN.
+#
+# DOLFIN is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# DOLFIN 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 Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
+#
+# First added:  2011-03-10
+# Last changed: 2011-03-10
+
+import unittest
+import numpy.random
+from dolfin import *
+
+class MeshValueCollections(unittest.TestCase):
+
+  def testAssign2DCells(self):
+      mesh = UnitSquare (3, 3)
+      ncells = mesh.num_cells()
+      f = MeshValueCollection("int", 2)
+      all_new = True
+      for cell in cells(mesh):
+          value = ncells - cell.index()
+          all_new = all_new and f.set_value(cell.index(), value, mesh)
+      g = MeshValueCollection("int", 2)
+      g.assign(f)
+      self.assertEqual(ncells, f.size())
+      self.assertEqual(ncells, g.size())
+      self.assertTrue(all_new)
+      
+      for cell in cells(mesh):
+          value = ncells - cell.index()
+          self.assertEqual(value, g.get_value(cell.index(), 0))
+          
+  def testAssign2DFacets(self):
+      mesh = UnitSquare (3, 3)
+      mesh.init(2,1)
+      ncells = mesh.num_cells()
+      f = MeshValueCollection("int", 1)
+      all_new = True
+      for cell in cells(mesh):
+          value = ncells - cell.index()
+          for i, facet in enumerate(facets(cell)):
+              all_new = all_new and f.set_value(cell.index(), i, value+i)
+
+      g = MeshValueCollection("int", 1)
+      g.assign(f)
+      self.assertEqual(ncells*3, f.size())
+      self.assertEqual(ncells*3, g.size())
+      self.assertTrue(all_new)
+      
+      for cell in cells(mesh):
+          value = ncells - cell.index()
+          for i, facet in enumerate(facets(cell)):
+              self.assertEqual(value+i, g.get_value(cell.index(), i))
+          
+  def testAssign2DVertices(self):
+      mesh = UnitSquare (3, 3)
+      mesh.init(2,0)
+      ncells = mesh.num_cells()
+      f = MeshValueCollection("int", 0)
+      all_new = True
+      for cell in cells(mesh):
+          value = ncells - cell.index()
+          for i, vert in enumerate(vertices(cell)):
+              all_new = all_new and f.set_value(cell.index(), i, value+i)
+
+      g = MeshValueCollection("int", 0)
+      g.assign(f)
+      self.assertEqual(ncells*3, f.size())
+      self.assertEqual(ncells*3, g.size())
+      self.assertTrue(all_new)
+      
+      for cell in cells(mesh):
+          value = ncells - cell.index()
+          for i, vert in enumerate(vertices(cell)):
+              self.assertEqual(value+i, g.get_value(cell.index(), i))
+          
+  def testMeshFunctionAssign2DCells(self):
+      mesh = UnitSquare (3, 3)
+      ncells = mesh.num_cells()
+      f = CellFunction("int", mesh)
+      for cell in cells(mesh):
+          f[cell] = ncells - cell.index()
+
+      g = MeshValueCollection("int", 2)
+      g.assign(f)
+      self.assertEqual(ncells, f.size())
+      self.assertEqual(ncells, g.size())
+      
+      for cell in cells(mesh):
+          value = ncells - cell.index()
+          self.assertEqual(value, g.get_value(cell.index(), 0))
+          
+  def testMeshFunctionAssign2DFacets(self):
+      mesh = UnitSquare (3, 3)
+      mesh.init(1)
+      f = FacetFunction("int", mesh, 25)
+      g = MeshValueCollection("int", 1)
+      g.assign(f)
+      self.assertEqual(mesh.num_facets(), f.size())
+      self.assertEqual(mesh.num_cells()*3, g.size())
+      
+      for cell in cells(mesh):
+          for i, facet in enumerate(facets(cell)):
+              self.assertEqual(25, g.get_value(cell.index(), i))
+          
+  def testMeshFunctionAssign2DVertices(self):
+      mesh = UnitSquare (3, 3)
+      mesh.init(0)
+      f = VertexFunction("int", mesh, 25)
+      g = MeshValueCollection("int", 0)
+      g.assign(f)
+      self.assertEqual(mesh.num_vertices(), f.size())
+      self.assertEqual(mesh.num_cells()*3, g.size())
+      
+      for cell in cells(mesh):
+          for i, vert in enumerate(vertices(cell)):
+              self.assertEqual(25, g.get_value(cell.index(), i))
+          
+if __name__ == "__main__":
+    unittest.main()

=== modified file 'test/unit/test.py'
--- test/unit/test.py	2011-10-23 08:23:30 +0000
+++ test/unit/test.py	2011-10-31 20:45:51 +0000
@@ -34,7 +34,7 @@
     "fem":            ["Assembly", "DirichletBC", "FiniteElement", "DofMap"],
     "function":       ["Function", "FunctionSpace", "Expression", "Constant"],
     "math":           ["basic"],
-    "mesh":           ["test", "MeshFunction", "Edge", "Face"],
+    "mesh":           ["test", "MeshFunction", "Edge", "Face", "MeshValueCollection"],
     "meshconvert":    ["test"],
     "refinement":     ["refine"],
     "la":             ["test", "Scalar", "Vector", "Matrix"],