Commits

Matt Knepley  committed 96bf7e3

DMMesh: Cleaned up some old references and removed some out-dated files

  • Participants
  • Parent commits 04ceabe

Comments (0)

Files changed (6)

File bin/processSummary.py

-#!/usr/bin/env python
-import user
-import script
-
-class LogSummarizer(script.Script):
-  transforms = [
-    (', boost::tuples::null_type', ''),
-    ('ALE::pair<ALE::Point, int>', 'Rank'),
-    ('ALE::Sieve<ALE::Point, int, int>', 'Topology'),
-    ('ALE::CoSifter<Topology, ALE::Point, ALE::Point, int>', 'Bundle'),
-    ('ALE::CoSifter<Topology, ALE::Point, ALE::Point, double>', 'Field'),
-    ('ALE::CoSifter<Topology, Rank, ALE::Point, int>', 'RankBundle'),
-    ('ALE::CoSifter<Topology, Rank, ALE::Point, double>', 'RankField'),
-    ('std::less<ALE::Point>', 'lessPoint'),
-    ('std::less<Rank >', 'lessRank'),
-    ('Bundle::trueFunc<ALE::Point>', 'trueFunc'),
-    ('RankField::trueFunc<ALE::Point>', 'trueFunc'),
-    ('Field::trueFunc<ALE::Point>', 'trueFunc'),
-    ('boost::multi_index::composite_key_compare<lessPoint, lessPoint, lessPoint>', 'stdCompare'),
-    ('boost::multi_index::composite_key_compare<lessPoint, std::less<int>, lessPoint>', 'stdCompareInt'),
-    ('boost::multi_index::composite_key_compare<lessPoint, trueFunc, lessPoint>', 'orderCompare'),
-    ('boost::multi_index::composite_key_compare<lessPoint, trueFunc, lessRank>', 'orderRankCompare'),
-    ('ALE::array<ALE::Point>', 'PointArray'),
-    ('ALE::set<ALE::Point>', 'PointSet'),
-    ('std::vector<ALE::Point, std::allocator<ALE::Point> >', 'PointVec'),
-    ('std::set<int, std::less<int>, std::allocator<int> >', 'IntSet'),
-    ('ALE::SifterDef::Arrow<ALE::Point, ALE::Point, ALE::Point>', 'Arrow'),
-    ('ALE::SifterDef::Arrow<ALE::Point, ALE::Point, int>', 'IntArrow'),
-    ('ALE::SifterDef::Arrow<ALE::Point, Rank, ALE::Point>', 'RankArrow'),
-    ('ALE::SifterDef::Arrow<int, ALE::Point, ALE::pair<ALE::Point, ALE::pair<int, int> > >', 'OverlapArrow'),
-    ('ALE::SifterDef::Arrow<ALE::Point, int, ALE::pair<ALE::Point, ALE::pair<int, int> > >', 'FlipOverlapArrow'),
-    ('ALE::SifterDef::Arrow<int, ALE::pair<int, ALE::Point>, ALE::pair<ALE::Point, ALE::pair<int, int> > >', 'BiOverlapArrow'),
-    ('ALE::SifterDef::Arrow<ALE::pair<int, ALE::Point>, int, ALE::pair<ALE::Point, ALE::pair<int, int> > >', 'FlipBiOverlapArrow'),
-    ('ALE::SifterDef::Rec<ALE::Point>', 'Point'),
-    ('ALE::SifterDef::Rec<Rank >', 'RankPoint'),
-    ('ALE::SifterDef::Rec<int>', 'IntPoint'),
-    ('ALE::SifterDef::Rec<ALE::pair<int, ALE::Point> >', 'IPPairPoint'),
-    ('ALE::SieveDef::Rec<ALE::Point, int>', 'Point&Int'),
-    ('ALE::SieveDef::Rec<int, ALE::Point>', 'Int&Point'),
-    ('ALE::SifterDef::RecContainerTraits<ALE::Point, Point >', 'SifterRecTraits'),
-    ('ALE::SifterDef::RecContainerTraits<int, IntPoint >', 'OverlapRecTraits'),
-    ('ALE::SieveDef::RecContainerTraits<ALE::Point, Point&Int >', ' SieveRecTraits'),
-    ('ALE::SifterDef::RecContainer<ALE::Point, Point >', 'SifterRecCon'),
-    ('ALE::SifterDef::RecContainer<Rank, RankPoint >', 'RankRecCon'),
-    ('ALE::SifterDef::RecContainer<int, IntPoint >', 'OverlapRecCon'),
-    ('ALE::SifterDef::RecContainer<ALE::pair<int, ALE::Point>, IPPairPoint >', 'BiOverlapRecCon'),
-    ('ALE::SieveDef::RecContainer<ALE::Point, Point&Int >', 'SieveRecCon'),
-    ('SifterRecTraits::PointSequence', 'SifPointSeq'),
-    ('OverlapRecTraits::PointSequence', 'OvPointSeq'),
-    ('SieveRecTraits::PointSequence', 'SivPointSeq'),
-    ('SieveRecTraits::TwoValueSequence< SieveRecTraits::heightMarkerTag, int>', 'HeightSeq'),
-    ('SieveRecTraits::TwoValueSequence< SieveRecTraits::depthMarkerTag, int>', 'DepthSeq'),
-    ('ALE::RightSequenceDuplicator<ALE::ConeArraySequence<Arrow > >', 'SeqDup'),
-    ('ALE::RightSequenceDuplicator<ALE::ConeArraySequence<IntArrow > >', 'IntSeqDup'),
-    ('ALE::Sifter<ALE::Point, ALE::Point, ALE::Point, orderCompare, SifterRecCon, SifterRecCon >', 'Order'),
-    ('ALE::Sifter<ALE::Point, ALE::Point, ALE::Point, stdCompare, SifterRecCon, SifterRecCon >', 'ReOrder'),
-    ('ALE::Sifter<ALE::Point, Rank, ALE::Point, orderRankCompare, SifterRecCon, RankRecCon >', 'RankOrder'),
-    ('ALE::ASifter<int, ALE::Point, ALE::pair<ALE::Point, ALE::pair<int, int> >, (ALE::SifterDef::ColorMultiplicity)1, boost::multi_index::composite_key_compare<std::less<int>, std::less<ALE::pair<ALE::Point, ALE::pair<int, int> > >, lessPoint>, OverlapRecCon, SifterRecCon >', 'Overlap'),
-    ('ALE::ASifter<ALE::Point, int, ALE::pair<ALE::Point, ALE::pair<int, int> >, (ALE::SifterDef::ColorMultiplicity)1, boost::multi_index::composite_key_compare<lessPoint, std::less<ALE::pair<ALE::Point, ALE::pair<int, int> > >, std::less<int>>, SifterRecCon, OverlapRecCon >', 'FlipOverlap'),
-    ('ALE::ASifter<int, ALE::pair<int, ALE::Point>, ALE::pair<ALE::Point, ALE::pair<int, int> >, (ALE::SifterDef::ColorMultiplicity)1, boost::multi_index::composite_key_compare<std::less<int>, std::less<ALE::pair<ALE::Point, ALE::pair<int, int> > >, std::less<ALE::pair<int, ALE::Point> >>, OverlapRecCon, BiOverlapRecCon >', 'BiOverlap'),
-    ('ALE::ASifter<ALE::pair<int, ALE::Point>, int, ALE::pair<ALE::Point, ALE::pair<int, int> >, (ALE::SifterDef::ColorMultiplicity)1, boost::multi_index::composite_key_compare<std::less<ALE::pair<int, ALE::Point> >, std::less<ALE::pair<ALE::Point, ALE::pair<int, int> > >, std::less<int>>, BiOverlapRecCon, OverlapRecCon >', 'FlipBiOverlap'),
-    ('ALE::ASifter<ALE::Point, ALE::Point, int, (ALE::SifterDef::ColorMultiplicity)1, stdCompareInt, SieveRecCon, SieveRecCon >::traits::coneSequence', 'ConeSeq'),
-    ('ALE::ASifter<ALE::Point, ALE::Point, int, (ALE::SifterDef::ColorMultiplicity)1, stdCompareInt, SieveRecCon, SieveRecCon >::traits::supportSequence', 'SuppSeq'),
-    ('ALE::ASifter<ALE::Point, ALE::Point, ALE::Point, (ALE::SifterDef::ColorMultiplicity)1, stdCompare, SifterRecCon, SifterRecCon >::traits::coneSequence', 'OrderFusionCone'),
-    ('ALE::ASifter<ALE::Point, ALE::Point, ALE::Point, (ALE::SifterDef::ColorMultiplicity)1, stdCompare, SifterRecCon, SifterRecCon >::traits::supportSequence', 'OrderFusionSupp'),
-    ('ALE::ASifter<ALE::Point, ALE::Point, ALE::Point, (ALE::SifterDef::ColorMultiplicity)1, orderCompare, SifterRecCon, SifterRecCon >::traits::coneSequence', 'OrderCone'),
-    ('ALE::ASifter<ALE::Point, ALE::Point, ALE::Point, (ALE::SifterDef::ColorMultiplicity)1, orderCompare, SifterRecCon, SifterRecCon >::traits::supportSequence', 'OrderSupp'),
-    ('BiOverlap::traits::coneSequence', 'BiOverlapCone'),
-    ('BiOverlap::traits::supportSequence', 'BiOverlapSupp'),
-    ('FlipBiOverlap::traits::coneSequence', 'FlipBiOverlapCone'),
-    ('FlipBiOverlap::traits::supportSequence', 'FlipBiOverlapSupp'),
-    ('ALE::Flip<Order >', 'FlipOrder'),
-    ('ALE::Flip<ReOrder >', 'FlipReOrder'),
-    ('boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<Arrow > > > >', 'bArrow'),
-    ('boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<IntArrow > > > >', 'bIntArrow'),
-    ('boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<RankArrow > > > >', 'bRankArrow'),
-    ('boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<OverlapArrow > > > >', 'bOverlapArrow'),
-    ('boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<FlipOverlapArrow > > > >', 'bFlipOverlapArrow'),
-    ('boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<BiOverlapArrow > > > >', 'bBiOverlapArrow'),
-    ('boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<FlipBiOverlapArrow > > > >', 'bFlipBiOverlapArrow'),
-    ('boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<Point > >', 'bPoint'),
-    ('boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<Point&Int > > > > >', 'bIntPoint'),
-    ('boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<RankPoint > >', 'bRankPoint'),
-    ('boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<OverlapPoint > > > >', 'bOverlapPoint'),
-    ('boost::multi_index::detail::copy_map_entry<bArrow >', 'bArrowCopy'),
-    ('boost::multi_index::detail::copy_map_entry<bPoint >', 'bPointCopy'),
-    ('std::_Rb_tree_node<ALE::Point>', 'tPoint')
-    ]
-
-  removes = [
-    'Registered event',
-    'boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<ALE::SifterDef::Arrow<ALE::Point, ALE::Point, int> > > > >:',
-    'boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<ALE::SieveDef::Rec<ALE::Point, int> > > > > >:',
-    'boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<ALE::SifterDef::Arrow<ALE::Point, ALE::Point, ALE::Point> > > > >:',
-    'boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<ALE::SifterDef::Rec<ALE::Point> > >:',
-    'boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<ALE::SifterDef::Arrow<ALE::Point, ALE::pair<ALE::Point, int>, ALE::Point> > > > >:',
-    'boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<ALE::SifterDef::Rec<ALE::pair<ALE::Point, int> > > >:',
-    'boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<ALE::SifterDef::Rec<int> > >',
-    'boost::multi_index::detail::ordered_index_node<boost::multi_index::detail::index_node_base<ALE::SifterDef::Rec<ALE::pair<int, ALE::Point> > > >',
-    'std::_Rb_tree_node<ALE::Point>:',
-    'Obj:std::set<std::string',
-    'std::set<std::string'
-    ]
-
-  def setupHelp(self, help):
-    help = script.Script.setupHelp(self, help)
-    #help.addArgument('LogSummarizer', '-', nargs.ArgBool(None, 0, 'Print this help message', isTemporary = 1), ignoreDuplicates = 1)
-    return help
-
-  def filter(self, line):
-    for r in LogSummarizer.removes:
-      if line.startswith(r):
-        return ''
-    return line
-
-  def transform(self, line):
-    '''We could try to pick out just the event lines'''
-    for longName, shortName in LogSummarizer.transforms:
-      line = line.replace(longName, shortName)
-    return line
-
-  def process(self, inF, outF):
-    for line in inF.readlines():
-      line = self.filter(line)
-      line = self.transform(line)
-      outF.write(line)
-    return
-
-  def run(self):
-    import sys
-
-    self.setup()
-    self.process(sys.stdin, sys.stdout)
-    return
-
-if __name__ == '__main__':
-  LogSummarizer().run()

File src/docs/doxygen/Doxyfile

 # wildcard * is used, a substring. Examples: ANamespace, AClass,
 # AClass::ANamespace, ANamespace::*Test
 
-EXCLUDE_SYMBOLS        = __FUNCT__ ALE::PCICE
+EXCLUDE_SYMBOLS        = __FUNCT__
 
 # The EXAMPLE_PATH tag can be used to specify one or more files or
 # directories that contain example code fragments that are included (see
                          ../src/vec/pf/examples/tutorials/ \
                          ../src/ts/examples/tutorials/ \
                          ../src/dm/ao/examples/tutorials/ \
-                         ../src/dm/impls/mesh/examples/tutorials/ \
                          ../src/dm/examples/tutorials/ \
                          ../src/ksp/pc/examples/tutorials/ \
                          ../src/ksp/ksp/examples/tutorials/ \

File src/docs/strategy.tex

-	The purpose of this document is to outline the current strategic thinking for development across the PETSc
-group, including auxillary projects, and perhaps overlying projects such as TAO or SLEPc. The main thrusts should
-include not only technical justifications, but application partnerships and actual/possible funding sources. We will
-organize these thrusts into sections.
-
-\section{Definitions}
-
-   {\bf Stateless iterative solver} - An iterative process that, for each iteration, the algorithm depends {\bf only}
-on the current initial solution and the problem. The PCs in PETSc are stateless. The ``plain'' Newton's method in
-PETSc is stateless.
-
-   {\bf State iterative solver} - An iterative process where the algorithm depends directly on not only the current
-initial solution but additional information from previous iterations. The KSP methods in PETSc are state. Newton's method
-with lagged Jacobians or the E-W convergence test are state. Nonlinear CG and nonlinear GMES (and minimization methods
-such as l-BFGS) are state iterative solvers.
-
-   {\bf Stateless iterative solver implementation} - An implementation of a stateless iterative solver that is also
-stateless. Almost no implementation in PETSc is stateless, for example, the ILU PC computes the factorization initially
-which is then used for each iteration. Even Jacobi extracts the diagonal initially to use later. There is a generalization
-of this where the iterations do not depend directly on previous iterations (except through the initial solution) but
-do depend on initial setup (like the construction of the ILU factors), we will call these {\bf setup state only iterative solver
-implementations}. Stateless iterative solvers are {\bf only}
-implemented as setup state only for efficiency reasons (to prevent recomputation).
-
-  We will call stateless iterative solvers {\bf preconditioners} and state iterative solvers {\bf accelerators} or
-possibly Krylov methods or Krylov accelerators. Preconditioners can be viewed as ``simple'' transformations of the initial
-(nonlinear) algebraic problem that results in a new algebraic problem where simple iteration (nonlinear Richardson's method)
-may converge better. FAS is a preconditioner, nonlinear CG is an accelerator. Newton's method with a direct solver is a preconditioner but is
-funky because the transformation depends not only on the problem but also on the current initial solution; the transformed
-problem is $ J^{-1}(x^{n}) F(x^n)$. It is interesting to note that each transformation is linear (like for all linear preconditioners).
-Newton's method with an iterative method is an accelerator.
-
-
-\section{Matrix-Free Operation}
-
-	This is a large project of several interlocking parts. However, at a high level, the goal can be seen as
-elimination of parallel sparse matrices from the nonlinear solution process.
-
-	The first step in this process is the elimination of Newton's algorithm as the outer parallel solver for the
-nonlinear algebraic problem. Barry has cleaned up the existing FAS code, and introduced a point-block version. A summer
-student from Olof Widlund's group at NYU is also working along this line. She will hopefully examine effective
-{\bf accelerators}  for FAS. We expect to improve our performance from the dismal 5\% of peak numbers to somewhere around
-the STREAMS benchmark with these changes.
-
-	The next step involves better control of the mesh and discretization for common problems. FAS operates on sets
-of fully assembled matrix rows, as opposed to the common method of integrating each element at a time. Using FIAT and
-FFC, we have the ability to reorganize the computation to allow computation of one dof at a time. Here we also have the
-possibility of improving the efficiency yet again with sparser meshes supporting higher order elements.
-
-  \subsection{Parnerships}
-
-	The best test of these improvements is likely to come from the code under development by Ethan Coon at Columbia.
-
-  \subsection{Funding sources}
-
-	Hopefully our multiscale grant comes through. I would say this is also excellent for a followon SciDAC.
-
-\section{Scalability}
-
-	The idea here is to greatly increase the use of PETSc geometric multigrid, which we believe is greatly
-underutilized. To this end, we propose integrating several geometric multigrid algorithms currently in use in the
-geophysical community as PCMG implementations along the same line as the Sandia ML package.
-
-	I have sent an initial email to VPAC and Monash to initiate development of the first integration project. We
-will introduce the current St. Germaine multigrid into PETSc.
-
-  \subsection{Parnerships}
-
-	We will have strong support from CIG, and in particular Louis Moresi from Monash and Steve Quenette from VPAC.
-However we can also expect some help from Scott King at Purdue, John Baumgartner at LANL, and perhaps Marc Spiegelman at
-Columbia.
-
-  \subsection{Funding sources}
-
-	Initially all this money will be coming from CIG in the form of my support. However, it seems likely that we
-will be able to leverage work from the application partners.
-
-\section{Mesh Representation}
-
-	Dmitry and I have developed an extremely flexible and general topology representation which we call a Sieve.
-This mechanism will be integrated into the next version of PETSc. It provides a parallel unstructured mesh interface
-which will mirror DM, and allow a DM-like object to painlessly introduce scalable preconditioning into unstructured
-simulations like PCICE and PyLith.
-
-  \subsection{Parnerships}
-
-	We plan to use this initially in the PCICE code from Rich Martineau at INL, and PyLith from Charles Williams at
-RPI.
-
-  \subsection{Funding sources}
-
-	Right now, Rich Martineau is using some of his LDRD money for this. Dmitry hopes to receive funding for this in
-two recently submitted grants.

File src/docs/tex/manual/sieve.tex

-\section{Handling Unstructured Grids}
-
-    The main idea behind the \emph{Sieve} system for handling unstructured grids in PETSc is to separate the problem
-into two pieces: local interaction with unstructured meshes and global interaction between meshes distribute across a
-group of processes. In fact, the second piece may be used to stitch together pieces of a DA in exactly the same way, as
-will be described below. Our goal is to provide an interface independent of spatial dimension, discretization, and
-details of the mesh, but does provide more structure than a purely linear-algebraic interface.
-
-\subsection{Global Interaction}
-
-    The \code{VecScatter} mechanism in PETSc provides a structured way to move values among a group of
-processes. However, when applied at the application level is has a few drawbacks. \code{VecScatter} demands that the
-user provide indices to describe the mapping between vectors, but most application codes manipulate higher level
-objects, such as elements, making this mechanism too fine-grained. Moreover, \code{VecScatter} allows only two methods
-for combining remote and local values, addition and replacement, and only allows a one-to-one mapping between values.
-
-    The Sieve model is to split the scatter information into two parts, a mapping between Sieve points on different
-processes, called an \code{Overlap}, and an assignment of degrees of freedom (dof) to sieve points, called an
-\code{Atlas}. When these mappings are composed, we recover the dof matching used to create a \code{VecScatter}. However,
-dividing them allows the user more flexibility when creating parallel constructs.
-
-There are three levels of data representation (provide picture)
-\begin{itemize}
-  \item Local
-
-  \item Process
-
-  \item Global
-\end{itemize}
-At the local level, we present data in a form specifically tied to the geometry and discretization. For instance, finite
-element methods will be given an element vector, finite volume methods a vector of fluxes, and finite difference methods
-a stencil. At the process level, we create storage which is partially assembled over the process subdomain, but
-unassembled between processes. The Sieve calls these objects \code{Sections}, which become PETSc \code{VecGhost} when
-reduced to linear algebra operations. A single piece of the process level representation is called \emph{local vector}
-by the DMDA. Global representatives are completely assembled, and stored in \code{Vec} objects.
-
-    The simplest example of communication is the trading of ghost values in a DMDA. These values can be communicated in a
-number of ways. First, the user can just call
-\begin{quote}
-  \code{Mesh}
-\end{quote}
-
-
-\subsection{Local Interaction}
-
-    Here we deviate from the DMDA model in order to allow more flexible data layout, and also an access interface which is
-independent of mesh dimension, element shape, and discretization.
-

File src/docs/website/documentation/faq.html

 
       <ol>
         <li>
-          use the Sieve construct in PETSc, this is a high
-          level approach that uses a small number of
-          abstractions to help you manage distributing the
-          grid data structures and computing the elements into
-          the matrices.
+          use DMPlex, which is a high level approach to manage your mesh and
+          discretization. <a href="http://www.mcs.anl.gov/petsc/petsc-dev/src/snes/examples/tutorials/ex62.c.html">SNES
+          ex62</a> solves the Stokes equation using this approach.
         </li>
         <li>
           manage the grid data structure yourself and use

File src/snes/examples/tutorials/ex72.c

   ierr = DMLocalToGlobalBegin(dm, localX, mode, X);CHKERRQ(ierr);
   ierr = DMLocalToGlobalEnd(dm, localX, mode, X);CHKERRQ(ierr);
   ierr = DMRestoreLocalVector(dm, &localX);CHKERRQ(ierr);
-#if 0
-  const PetscInt localDof = this->_mesh->sizeWithBC(s, *cells->begin());
-  PetscReal      detJ;
-
-  ierr = PetscMalloc(localDof * sizeof(PetscScalar), &values);CHKERRQ(ierr);
-  ierr = PetscMalloc2(dim,PetscReal,&v0,dim*dim,PetscReal,&J);CHKERRQ(ierr);
-  ALE::ISieveVisitor::PointRetriever<PETSC_MESH_TYPE::sieve_type> pV((int) pow(this->_mesh->getSieve()->getMaxConeSize(), dim+1)+1, true);
-
-  for (PetscInt c = cStart; c < cEnd; ++c) {
-    ALE::ISieveTraversal<PETSC_MESH_TYPE::sieve_type>::orientedClosure(*this->_mesh->getSieve(), c, pV);
-    const PETSC_MESH_TYPE::point_type *oPoints = pV.getPoints();
-    const int                         oSize    = pV.getSize();
-    int                               v        = 0;
-
-    ierr = DMPlexComputeCellGeometry(dm, c, v0, J, NULL, &detJ);CHKERRQ(ierr);
-    for (PetscInt cl = 0; cl < oSize; ++cl) {
-      const PetscInt fDim;
-
-      ierr = PetscSectionGetDof(oPoints[cl], &fDim);CHKERRQ(ierr);
-      if (pointDim) {
-        for (PetscInt d = 0; d < fDim; ++d, ++v) {
-          values[v] = (*this->_options.integrate)(v0, J, v, initFunc);
-        }
-      }
-    }
-    ierr = DMPlexVecSetClosure(dm, NULL, localX, c, values);CHKERRQ(ierr);
-    pV.clear();
-  }
-  ierr = PetscFree2(v0,J);CHKERRQ(ierr);
-  ierr = PetscFree(values);CHKERRQ(ierr);
-#endif
   PetscFunctionReturn(0);
 }