From: schrage
Date: Fri, 19 Feb 1999 16:33:07 +0000 (+0000)
Subject: Changes to doc, added code example (broken)
X-Git-Url: https://gitweb.dealii.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=c2be67c8aad541253c49fcc103e1b6a3cff036a9;p=dealii-svn.git
Changes to doc, added code example (broken)
git-svn-id: https://svn.dealii.org/trunk@852 0785d39b-7218-0410-832d-ea1e28bc413d
---
diff --git a/deal.II/doc/tutorial/chapter-3.laplace/assemble.html b/deal.II/doc/tutorial/chapter-3.laplace/assemble.html
new file mode 100644
index 0000000000..3433378160
--- /dev/null
+++ b/deal.II/doc/tutorial/chapter-3.laplace/assemble.html
@@ -0,0 +1,217 @@
+
+
+
+ DEAL tutorial: the Laplace problem
+
+
+
+
+
+
+Assembling the problem
+
+What's to be done
+In order to assemble the matrices we basically need to:
+
+Generate the matrices , i.e. call the DEAL functions that reserve
+storage space for us.
+
+
+Calculate the finite element trial functions
+
+
+Traverse all existing cells and integrate the problem
+using the discretized laplace operator
+
+
+Traverse all the cell faces and set the appropriate boundary conditions
+
+
+Insert the local matrices we have used into the global matrix using the
+appropriate DEAL functions
+
+
+
+...and how to do it
+
+Function parameters
+
+
+void
+Laplace::assemble_primal(const Function<2>& exact, const Function<2>&)
+{
+
+
+
+
+
+
+First we generate an n times n square matrix where n is the number
+of the degrees of freedom, i.e. the number of points of our discretization.
+The parameter max_couplings_between_dofs() returns the maximum
+number of couplings between degrees of freedom and allows DEAL
+to generate the matrix structure more efficiently, for most of its
+elements are zero.
+
+
+Afterwards the hanging nodes are copied into the matrix, i.e.
+the matrix is generated.
+
+
+
+ matrix_structure.reinit(dof_primal.n_dofs(),dof_primal.n_dofs(),
+ dof_primal.max_couplings_between_dofs());
+ dof_primal.make_sparsity_pattern(matrix_structure);
+ hanging_nodes.clear();
+ dof_primal.make_constraint_matrix(hanging_nodes);
+ hanging_nodes.condense(matrix_structure);
+
+
+
+The problem is of the form Au=f :
+
+
+
+ A.reinit(matrix_structure);
+ f.reinit(dof_primal.n_dofs());
+
+
+
+
+
+The two lines below calculate trial functions for the finite elements and
+for their faces using Gaussian quadrature.
+
+
+
+ FEValues<2> fevalues(fe_primal, qc_primal, UpdateFlags(update_gradients |
+ update_JxW_values));
+ FEFaceValues<2> ffvalues(fe_primal, qf_primal,
+ UpdateFlags(update_JxW_values | update_q_points));
+
+
+
+
+
+Integration is done locally. Therefore we need appropriate definitions for
+
+
+an index vector that will allow us to reassemble the global matrix later on
+
+a vector of doubles with the dimension of the total number of degrees of freedom
+and a square matrix of doubles with the same dimension
+
+
+
+
+ vector indices(fe_primal.total_dofs);
+ dVector elvec(fe_primal.total_dofs);
+
+ dFMatrix elmat(fe_primal.total_dofs);
+
+
+
+Next we traverse all the cells and integrate the Laplace problem using the
+discretized Laplace operator. qc_primal is a Gaussian quadrature.
+
+
+
+ for (DoFHandler<2>::active_cell_iterator c = dof_primal.begin_active()
+ ; c != dof_primal.end() ; ++c)
+ {
+ fevalues.reinit(c, stb);
+ elmat.clear();
+ elvec.clear();
+ c->get_dof_indices(indices);
+
+ for (unsigned k=0;k dv = fevalues.shape_grad(i,k);
+
+ for (unsigned j=0;j du = fevalues.shape_grad(j,k);
+
+ elmat(i,j) += fevalues.JxW(k)
+ * du * dv
+ ;
+
+ }
+ }
+ }
+
+
+
+
+
+
+There are two DEAL functions relevant for us at the moment:
+
+
+static_void interpolate_boundary_values(...)
+
+
+which does exactly what it says. This function returns a list of pairs
+of boundary indicators and the according functions denoting the respective
+Dirichlet boundary values.
+
+
+This output is used by
+
+
+static void apply_boundary_values(...)
+
+
+that inserts the proper boundary conditions into the equation system:
+
+
+
+ map boundary_values;
+ DoFHandler<2>::FunctionMap dirichlet_bc;
+ BoundaryFct bfkt;
+ dirichlet_bc[0]=&bfkt;
+ VectorTools<2>::interpolate_boundary_values(dof_primal,dirichlet_bc,fe_primal,boundary,boundary_values);
+ u.reinit(f);
+ MatrixTools<2>::apply_boundary_values(boundary_values,A,u,f);
+
+First, we need a few definitions:
+
+
+boundary_values
maps boundary values computed by interpolate_boundary_values
to boundary indicators,i.e. to boundaries.
+
+dirichlet_bc
maps boundary functions, supplied by us, to boundary indicators. The boundary functions compute the boundary values.
+
+bfkt is a function returning sin(x)*sin(y)
+
, thereby supplying boundary values.
+
+This may seem a bit confusing. What actually happens is the following:
+
+interpolate_boundary_values
takes the boundary functions
+bfkt
, its relation to boundaries dirichlet_bc
and
+the triangulation dof_primal, fe_primal
and returns a
+mapping boundary_values
that maps values instead of functions
+to our boundaries. The function looks at all the boundaries. All we
+ever need to do is specify the initial triangulation.
+
+apply_boundary_values
subsequently takes that mapping and
+our equation system Au=f
and inserts the boundary values into
+the equation system which can then be solved.
+
+
+
+
+
+
+Back to the tutorial index
+
+
+
+Jan Schrage
+
+Last modified: Fri Feb 12, 1999
+
+
+
diff --git a/deal.II/doc/tutorial/chapter-3.laplace/code/Makefile b/deal.II/doc/tutorial/chapter-3.laplace/code/Makefile
new file mode 100644
index 0000000000..7fbd4d5906
--- /dev/null
+++ b/deal.II/doc/tutorial/chapter-3.laplace/code/Makefile
@@ -0,0 +1,152 @@
+# $Id$
+# Author: Wolfgang Bangerth, 1998
+
+root = ../../../../
+
+vpath %.a $(root)/deal.II/lib
+vpath %.a $(root)/lac/lib
+vpath %.a $(root)/base/lib
+
+# Template for makefiles for the examples subdirectory. In principle,
+# everything should be done automatically if you set the target file
+# here correctly:
+target = laplace
+
+# All dependencies between files should be updated by the included
+# file Makefile.dep if necessary. Object files are compiled into
+# the archives ./Obj.a and ./Obj.g.a. By default, the debug version
+# is used to link. It you don't like that, change the following
+# variable to "off"
+debug-mode = on
+
+# If you want your program to be linked with extra object or library
+# files, specify them here:
+user-libs =
+
+# To run the program, use "make run"; to give parameters to the program,
+# give the parameters to the following variable:
+run-parameters = 60 4
+
+# To execute additional action apart from running the program, fill
+# in this list:
+#additional-run-action =
+
+# To specify which files are to be deleted by "make clean" (apart from
+# the usual ones: object files, executables, backups, etc), fill in the
+# following list
+delete-files = gnuplot* *.eps
+
+deal_II_dimension=2
+
+
+###############################################################################
+# Internals
+
+INCLUDE=-I$(root)/deal.II/include -I$(root)/lac/include -I$(root)/base/include
+
+CXXFLAGS.g= -DDEBUG -g -Wall -W -pedantic -Wconversion \
+ -Winline -Woverloaded-virtual \
+ $(INCLUDE) -Ddeal_II_dimension=$(deal_II_dimension)
+CXXFLAGS =-O3 -Wuninitialized -finline-functions -ffast-math \
+ -felide-constructors -fnonnull-objects \
+ $(INCLUDE) \
+ -Ddeal_II_dimension=$(deal_II_dimension)
+
+ifeq ($(shell uname),Linux)
+CXX = g++
+endif
+
+ifeq ($(shell uname),SunOS)
+CXX = g++
+endif
+
+
+%.go : %.cc #Makefile
+ @echo ============================ Compiling with debugging information: $<
+ @echo $(CXX) ... -c $< -o $@
+ @$(CXX) $(CXXFLAGS.g) -c $< -o $@
+%.o : %.cc #Makefile
+ @echo ============================ Compiling with optimization: $<
+ @echo $(CXX) ... -c $< -o $@
+ @$(CXX) $(CXXFLAGS) -c $< -o $@
+
+
+# get lists of files we need
+cc-files = $(wildcard *.cc)
+o-files = $(cc-files:.cc=.o)
+go-files = $(cc-files:.cc=.go)
+h-files = $(wildcard *.h)
+lib-h-files = $(wildcard $(root)/deal.II/include/*/*.h)
+
+# list of libraries needed to link with
+libs = ./Obj.a $(wildcard $(root)/deal.II/lib/lib*2d.a) $(root)/lac/lib/liblac.a
+libs.g = ./Obj.g.a $(wildcard $(root)/deal.II/lib/lib*2d.g.a) $(root)/lac/lib/liblac.a $(root)/base/lib/libbase.g.a
+
+#$(root)/deal.II/lib/deal_II_2d.g -llac.g -lbase.g#-lbasic.g -lfe.g -lgrid.g -lbasic.g -llac.g
+
+
+# check whether we use debug mode or not
+ifeq ($(debug-mode),on)
+libraries = $(libs.g)
+flags = $(CXXFLAGS.g)
+endif
+
+ifeq ($(debug-mode),off)
+libraries = $(libs)
+flags = $(CXXFLAGS)
+endif
+
+
+
+# make rule for the target
+$(target) : $(libraries) $(user-libs)
+ @echo ============================ Linking $@
+ $(CXX) $(flags) -o $@ $^
+
+# rule how to run the program
+run: $(target)
+ $(target) $(run-parameters)
+ $(additional-run-action)
+
+
+# rule to make object files
+%.go : %.cc
+ @echo ============================ Compiling with debugging information: $<
+ @echo $(CXX) ... -c $< -o $@
+ @$(CXX) $(CXXFLAGS.g) -c $< -o $@
+%.o : %.cc
+ @echo ============================ Compiling with optimization: $<
+ @echo $(CXX) ... -c $< -o $@
+ @$(CXX) $(CXXFLAGS) -c $< -o $@
+
+
+# rules which files the libraries depend upon
+Obj.a: ./Obj.a($(o-files))
+Obj.g.a: ./Obj.g.a($(go-files))
+
+
+clean:
+ rm -f *.o *.go *~ Makefile.dep Obj.a Obj.g.a $(target) $(delete-files)
+
+
+
+.PHONY: clean
+
+
+#Rule to generate the dependency file. This file is
+#automagically remade whenever needed, i.e. whenever
+#one of the cc-/h-files changed. Make detects whether
+#to remake this file upon inclusion at the bottom
+#of this file.
+#
+#use perl to generate rules for the .go files as well
+#as to make rules not for tria.o and the like, but
+#rather for libnumerics.a(tria.o)
+Makefile.dep: $(cc-files) $(h-files) $(lib-h-files)
+ @echo ============================ Remaking Makefile
+ @perl $(root)/deal.II/Make_dep.pl ./Obj $(INCLUDE) $(cc-files) \
+ > Makefile.dep
+
+
+include Makefile.dep
+
diff --git a/deal.II/doc/tutorial/chapter-3.laplace/code/func.cc b/deal.II/doc/tutorial/chapter-3.laplace/code/func.cc
new file mode 100644
index 0000000000..b76e900ec1
--- /dev/null
+++ b/deal.II/doc/tutorial/chapter-3.laplace/code/func.cc
@@ -0,0 +1,24 @@
+// $Id$
+
+// JS.
+const char* funcversion = "Functions: $Revision$";
+
+#include "functions.h"
+
+#include
+
+double
+WeightFunction::operator() (const Point<2>& p) const
+{
+ // double r = p(0)*p(0) + p(1) * p(1);
+ //if (r>=.8) return 0.;
+ //return 1.-r*(2.-r);
+ return 1.;
+
+}
+
+double
+BoundaryFct::operator ()(const Point<2> &p) const
+{
+ return sin(4*M_PI*p(0))*sin(4*M_PI*p(1));
+}
diff --git a/deal.II/doc/tutorial/chapter-3.laplace/code/functions.h b/deal.II/doc/tutorial/chapter-3.laplace/code/functions.h
new file mode 100644
index 0000000000..fa55d4aba9
--- /dev/null
+++ b/deal.II/doc/tutorial/chapter-3.laplace/code/functions.h
@@ -0,0 +1,22 @@
+// $Id$
+
+// JS.Wird das File ueberhaupt gebraucht ?
+
+#include
+
+class WeightFunction
+ : public Function<2>
+{
+public:
+ WeightFunction()
+ {}
+ virtual double operator()(const Point<2> &p) const;
+};
+
+class BoundaryFct
+ : public Function<2>
+{
+ public:
+ virtual double operator()(const Point<2> &p) const;
+};
+
diff --git a/deal.II/doc/tutorial/chapter-3.laplace/code/laplace.cc b/deal.II/doc/tutorial/chapter-3.laplace/code/laplace.cc
new file mode 100644
index 0000000000..329b00c93c
--- /dev/null
+++ b/deal.II/doc/tutorial/chapter-3.laplace/code/laplace.cc
@@ -0,0 +1,287 @@
+// $Id$
+
+const char* laplaceversion = "Laplace: $Revision$";
+
+#include "laplace.h"
+#include "functions.h"
+
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+#include
+#include
+#include
+
+#define PRIMEL FELinear<2>
+#define DUEL FEQuadraticSub<2>
+
+// Finite Elements
+
+static PRIMEL fe_primal;
+// JS.static DUEL fe_dual;
+
+// Quadrature formulae
+
+static QGauss2<2> qc_primal;
+static QGauss2<1> qf_primal;
+// static QGauss3<2> qc_dual;
+// static QGauss3<1> qf_dual;
+static QGauss5<2> qc_integrate;
+static QGauss5<1> qf_integrate;
+
+StraightBoundary<2> stb;
+
+// JS.ist im Moment noch PureTransportSolution...
+Laplace::Laplace()
+ : dof_primal(&tr)
+{
+ // JS.Triangulation generieren. Zellränder werden numeriert.
+ tr.create_hypercube(-1.,1.);
+
+ // JS.Freiheitsgrade verteilen. D.h. Zellen numerieren.
+ dof_primal.distribute_dofs(fe_primal);
+ }
+
+Laplace::~Laplace()
+{}
+
+
+// JS.Gitter verfeinern.
+void
+Laplace::remesh(unsigned int steps)
+{
+ if (tr.n_levels() <= 1)
+ {
+ tr.refine_global(1); //JS.Lokal ist execute_coarsening_etc...
+ }
+
+ if (steps)
+ tr.refine_global(steps);
+ else
+ tr.execute_coarsening_and_refinement();
+
+ // JS. Freiheitsgrade neu verteilen.
+ dof_primal.distribute_dofs(fe_primal);
+ // JS. und dem Problem angemessener nochmal numerieren.
+ dof_primal.renumber_dofs(Cuthill_McKee);
+ deallog << "Cells " << tr.n_active_cells()
+ << " PrimalDoFs " << dof_primal.n_dofs()
+ << endl;
+}
+
+// JS.Primales Problem zusammenstellen.
+void
+Laplace::assemble_primal(const Function<2>&,const Function<2>&)
+{
+ deallog << "Assembling primal problem" << endl;
+ // JS. Platz für neue Matrix mit (?) (2x = quadratisch) Anzahl der Zellen,
+ // Anzahl der Kopplungen (Matrix dünn besetzt, für effizientes Speichern)
+ matrix_structure.reinit(dof_primal.n_dofs(),dof_primal.n_dofs(),
+ dof_primal.max_couplings_between_dofs());
+ // JS.Hängende Noden in die Matrix einbauen; d.h. Matrix generieren.
+ dof_primal.make_sparsity_pattern(matrix_structure);
+ hanging_nodes.clear();
+ dof_primal.make_constraint_matrix(hanging_nodes);
+ hanging_nodes.condense(matrix_structure);
+
+ //JS.Problem der Form Au=f.
+ A.reinit(matrix_structure);
+ f.reinit(dof_primal.n_dofs());
+
+ // JS.Ansatzfunktionen auf Zellrändern im Voraus berechnen aus
+ // Effizienzgründen.
+ FEValues<2> fevalues(fe_primal, qc_primal, UpdateFlags(update_gradients |
+ update_JxW_values));
+ FEFaceValues<2> ffvalues(fe_primal, qf_primal,
+ UpdateFlags(update_JxW_values | update_q_points));
+ //JS.Ab hier lokales Problem el... = Finites Element...
+ //JS. Index für eine Zelle, für späteren Einbau in globale Matrix.
+ vector indices(fe_primal.total_dofs);
+ dVector elvec(fe_primal.total_dofs);
+
+ dFMatrix elmat(fe_primal.total_dofs);
+
+ // JS.Einmal alle Zellen durchlaufen
+ for (DoFHandler<2>::active_cell_iterator c = dof_primal.begin_active()
+ ; c != dof_primal.end() ; ++c)
+ {
+ fevalues.reinit(c, stb);
+ elmat.clear();
+ elvec.clear();
+ c->get_dof_indices(indices);
+
+ // JS.Integration des Problems. Diese Schleifenfolge für Effizienz.
+ for (unsigned k=0;k dv = fevalues.shape_grad(i,k);
+
+
+ for (unsigned j=0;j du = fevalues.shape_grad(j,k);
+
+ elmat(i,j) += fevalues.JxW(k)
+ * du * dv
+ ;
+
+ }
+ }
+ }
+ // JS.Lokale Matrix in globale einbauen.
+ for (unsigned i=0;i boundary_values;
+ DoFHandler<2>::FunctionMap dirichlet_bc;
+ BoundaryFct bfkt;
+ dirichlet_bc[0]=&bfkt;
+ VectorTools<2>::interpolate_boundary_values(dof_primal,dirichlet_bc,
+ fe_primal,boundary,
+ boundary_values);
+ u.reinit(f);
+ MatrixTools<2>::apply_boundary_values(boundary_values,A,u,f);
+
+ cout << "u: " << u.l2_norm() << endl;
+ cout << "f: " << f.l2_norm() << endl;
+
+ // JS.Hängende Noden einbauen.
+ // hanging_nodes.condense(A);
+ //hanging_nodes.condense(f);
+}
+
+// JS. Primales Problem lösen.
+void
+Laplace::solve_primal()
+{
+ deallog.push("Solve");
+
+ // JS.Empfindlichkeit des Lösers einstellen.
+ SolverControl control(1000, 1.e-10);
+ // JS. Löser definieren. modifiziertes cg-Verfahren,
+ SolverCG solver(control, mem);
+
+ // JS.???
+ cout << "f:L2-norm=" << f.l2_norm() << endl;
+ // u.reinit(f);
+
+ // JS.lösen.
+ solver.solve(A,u,f);
+ cout << "u:L2-norm=" << u.l2_norm() << endl;
+
+ // JS.???
+ hanging_nodes.distribute(u);
+
+ deallog.pop();
+}
+
+
+// JS. Datenausgabe im Gnuplot-Format.
+void Laplace::write_data(const char* name)
+{
+ deallog << "Writing gnuplot" << endl;
+
+ DataOut<2> out;
+ char fname[100];
+ sprintf(fname,"P_%s",name);
+
+ {
+ ofstream gnuplot(fname);
+
+ out.clear_data_vectors();
+ out.attach_dof_handler(dof_primal);
+ out.add_data_vector(u,"solution","kg");
+
+ out.write_gnuplot (gnuplot, 1);
+ gnuplot.close ();
+ }
+
+}
+
+
+// JS. Ergebnis zurückgeben. Wie funktioniert das ?
+double
+Laplace::result(const Function<2>& interior, const Function<2>& boundary)
+{
+ double erg = 0., ergex = 0.;
+ FEValues<2> fevalues(fe_primal, qc_integrate,
+ UpdateFlags(update_q_points | update_JxW_values));
+ FEFaceValues<2> ffvalues(fe_primal, qf_integrate,
+ UpdateFlags(update_q_points | update_JxW_values));
+ vector uh(qc_integrate.n_quadrature_points);
+ vector uf(qf_integrate.n_quadrature_points);
+
+ // JS.Alle Zellen durch.
+ for (DoFHandler<2>::active_cell_iterator c = dof_primal.begin_active()
+ ; c != dof_primal.end() ; ++c)
+ {
+ double s = 0.;
+ fevalues.reinit(c, stb);
+
+ fevalues.get_function_values(u, uh);
+
+ for (unsigned int k=0;k::faces_per_cell;++fi)
+ {
+ DoFHandler<2>::face_iterator f = c->face(fi);
+ unsigned char bi = f->boundary_indicator();
+ if (bi == 0xFF) continue;
+ ffvalues.reinit(c, fi, stb);
+ ffvalues.get_function_values(u, uf);
+
+ // JS.??? Integrationspunkte ???
+ for (unsigned k=0;k
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+class AdvMatrix :
+ public dSMatrix
+{
+public:
+ void precondition(dVector& dst, const dVector& src) const
+ {
+ dSMatrix::precondition_SSOR(dst, src);
+ }
+};
+
+
+class Laplace
+{
+ Function<2>& exact;
+protected:
+ Point<2> direction;
+ Triangulation<2> tr;
+ DoFHandler<2> dof_primal;
+// DoFHandler<2> dof_dual;
+
+ dSMatrixStruct matrix_structure;
+ AdvMatrix A;
+
+ dVector u;
+ dVector z;
+ dVector f;
+
+ PrimitiveVectorMemory mem;
+
+ ConstraintMatrix hanging_nodes;
+
+ StraightBoundary<2> boundary;
+
+public:
+ Laplace();
+ ~Laplace();
+
+ void remesh(unsigned int global_refine = 0);
+ void assemble_primal(const Function<2>& boundary, const Function<2>& rhs);
+ void solve_primal();
+
+ double result(const Function<2>& interior, const Function<2>& boundary);
+
+ void adapt();
+
+ void write_data(const char* name);
+
+ void fill_vector(dVector& v, const Function<2>& f) const;
+};
+
diff --git a/deal.II/doc/tutorial/chapter-3.laplace/code/main.cc b/deal.II/doc/tutorial/chapter-3.laplace/code/main.cc
new file mode 100644
index 0000000000..7e2181f5f5
--- /dev/null
+++ b/deal.II/doc/tutorial/chapter-3.laplace/code/main.cc
@@ -0,0 +1,74 @@
+// $Id$
+
+#include "laplace.h"
+#include "functions.h"
+
+#include
+#include
+#include
+
+#include
+#include
+
+ZeroFunction<2> zero;
+
+char fname[30];
+
+main(int argc, char** argv)
+{
+ // JS.Logfile erzeugen, als Stream konzipiert
+
+ ofstream logfile("T");
+ deallog.attach(logfile);
+
+ if (argc==1)
+ cerr << "Usage: " << argv[0] << "firstgrid\nUsing 3"
+ << endl;
+
+ int firstgrid = 3;
+
+ if (argc>=2) firstgrid = atoi(argv[1]);
+
+ deallog << "Firstgrid " << firstgrid << endl;
+
+ // JS.Benötigte Funktionen zur Lösung des Problems
+ WeightFunction weight;
+ BoundaryFct boundary;
+ Laplace lap;
+
+ // JS.Logstream ist ein stack, ab hier wird "Adaptive:" vor jede Zeile
+ // gestellt
+ deallog.push("Adaptive");
+ deallog.depth_console(2);
+
+ for (unsigned step = 0; step < 3 ; ++step)
+ {
+ deallog << "Step " << step << endl;
+ // JS.Beim ersten Mal ein verfeinertes Grid erzeugen, firstgrid=Anzahl
+ // der Verfeinerungen
+ if (!step)
+ lap.remesh(firstgrid);
+ else
+ {
+//JS. lap.adapt();
+ lap.remesh(1);
+ }
+
+ deallog.push("Primal");
+
+ // JS.exakte Lösung mit 0 auf der rechten Seite
+ lap.assemble_primal(boundary,zero);
+ lap.solve_primal();
+
+ // JS.ab hier kein "Adaptive:" mehr
+ deallog.pop();
+
+ sprintf(fname,"T%02d",step);
+ // JS.Daten zurückschreiben. Aber welche ?
+ lap.result(weight,boundary);
+ lap.write_data(fname);
+ }
+ // JS.Logfile sauber abschließen und Schluß
+ deallog.pop();
+ deallog.detach();
+}
diff --git a/deal.II/doc/tutorial/chapter-3.laplace/index.html b/deal.II/doc/tutorial/chapter-3.laplace/index.html
index bc60a8f8ad..f977f4cff8 100644
--- a/deal.II/doc/tutorial/chapter-3.laplace/index.html
+++ b/deal.II/doc/tutorial/chapter-3.laplace/index.html
@@ -4,7 +4,7 @@
The Laplace Problem
-
@@ -65,10 +65,11 @@ triangulation
where a triangulation is generated and degrees of freedom are discussed
-Assembling the problem
+Assembling the problem matrix
-where the matrices describing the problem and the boundary conditions are
-built
+where the matrices describing the problem is assembled
+and the boundary conditions are set
+
Solving the problem
@@ -79,14 +80,14 @@ where the problem is solved
-Back to the tutorial index
+Back to the tutorial index
+
Jan Schrage
-
-Last modified: Tue 5 Jan 1999
+Last modified: Mon 15 Feb 1999