Merge lp:~nschloe/dolfin/exodus into lp:~fenics-core/dolfin/trunk

[Nico Schlömer]

This is essentially an update of a former attempt at getting proper Exodus support into Dolfin, with the exception that it behaves gracefully if the present VTK installation doesn't have Exodus support.

[lp:~nschloe/dolfin/exodus]

7482. By Nico Schlömer on 2013-02-28

actually add defintion -DHAS_VTK_EXODUS

7483. By Nico Schlömer on 2013-02-28

nest HAS_VTK and HAS_VTK_EXODUS

7484. By Nico Schlömer on 2013-02-28

Unit* -> Unit*Mesh in Exodus tests

[Anders Logg (logg)]

Hi Nico, what's the status of your patch? If you sync it with trunk I can merge it in (if it looks good).

[lp:~nschloe/dolfin/exodus]

7485. By Nico Schlömer on 2013-03-07

merge with HEAD

[Nico Schlömer (nschloe)]

It's merged now, still looking good.

[Anders Logg (logg)]

On Thu, Mar 07, 2013 at 10:58:22PM -0000, Nico Schlömer wrote:
> It's merged now, still looking good.

ok, I'll try looking at it tomorrow. It might now make 1.2 but there
will be new releases.

--
Anders

[Nico Schlömer (nschloe)]

Shorter release cycles ftw. https://en.wikipedia.org/wiki/Release_early,_release_often ;)

[Anders Logg (logg)]

Doesn't seem to work for me. Did you forget to merge in File.cpp?

Error: Unable to open file.
*** Reason: Unknown file type (".e") for file "mesh.e".
*** Where: This error was encountered inside File.cpp.
*** Process: 0

[lp:~nschloe/dolfin/exodus]

7486. By Nico Schlömer on 2013-03-11

merge with HEAD

7487. By Nico Schlömer on 2013-03-11

added CMake status message if vtkExodusWriter isn't found

[Nico Schlömer (nschloe)]

Exodus file writing is only activated if the system VTK has Exodus support. There's some CMake logic to check for it, and I just added a status message if it's not found (which may be the case on your system). With the default Ubuntu VTK, for example, it does work.

If you want to try it out again, you should either see a configure time status message about missing Exodus or it should work.

[Anders Logg (logg)]

On Mon, Mar 11, 2013 at 12:52:24PM -0000, Nico Schlömer wrote:
> Exodus file writing is only activated if the system VTK has Exodus support. There's some CMake logic to check for it, and I just added a status message if it's not found (which may be the case on your system). With the default Ubuntu VTK, for example, it does work.
> If you want to try it out again, you should either see a configure time status message about missing Exodus or it should work.

The unit test should work regardless of whether VTK has Exodus
support.

I suggest adding:

1. a runtime error (dolfin_error) if VTK Exodus is missing (in
   File.cpp) instead of just missing file format

2. a runtime check in the unit test so that it is skipped if the VTK
   Exodus format is missing

--
Anders

[lp:~nschloe/dolfin/exodus]

7488. By Nico Schlömer on 2013-03-11

added dolfin::has_exodus() and include Exodus unit tests conditionally on this

[Nico Schlömer (nschloe)]

Ah, the unit test, of course.
I now went the same way that HDF5 and XDMF support is handled: defines.cpp now features a has_exodus() helper function, and the unit tests are added only if it returns `true`.

[Anders Logg (logg)]

On Mon, Mar 11, 2013 at 01:16:17PM -0000, Nico Schlömer wrote:
> Ah, the unit test, of course.
> I now went the same way that HDF5 and XDMF support is handled: defines.cpp now features a has_exodus() helper function, and the unit tests are added only if it returns `true`.

Thanks, looks good now.

--
Anders

=== modified file 'dolfin/CMakeLists.txt'
--- dolfin/CMakeLists.txt	2013-03-02 20:24:12 +0000
+++ dolfin/CMakeLists.txt	2013-03-11 13:15:27 +0000
@@ -250,6 +250,21 @@
     endif()
   endif()
 
+  # Check if the VTK-Exodus library is found.
+  # Normally, it should be included in libvtkParallel.so (check out the output
+  # of
+  #     $ nm -D /usr/lib/libvtkParallel.so | grep ExodusIIWriter
+  # but on some systems, this doesn't seem to be the case. Check if the
+  # appropriate header exists and store this information in HAS_VTK_EXODUS.
+  include(CheckIncludeFileCXX)
+  set(CMAKE_REQUIRED_INCLUDES "${VTK_INCLUDE_DIRS}")
+  CHECK_INCLUDE_FILE_CXX(vtkExodusIIWriter.h  HAS_VTK_EXODUS)
+  if(HAS_VTK_EXODUS)
+    list(APPEND DOLFIN_CXX_DEFINITIONS "-DHAS_VTK_EXODUS")
+  else()
+    message(STATUS "vtkExodusIIWriter not found, disabling Exodus file writing")
+  endif()
+
   list(APPEND DOLFIN_TARGET_LINK_LIBRARIES ${DOLFIN_VTK_LIBRARIES})
 endif()
 

=== modified file 'dolfin/common/defines.cpp'
--- dolfin/common/defines.cpp	2012-09-14 08:39:20 +0000
+++ dolfin/common/defines.cpp	2013-03-11 13:15:27 +0000
@@ -122,3 +122,12 @@
 #endif
 }
 //-------------------------------------------------------------------------
+bool dolfin::has_exodus()
+{
+#ifdef HAS_VTK_EXODUS
+  return true;
+#else
+  return false;
+#endif
+}
+//-------------------------------------------------------------------------

=== modified file 'dolfin/common/defines.h'
--- dolfin/common/defines.h	2012-09-14 08:39:20 +0000
+++ dolfin/common/defines.h	2013-03-11 13:15:27 +0000
@@ -61,6 +61,9 @@
   // Return true if DOLFIN is compiled with HDF5
   bool has_hdf5();
 
+  // Return true if DOLFIN is compiled with Exodus
+  bool has_exodus();
+
 }
 
 #endif

=== added file 'dolfin/io/ExodusFile.cpp'
--- dolfin/io/ExodusFile.cpp	1970-01-01 00:00:00 +0000
+++ dolfin/io/ExodusFile.cpp	2013-03-11 13:15:27 +0000
@@ -0,0 +1,335 @@
+// Copyright (C) 2013 Nico Schlömer
+//
+// 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:  2013-02-27
+
+#ifdef HAS_VTK
+#ifdef HAS_VTK_EXODUS
+
+#include <dolfin/fem/GenericDofMap.h>
+#include <dolfin/function/Function.h>
+#include <dolfin/function/FunctionSpace.h>
+#include <dolfin/la/GenericVector.h>
+#include <dolfin/mesh/Mesh.h>
+#include <dolfin/mesh/MeshFunction.h>
+#include "ExodusFile.h"
+
+#include <vtkUnsignedIntArray.h>
+#include <vtkIntArray.h>
+#include <vtkDoubleArray.h>
+#include <vtkCellType.h>
+#include <vtkPointData.h>
+#include <vtkCellData.h>
+#include <vtkCellArray.h>
+#include <vtkIdTypeArray.h>
+#include <vtkUnstructuredGrid.h>
+#include <vtkExodusIIWriter.h>
+
+using namespace dolfin;
+
+//----------------------------------------------------------------------------
+ExodusFile::ExodusFile(const std::string filename)
+  : GenericFile(filename, "Exodus")
+{
+}
+//----------------------------------------------------------------------------
+ExodusFile::~ExodusFile()
+{
+  // Do nothing
+}
+//----------------------------------------------------------------------------
+void ExodusFile::operator<<(const Mesh& mesh)
+{
+  perform_write(create_vtk_mesh(mesh));
+  log(TRACE, "Saved mesh %s (%s) to file %s in Exodus format.",
+      mesh.name().c_str(), mesh.label().c_str(), _filename.c_str());
+  return;
+}
+//----------------------------------------------------------------------------
+void ExodusFile::operator<<(const MeshFunction<unsigned int>& meshfunction)
+{
+  const Mesh& mesh = meshfunction.mesh();
+  const uint cell_dim = meshfunction.dim();
+
+  // Throw error for MeshFunctions on vertices for interval elements
+  if (mesh.topology().dim() == 1 && cell_dim == 0)
+  {
+    dolfin_error("ExodusFile.cpp",
+                 "write mesh function to Exodus file",
+                 "Exodus output of mesh functions on interval facets is not supported");
+  }
+
+  if (cell_dim != mesh.topology().dim() && cell_dim != mesh.topology().dim() - 1)
+  {
+    dolfin_error("ExodusFile.cpp",
+                 "write mesh function to Exodus file",
+                 "Exodus output of mesh functions is implemented for cell- and facet-based functions only");
+  }
+
+  // Create Exodus mesh.
+  vtkSmartPointer<vtkUnstructuredGrid> vtk_mesh = create_vtk_mesh(mesh);
+
+  // Add cell data.
+  const int dim = meshfunction.dim();
+  const int numCells = mesh.num_cells();
+  vtkSmartPointer<vtkUnsignedIntArray> cellData =
+    vtkSmartPointer<vtkUnsignedIntArray>::New();
+  cellData->SetNumberOfComponents(dim);
+  cellData->SetArray(const_cast<unsigned int*>(meshfunction.values()), dim*numCells, 1);
+  cellData->SetName(meshfunction.name().c_str());
+  vtk_mesh->GetCellData()->AddArray(cellData);
+
+  // Write out.
+  perform_write(vtk_mesh);
+
+  log(TRACE, "Saved mesh function %s (%s) to file %s in Exodus format.",
+      mesh.name().c_str(), mesh.label().c_str(), _filename.c_str());
+}
+//----------------------------------------------------------------------------
+void ExodusFile::operator<<(const MeshFunction<int>& meshfunction)
+{
+  const Mesh& mesh = meshfunction.mesh();
+  const uint cell_dim = meshfunction.dim();
+
+  // Throw error for MeshFunctions on vertices for interval elements
+  if (mesh.topology().dim() == 1 && cell_dim == 0)
+  {
+    dolfin_error("ExodusFile.cpp",
+                 "write mesh function to Exodus file",
+                 "Exodus output of mesh functions on interval facets is not supported");
+  }
+
+  if (cell_dim != mesh.topology().dim() && cell_dim != mesh.topology().dim() - 1)
+  {
+    dolfin_error("ExodusFile.cpp",
+                 "write mesh function to Exodus file",
+                 "Exodus output of mesh functions is implemented for cell- and facet-based functions only");
+  }
+
+  // Create Exodus mesh.
+  vtkSmartPointer<vtkUnstructuredGrid> vtk_mesh = create_vtk_mesh(mesh);
+
+  // Add cell data.
+  const int dim = meshfunction.dim();
+  const int numCells = mesh.num_cells();
+  vtkSmartPointer<vtkIntArray> cellData =
+    vtkSmartPointer<vtkIntArray>::New();
+  cellData->SetNumberOfComponents(dim);
+  cellData->SetArray(const_cast<int*>(meshfunction.values()), dim*numCells, 1);
+  cellData->SetName(meshfunction.name().c_str());
+  vtk_mesh->GetCellData()->AddArray(cellData);
+
+  // Write out.
+  perform_write(vtk_mesh);
+
+  log(TRACE, "Saved mesh function %s (%s) to file %s in Exodus format.",
+      mesh.name().c_str(), mesh.label().c_str(), _filename.c_str());
+}
+//----------------------------------------------------------------------------
+void ExodusFile::operator<<(const MeshFunction<double>& meshfunction)
+{
+  const Mesh& mesh = meshfunction.mesh();
+  const uint cell_dim = meshfunction.dim();
+
+  // Throw error for MeshFunctions on vertices for interval elements
+  if (mesh.topology().dim() == 1 && cell_dim == 0)
+  {
+    dolfin_error("ExodusFile.cpp",
+                 "write mesh function to Exodus file",
+                 "Exodus output of mesh functions on interval facets is not supported");
+  }
+
+  if (cell_dim != mesh.topology().dim() && cell_dim != mesh.topology().dim() - 1)
+  {
+    dolfin_error("ExodusFile.cpp",
+                 "write mesh function to Exodus file",
+                 "Exodus output of mesh functions is implemented for cell- and facet-based functions only");
+  }
+
+  // Create Exodus mesh.
+  vtkSmartPointer<vtkUnstructuredGrid> vtk_mesh = create_vtk_mesh(mesh);
+
+  // Add cell data.
+  const int dim = meshfunction.dim();
+  const int numCells = mesh.num_cells();
+  vtkSmartPointer<vtkDoubleArray> cellData =
+    vtkSmartPointer<vtkDoubleArray>::New();
+  cellData->SetNumberOfComponents(dim);
+  cellData->SetArray(const_cast<double*>(meshfunction.values()), dim*numCells, 1);
+  cellData->SetName(meshfunction.name().c_str());
+  vtk_mesh->GetCellData()->AddArray(cellData);
+
+  // Write out.
+  perform_write(vtk_mesh);
+
+  log(TRACE, "Saved mesh function %s (%s) to file %s in Exodus format.",
+      mesh.name().c_str(), mesh.label().c_str(), _filename.c_str());
+}
+//----------------------------------------------------------------------------
+void ExodusFile::operator<<(const Function& u)
+{
+  u.update();
+  write_function(u, counter);
+}
+//----------------------------------------------------------------------------
+void ExodusFile::operator<<(const std::pair<const Function*, double> u)
+{
+  dolfin_assert(u.first);
+  u.first->update();
+  write_function(*(u.first), u.second);
+}
+//----------------------------------------------------------------------------
+void ExodusFile::write_function(const Function& u, double time) const
+{
+  // Write results
+  // Get rank of Function
+  const uint rank = u.value_rank();
+  if (rank > 2)
+  {
+    dolfin_error("ExodusFile.cpp",
+                 "write data to Exodus file",
+                 "Only scalar, vector and tensor functions can be saved in Exodus format");
+  }
+
+  // Get number of components
+  const uint dim = u.value_size();
+
+  // Check that function type can be handled, cf.
+  // http://www.vtk.org/Bug/view.php?id=13508.
+  if (dim > 6)
+  {
+    dolfin_error("ExodusFile.cpp",
+                 "write data to Exodus file",
+                 "Can't handle more than 6 components");
+  }
+
+  // Test for cell-based element type
+  dolfin_assert(u.function_space()->mesh());
+  const Mesh& mesh = *u.function_space()->mesh();
+
+  vtkSmartPointer<vtkUnstructuredGrid> vtk_mesh =
+    create_vtk_mesh(mesh);
+
+  uint cell_based_dim = 1;
+  for (uint i = 0; i < rank; i++)
+    cell_based_dim *= mesh.topology().dim();
+
+  dolfin_assert(u.function_space()->dofmap());
+  const GenericDofMap& dofmap = *u.function_space()->dofmap();
+  // Define the vector that holds the values outside the if
+  // to make sure it doesn't get destroyed before the data
+  // is written out to a file
+  std::vector<double> values;
+  if (dofmap.max_cell_dimension() == cell_based_dim)
+  {
+    // Extract DOFs from u.
+    const uint num_cells = mesh.num_cells();
+    const uint size = num_cells*dim;
+    std::vector<int> dof_set;
+    for (CellIterator cell(mesh); !cell.end(); ++cell)
+    {
+      const std::vector<int>& dofs = dofmap.cell_dofs(cell->index());
+      for(uint i = 0; i < dofmap.cell_dimension(cell->index()); ++i)
+        dof_set.push_back(dofs[i]);
+    }
+    // Get  values
+    values.resize(dof_set.size());
+    dolfin_assert(u.vector());
+    u.vector()->get_local(&values[0], dof_set.size(), &dof_set[0]);
+
+    // Set the cell array.
+    vtkSmartPointer<vtkDoubleArray> cellData =
+      vtkSmartPointer<vtkDoubleArray>::New();
+    cellData->SetNumberOfComponents(dim);
+    cellData->SetArray(&values[0], dof_set.size(), 1);
+    cellData->SetName(u.name().c_str());
+    vtk_mesh->GetCellData()->AddArray(cellData);
+  }
+  else
+  {
+    // Extract point values.
+    const uint num_vertices = mesh.num_vertices();
+    const uint size = num_vertices*dim;
+    values.resize(size);
+    u.compute_vertex_values(values, mesh);
+    // Set the point array.
+    vtkSmartPointer<vtkDoubleArray> pointData =
+      vtkSmartPointer<vtkDoubleArray>::New();
+    pointData->SetNumberOfComponents(dim);
+    pointData->SetArray(&values[0], size, 1);
+    pointData->SetName(u.name().c_str());
+    vtk_mesh->GetPointData()->AddArray(pointData);
+  }
+
+  // Actually write out the data.
+  perform_write(vtk_mesh);
+
+  log(TRACE, "Saved function %s (%s) to file %s in Exodus format.",
+      u.name().c_str(), u.label().c_str(), _filename.c_str());
+}
+//----------------------------------------------------------------------------
+vtkSmartPointer<vtkUnstructuredGrid> ExodusFile::create_vtk_mesh(const Mesh& mesh) const
+{
+  // Build Exodus unstructured grid object.
+  vtkSmartPointer<vtkUnstructuredGrid> unstructuredGrid =
+    vtkSmartPointer<vtkUnstructuredGrid>::New();
+  // Set the points.
+  const int numPoints = mesh.num_vertices();
+  vtkSmartPointer<vtkDoubleArray> pointData =
+    vtkSmartPointer<vtkDoubleArray>::New();
+  pointData->SetNumberOfComponents(3);
+  pointData->SetArray(const_cast<double*>(&mesh.coordinates()[0]), 3*numPoints, 1);
+  vtkSmartPointer<vtkPoints> points =
+    vtkSmartPointer<vtkPoints>::New();
+  points->SetData(pointData);
+  unstructuredGrid->SetPoints(points);
+  // Set cells. Those need to be copied over since the
+  // default Dolfin node ID data type is dolfin::uint
+  // (typically unsigned int), and the node ID of Exodus
+  // is vtkIdType (typically long long int).
+  const int numCells = mesh.num_cells();
+  const std::vector<unsigned int> cells = mesh.cells();
+  vtkSmartPointer<vtkCellArray> cellData =
+    vtkSmartPointer<vtkCellArray>::New();
+  vtkIdType tmp[4];
+  for (int k=0; k<numCells; k++)
+  {
+    for (int i=0; i<4; i++)
+      tmp[i] = cells[4*k+i];
+    cellData->InsertNextCell(4, tmp);
+  }
+  unstructuredGrid->SetCells(VTK_TETRA, cellData);
+
+  return unstructuredGrid;
+}
+//----------------------------------------------------------------------------
+void ExodusFile::perform_write(const vtkSmartPointer<vtkUnstructuredGrid> & vtk_mesh) const
+{
+  // Instantiate writer.
+  vtkSmartPointer<vtkExodusIIWriter> writer =
+    vtkSmartPointer<vtkExodusIIWriter>::New();
+
+  // Write out to file.
+  writer->SetFileName(_filename.c_str());
+  writer->SetInput(vtk_mesh);
+  writer->Write();
+
+  return;
+}
+//----------------------------------------------------------------------------
+#endif // HAS_VTK_EXODUS
+#endif // HAS_VTK

=== added file 'dolfin/io/ExodusFile.h'
--- dolfin/io/ExodusFile.h	1970-01-01 00:00:00 +0000
+++ dolfin/io/ExodusFile.h	2013-03-11 13:15:27 +0000
@@ -0,0 +1,75 @@
+// Copyright (C) 2013 Nico Schlömer
+//
+// 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:  2013-02-27
+
+#ifndef __EXODUS_FILE_H
+#define __EXODUS_FILE_H
+
+#ifdef HAS_VTK
+#ifdef HAS_VTK_EXODUS
+
+#include "GenericFile.h"
+
+#include <vtkSmartPointer.h>
+
+// forward declarations
+class vtkUnstructuredGrid;
+
+namespace dolfin
+{
+
+  /// This class supports the output of meshes and functions
+  /// Exodus format for visualistion purposes. It is not suitable to
+  /// checkpointing as it may decimate some data.
+
+  class ExodusFile : public GenericFile
+  {
+  public:
+
+    ExodusFile(const std::string filename);
+    ~ExodusFile();
+
+    void operator<< (const Mesh& mesh);
+    void operator<< (const MeshFunction<unsigned int>& meshfunction);
+    void operator<< (const MeshFunction<int>& meshfunction);
+    void operator<< (const MeshFunction<double>& meshfunction);
+    void operator<< (const Function& u);
+    void operator<< (const std::pair<const Function*, double> u);
+
+private:
+
+    void write_function(const Function& u, double time) const;
+
+    vtkSmartPointer<vtkUnstructuredGrid> create_vtk_mesh(const Mesh& mesh) const;
+
+    void perform_write(const vtkSmartPointer<vtkUnstructuredGrid> & vtk_mesh) const;
+
+    // File encoding
+    const std::string encoding;
+    std::string encode_string;
+
+    bool binary;
+    bool compress;
+
+  };
+
+}
+
+#endif // HAS_VTK_EXODUS
+#endif // HAS_VTK
+#endif // __EXODUS_FILE_H

=== modified file 'dolfin/io/File.cpp'
--- dolfin/io/File.cpp	2013-03-04 11:44:12 +0000
+++ dolfin/io/File.cpp	2013-03-11 13:15:27 +0000
@@ -33,6 +33,7 @@
 #include "BinaryFile.h"
 #include "RAWFile.h"
 #include "VTKFile.h"
+#include "ExodusFile.h"
 #include "XMLFile.h"
 #include "XYZFile.h"
 #include "XDMFFile.h"
@@ -73,6 +74,12 @@
     file.reset(new XMLFile(filename));
   else if (extension == ".pvd")
     file.reset(new VTKFile(filename, encoding));
+#ifdef HAS_VTK
+#ifdef HAS_VTK_EXODUS
+  else if (extension == ".e")
+    file.reset(new ExodusFile(filename));
+#endif
+#endif
   else if (extension == ".raw")
     file.reset(new RAWFile(filename));
   else if (extension == ".xyz")

=== added file 'test/unit/io/python/Exodus.py'
--- test/unit/io/python/Exodus.py	1970-01-01 00:00:00 +0000
+++ test/unit/io/python/Exodus.py	2013-03-11 13:15:27 +0000
@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+"""Unit tests for the Exodus io library"""
+
+# Copyright (C) 2013 Nico Schlömer
+#
+# 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:  2013-02-27
+# Last changed: 2013-03-11
+
+import unittest
+from dolfin import *
+
+if has_exodus():
+    class Exodus_Mesh_Output(unittest.TestCase):
+        """Test output of Meshes to Exodus files"""
+
+        def test_save_1d_mesh(self):
+            if MPI.num_processes() == 1:
+                mesh = UnitIntervalMesh(32)
+                File("mesh.e") << mesh
+
+        def test_save_2d_mesh(self):
+            mesh = UnitSquareMesh(32, 32)
+            File("mesh.e") << mesh
+
+        def test_save_3d_mesh(self):
+            mesh = UnitCubeMesh(8, 8, 8)
+            File("mesh.e") << mesh
+
+
+    class Exodus_Point_Function_Output(unittest.TestCase):
+        """Test output of point-based Functions to Exodus files"""
+
+        def test_save_1d_scalar(self):
+            if MPI.num_processes() == 1:
+                mesh = UnitIntervalMesh(32)
+                u = Function(FunctionSpace(mesh, "Lagrange", 2))
+                u.vector()[:] = 1.0
+                File("u.e") << u
+
+        def test_save_2d_scalar(self):
+            mesh = UnitSquareMesh(16, 16)
+            u = Function(FunctionSpace(mesh, "Lagrange", 2))
+            u.vector()[:] = 1.0
+            File("u.e") << u
+
+        def test_save_3d_scalar(self):
+            mesh = UnitCubeMesh(8, 8, 8)
+            u = Function(FunctionSpace(mesh, "Lagrange", 2))
+            u.vector()[:] = 1.0
+            File("u.e") << u
+
+        def test_save_2d_vector(self):
+            mesh = UnitSquareMesh(16, 16)
+            u = Function(VectorFunctionSpace(mesh, "Lagrange", 2))
+            u.vector()[:] = 1.0
+            File("u.e") << u
+
+        def test_save_3d_vector(self):
+            mesh = UnitCubeMesh(8, 8, 8)
+            u = Function(VectorFunctionSpace(mesh, "Lagrange", 2))
+            u.vector()[:] = 1.0
+            File("u.e") << u
+
+        def test_save_2d_tensor(self):
+            mesh = UnitSquareMesh(16, 16)
+            u = Function(TensorFunctionSpace(mesh, "Lagrange", 2))
+            u.vector()[:] = 1.0
+            File("u.e") << u
+
+        #def test_save_3d_tensor(self):
+        #    mesh = UnitCubeMesh(8, 8, 8)
+        #    u = Function(TensorFunctionSpace(mesh, "Lagrange", 2))
+        #    u.vector()[:] = 1.0
+        #    File("u.e") << u
+
+if __name__ == "__main__":
+    unittest.main()