]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Fix up documentation and (related) deprecations in the examples 4908/head
authorDaniel Arndt <daniel.arndt@iwr.uni-heidelberg.de>
Tue, 22 Aug 2017 10:54:10 +0000 (12:54 +0200)
committerDaniel Arndt <daniel.arndt@iwr.uni-heidelberg.de>
Tue, 22 Aug 2017 12:04:51 +0000 (14:04 +0200)
examples/step-16/step-16.cc
examples/step-37/step-37.cc
examples/step-39/step-39.cc
examples/step-50/step-50.cc
examples/step-56/step-56.cc
examples/step-6/doc/results.dox
examples/step-6/step-6.cc

index 06151f45b434ea68559064b1fd1875ed2d55d17b..b1076249057540ed8f2a3225c79fddafc54ef66d 100644 (file)
@@ -261,7 +261,7 @@ namespace Step16
   void LaplaceProblem<dim>::setup_system ()
   {
     dof_handler.distribute_dofs (fe);
-    dof_handler.distribute_mg_dofs (fe);
+    dof_handler.distribute_mg_dofs ();
 
     deallog << "   Number of degrees of freedom: "
             << dof_handler.n_dofs()
index d0547ac1ffdc078bc9c528e8de5542869f5cc960..ee7efd9bb95d16cca040bf9767411faa449a7d05 100644 (file)
@@ -811,7 +811,7 @@ namespace Step37
     mg_matrices.clear_elements();
 
     dof_handler.distribute_dofs (fe);
-    dof_handler.distribute_mg_dofs (fe);
+    dof_handler.distribute_mg_dofs ();
 
     pcout << "Number of degrees of freedom: "
           << dof_handler.n_dofs()
index e0898fbeb5d31eb4e7c53a4ec690a8a52ce4f12e..3d94624139e9221631a3cef819234f0e68315d70 100644 (file)
@@ -492,7 +492,7 @@ namespace Step39
     // First, we use the finite element to distribute degrees of freedom over
     // the mesh and number them.
     dof_handler.distribute_dofs(fe);
-    dof_handler.distribute_mg_dofs(fe);
+    dof_handler.distribute_mg_dofs();
     unsigned int n_dofs = dof_handler.n_dofs();
     // Then, we already know the size of the vectors representing finite
     // element functions.
index daedd3b567a251d6a65803faf572f7584b4c82cd..ba5ef567ae0e36415fa0c431ed387f7bb440d4ed 100644 (file)
@@ -254,7 +254,7 @@ namespace Step50
   void LaplaceProblem<dim>::setup_system ()
   {
     mg_dof_handler.distribute_dofs (fe);
-    mg_dof_handler.distribute_mg_dofs (fe);
+    mg_dof_handler.distribute_mg_dofs ();
 
     DoFTools::extract_locally_relevant_dofs (mg_dof_handler,
                                              locally_relevant_set);
index 5fb81c9331dfb7206c9af768fa8b46336473bfe8..5fbfebad9942edf5f711c5997f85ce8788dfc9b8 100644 (file)
@@ -515,7 +515,7 @@ namespace Step56
         // velocity space in a separate DoFHandler as described in the
         // introduction.
         velocity_dof_handler.distribute_dofs(velocity_fe);
-        velocity_dof_handler.distribute_mg_dofs(velocity_fe);
+        velocity_dof_handler.distribute_mg_dofs();
 
         // The following block of code initializes the MGConstrainedDofs
         // (using the boundary conditions for the velocity), and the
index 890eaa33e6cde8b6048d48b52720a1632cabf10d..da72f27fa9eb061d61bd6e869663050bcd9deb4e 100644 (file)
@@ -115,14 +115,12 @@ from this example.
 
 @code
 --------------------------------------------------------
-An error occurred in line <128> of file <source/base/subscriptor.cc> in function
+An error occurred in line <104> of file <source/base/subscriptor.cc> in function
     void dealii::Subscriptor::check_no_subscribers() const
 The violated condition was:
     counter == 0
-The name and call sequence of the exception was:
-    ExcInUse (counter, object_info->name(), infostring)
-Additional Information:
-Object of class N6dealii4FE_QILi2ELi2EEE is still used by 1 other objects.
+Additional information:
+Object of class N6dealii17SphericalManifoldILi2ELi2EEE is still used by 1 other objects.
 
 (Additional information: <none>)
 
@@ -134,7 +132,7 @@ Stacktrace:
 -----------
 #0  /lib/libdeal_II.g.so: dealii::Subscriptor::check_no_subscribers() const
 #1  /lib/libdeal_II.g.so: dealii::Subscriptor::~Subscriptor()
-#2  /lib/libdeal_II.g.so: dealii::FiniteElement<2, 2>::~FiniteElement()
+#2  /lib/libdeal_II.g.so: dealii::Manifold<2, 2>::~Manifold()
 #3  ./step-6: Step6<2>::~Step6()
 #4  ./step-6: main
 --------------------------------------------------------
index db0e868c7b2d4c69fb5588a6430c15656ae3a360..6c23fad9f9094b3ef7a1c95170b811f8caf77e1f 100644 (file)
@@ -109,10 +109,11 @@ private:
   void refine_grid ();
   void output_results (const unsigned int cycle) const;
 
-  Triangulation<dim>   triangulation;
+  Triangulation<dim>           triangulation;
+  const SphericalManifold<dim> boundary;
 
-  DoFHandler<dim>      dof_handler;
   FE_Q<dim>            fe;
+  DoFHandler<dim>      dof_handler;
 
   // This is the new variable in the main class. We need an object which holds
   // a list of constraints to hold the hanging nodes and the boundary
@@ -153,39 +154,39 @@ double coefficient (const Point<dim> &p)
 template <int dim>
 Step6<dim>::Step6 ()
   :
-  dof_handler (triangulation),
-  fe (2)
+  fe (2),
+  dof_handler (triangulation)
 {}
 
 
 // @sect4{Step6::~Step6}
 
 // Here comes the added destructor of the class. The reason why we want to add
-// it is a subtle change in the order of data elements in the class as
-// compared to all previous examples: the <code>dof_handler</code> object was
-// defined before and not after the <code>fe</code> object. Of course we could
-// have left this order unchanged, but we would like to show what happens if
-// the order is reversed since this produces a rather nasty side-effect and
-// results in an error which is difficult to track down if one does not know
-// what happens.
+// it is to pick up an issue we already started to discuss in step-1:
+// the <code>boundary</code> object was defined before and not after the
+// <code>triangulation</code> object. Of course we could have left this order
+// unchanged, but we would like to show what happens if the order is reversed
+// since this produces a rather nasty side-effect and results in an error which
+// is difficult to track down if one does not know what happens.
 //
-// Basically what happens is the following: when we distribute the degrees of
-// freedom using the function call <code>dof_handler.distribute_dofs()</code>,
-// the <code>dof_handler</code> also stores a pointer to the finite element in
-// use. Since this pointer is used every now and then until either the degrees
-// of freedom are re-distributed using another finite element object or until
-// the <code>dof_handler</code> object is destroyed, it would be unwise if we
-// would allow the finite element object to be deleted before the
-// <code>dof_handler</code> object. To disallow this, the DoF handler
-// increases a counter inside the finite element object which counts how many
-// objects use that finite element (this is what the
+// Basically what happens is the following: when we set a manifold description
+// to the triangulation using the function call
+// <code>triangulation.set_manifold (0, boundary)</code>, the
+// <code>Triangulation</code> object also stores a pointer to the
+// <code>Manifold</code> object in use. Since this pointer is used until either
+// another <code>Manifold</code> object is set as boundary description or until
+// the <code>Triangulation</code> object is destroyed, it would be unwise if we
+// would allow the <code>boundary</code> to be deleted before the
+// <code>triangulation</code>. To disallow this, the <code>triangulation</code>
+// increases a counter inside the <code>boundary</code> which counts how many
+// objects use it (this is what the
 // <code>Subscriptor</code>/<code>SmartPointer</code> class pair is used for,
 // in case you want something like this for your own programs; see step-7 for
-// a more complete discussion of this topic). The finite element object will
+// a more complete discussion of this topic). The <code>boundary</code> will
 // refuse its destruction if that counter is larger than zero, since then some
-// other objects might rely on the persistence of the finite element
-// object. An exception will then be thrown and the program will usually abort
-// upon the attempt to destroy the finite element.
+// other objects might rely on its persistence. An exception will then be
+// thrown and the program will usually abort upon the attempt to destroy
+// <code>boundary</code>.
 //
 // To be fair, such exceptions about still used objects are not particularly
 // popular among programmers using deal.II, since they only tell us that
@@ -207,14 +208,14 @@ Step6<dim>::Step6 ()
 // destructed before the DoF handler object, since its declaration is below
 // the one of the DoF handler. This triggers the situation above, and an
 // exception will be raised when the <code>fe</code> object is
-// destructed. What needs to be done is to tell the <code>dof_handler</code>
-// object to release its lock to the finite element. Of course, the
-// <code>dof_handler</code> will only release its lock if it really does not
-// need the finite element any more, i.e. when all finite element related data
-// is deleted from it. For this purpose, the <code>DoFHandler</code> class has
-// a function <code>clear</code> which deletes all degrees of freedom, and
-// releases its lock to the finite element. After this, you can safely
-// destruct the finite element object since its internal counter is then zero.
+// destructed. What needs to be done is to tell the <code>triangulation</code>
+// object to release its lock to <code>boundary</code>. Of course, the
+// <code>triangulation</code> will only release its lock if it really does not
+// need the <code>boundary</code> any more. For this purpose, the
+// <code>Triangulation</code> class has a function <code>clear</code> which
+// resets the object into a virgin state by deleting all data and releases its
+// lock to the finite element. After this, you can safely destruct the
+// <code>boundary</code> object since its internal counter is then zero.
 //
 // For completeness, we add the output of the exception that would have been
 // triggered without this destructor, to the end of the results section of
@@ -222,7 +223,7 @@ Step6<dim>::Step6 ()
 template <int dim>
 Step6<dim>::~Step6 ()
 {
-  dof_handler.clear ();
+  triangulation.clear ();
 }
 
 
@@ -636,7 +637,6 @@ void Step6<dim>::run ()
         {
           GridGenerator::hyper_ball (triangulation);
 
-          static const SphericalManifold<dim> boundary;
           triangulation.set_all_manifold_ids_on_boundary(0);
           triangulation.set_manifold (0, boundary);
 

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.