step-66: a nonlinear, parallel matrix-free example [WIP] #8229

tjhei · 2019-05-17T16:36:45Z

I am working with Fabian Castelli on a nonlinear, parallel, matrix-free
tutorial. Because this is the second time my chosen tutorial number was
taken, I would like to reserve it with this PR.

We can either merge this as is or leave it open for now.

I am working with Fabian Castelli on a nonlinear, parallel, matrix-free tutorial. Because this is the second time my chosen tutorial number was taken, I would like to reserve it with this PR.

Tutorial program based also on step-15.

I noticed, that without LAPACK the function copy_to_mg will throw an error.

bangerth · 2020-01-28T22:49:36Z

What's the status here?

bangerth · 2020-05-07T12:45:04Z

Ping? Is this still in the works?

bangerth · 2020-05-21T16:11:11Z

@tjhei Can I steal step-66? I'd like to put the particle example before step-70, and there may be two of them (which would claim 68 as well). You could then take step-71?

tjhei · 2020-05-21T17:15:52Z

@tjhei Can I steal step-66?

I would like to keep it as step-66 if possible. I dropped the ball on it, but it is more or less ready to be looked at / merged.

kronbichler · 2020-05-21T17:26:38Z

Great to see this finalized! Let me know when I should start looking at it.

bangerth · 2020-05-21T18:24:10Z

What would be the downside for you to rename it to 71?

I'm just thinking that it would be nice to have the two new particle tutorials numerically before the first "real" application step-70. Do you already have links to step-66 spread everywhere, or have you used that name anywhere before?

drwells · 2020-05-21T19:01:35Z

@bangerth but you already reserved step-68 for particles in #10043 - shouldn't that suffice?

bangerth · 2020-05-21T19:11:00Z

We're going to write two tutorial programs that would conceptually sit before step-70, and I was hoping to get 66 and 68 for those...

kronbichler

I like this program, it shows a lot of new things. I did some random remarks on language on the parts where you're already reached a good state, and add some bigger comments where I think you could adapt things a bit. I realized too late (after too many comments) that I could have pushed them myself, but I will do so once we have agreed on the bigger topics.

kronbichler · 2020-05-22T12:30:54Z

examples/step-66/doc/intro.dox

+On the unit circle $\Omega = \bigl\{ x \in \mathbb{R}^2 : \|x\| \leq 1 \bigr\}$
+we consider the following nonlinear elliptic boundary value problem subject to a
+homogeneous Dirichlet boundary condition: Find a function
+$u\colon\Omega\to\mathbb{R}$ such that holds:


Suggested change

$u\colon\Omega\to\mathbb{R}$ such that holds:

$u\colon\Omega\to\mathbb{R}$ such that it holds:

kronbichler · 2020-05-22T12:31:56Z

examples/step-66/doc/intro.dox

+
+
+<h3>Discretization with finite elements</h3>
+Even it is a nonlinear problem, we first derive the weak formulation for this


Suggested change

Even it is a nonlinear problem, we first derive the weak formulation for this

As usual, we first derive the weak formulation for this

(I do not think the nonlinearity matters for the weak form.)

kronbichler · 2020-05-22T12:32:23Z

examples/step-66/doc/intro.dox

+<h3>Discretization with finite elements</h3>
+Even it is a nonlinear problem, we first derive the weak formulation for this
+problem by multiplying with a smooth test function $v\colon\Omega\to\mathbb{R}$
+respecting the boundary condition and integrate over the domain $\Omega$.


Suggested change

respecting the boundary condition and integrate over the domain $\Omega$.

respecting the boundary condition and integrating over the domain $\Omega$.

kronbichler · 2020-05-22T12:32:51Z

examples/step-66/doc/intro.dox

+respecting the boundary condition and integrate over the domain $\Omega$.
+Integration by parts and putting the term on the right hand side to the left
+yields the weak formulation: Find a function $u\colon\Omega\to\mathbb{R}$
+such that for all test functions $v$ holds:


Suggested change

such that for all test functions $v$ holds:

such that for all test functions $v$ it holds:

kronbichler · 2020-05-22T12:36:21Z

examples/step-66/doc/intro.dox

+Choosing the Lagrangian finite element space $V_h$ we can define a basis
+$\{\varphi_i\}_{i=1,\dots,N}$ and it suffices to test only with those basis
+functions. So the discrete problem reads as follows: Find $u_h\in V_h$ such that
+for all $i=1,\dots,N$ holds:


Suggested change

for all $i=1,\dots,N$ holds:

for all $i=1,\dots,N$ it holds:

kronbichler · 2020-05-22T13:48:01Z

examples/step-66/step-66.cc

+  // object handling the loop over all cells, and a local_apply function
+  // implementing the calculation of the cell contribution.
+
+  // TODO: As functor with operator() function?


I agree on that - I would remove the boilerplate of having a class and simply write the code inline where you use the residual with a functor - or add a function residual to the JacobianOperator class (well, then the name is not so clear).

kronbichler · 2020-05-22T13:49:22Z

examples/step-66/step-66.cc

+  {
+    TimerOutput::Scope t(computing_timer, "assemble right hand side");
+
+    residual_operator.apply(system_rhs, solution);


Yes, moving the code with a functor here would be very nice.

Just implemented a version, which is now even faster as with the ResidualOperator approach.

kronbichler · 2020-05-22T13:49:46Z

examples/step-66/step-66.cc

+  // important if we would use an adaptive version of the Newton method. Then
+  // for example we would compute the residual for different step lengths and
+  // compare the residuals. However for our problem the full Newton step with
+  // $\alpha=1$ is the best we can do. An adaptive verison of Newton's method


Suggested change

// $\alpha=1$ is the best we can do. An adaptive verison of Newton's method

// $\alpha=1$ is the best we can do. An adaptive version of Newton's method

kronbichler · 2020-05-22T13:52:40Z

examples/step-66/step-66.cc

+    MGTransferMatrixFree<dim, float> mg_transfer(mg_constrained_dofs);
+    mg_transfer.build(dof_handler);


Can you make MGTransferMatrixFree a class member? From an educational point of view, I think it would make sense to show that the transfer only needs to be set up once and can be re-used in subsequent nonlinear iterations. This is different to the mg_smoother object that must indeed be rebuilt because the diagonal changes (even though one could try to find a balance of not recomputing in every iteration - that would make for a good possibility for extensions, though).

Thats a good point! But maybe I didnt get the idea for the 'possibility of extensions'.

kronbichler · 2020-05-22T13:55:49Z

examples/step-66/step-66.cc

+    std::ofstream output(
+      "solution-" + Utilities::to_string(cycle, 2) + "." +
+      Utilities::to_string(Utilities::MPI::this_mpi_process(MPI_COMM_WORLD),
+                           4) +
+      ".vtu");
+    data_out.write_vtu(output);
+
+    if (Utilities::MPI::this_mpi_process(MPI_COMM_WORLD) == 0)
+      {
+        std::vector<std::string> filenames;
+        for (unsigned int i = 0;
+             i < Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD);
+             ++i)
+          {
+            filenames.emplace_back("solution-" +
+                                   Utilities::to_string(cycle, 2) + "." +
+                                   Utilities::to_string(i, 4) + ".vtu");
+          }
+        std::ofstream master_output("solution-" +
+                                    Utilities::to_string(cycle, 2) + ".pvtu");
+        data_out.write_pvtu_record(master_output, filenames);
+      }
+  }


Do you want to use DataOut::write_vtu_with_pvtu_record?

Sure, thats the function we want to use. Unfortunately, when writing this code, this functions was not yet available.

ghost · 2021-05-03T17:44:28Z

Thanks for the comments on this code and sorry for the long time without any reaction from my side. I was hardly stressed in writing my phd but now I am on a postdoc position.

I just created a pull request to tjhei:step-66 with a small update. Major missing point is the results section (which could consist of a wall clock comaprison as in step-50) and the reorganization of the residual evaluation. So the easiest way would be to write the corresponding code in a fuction, which I could do tomorrow morning?

…step-66

tjhei · 2021-05-04T13:50:54Z

Hi @gfcas, I am sorry that I have been sitting on it for 12 months. 😢
Thank you for the help. I was going to draft a result section this week. With at least the minor edits done, we can hopefully merge the tutorial.

ghost · 2021-05-04T13:56:40Z

Hi @tjhei dont worry ;-) I am just updating the evaluation of the residual according to @kronbichler's comment, which I can push later.

ghost · 2021-05-04T16:01:39Z

@tjhei OK, I commited the newest version and updated the pr to the step-66 branch of your dealii fork. One minor issue opened: If we build the patches with given mapping and fe_degree the paraview output looks somehow strange for coarse grids.

marcfehling

The results section is still missing, but otherwise the tutorial already looks very good!

Have you checked that doxygen generates the documentation correctly (i.e. parsing MathJax formulas, alignment of pictures)?

I'll leave some general remarks in this PR. @gfcas I'll open pull requests on your branch with other minor suggestions, see https://github.com/gfcas/dealii/pull/3, https://github.com/gfcas/dealii/pull/4, https://github.com/gfcas/dealii/pull/5, https://github.com/gfcas/dealii/pull/6.

marcfehling · 2021-05-06T00:11:42Z

examples/step-66/doc/intro.dox

+<a href="https://link.springer.com/book/10.1007/978-1-4612-4546-9">
+Mathematical Problems from Combustion Theory
+by Jerrold Bebernes and David Eberly</a>.


Do you want to add a proper literature reference in doc/doxygen/references.bib?

Of course could be done, but I suppose this is the only place where this book is cited. What is the general guideline?

Have a look at doc/doxygen/references.bib. You'll find sections designated for each step with literature specific for the tutorial. Feel free to create such a section for step-66 and add the literature reference there.

marcfehling · 2021-05-06T00:36:18Z

examples/step-66/doc/intro.dox

+Newton step $A = F'(u^n)$. Hence before we need to tell the function that
+computes the system matrix about the solution at the last Newton step. In an
+implementation with a classical
+assemble_system function we would gather this information from the last Newton


Suggested change

assemble_system function we would gather this information from the last Newton

<code>assemble_system()</code> function we would gather this information from the last Newton

Here and later, you can highlight functions like this if you want to.

marcfehling · 2021-05-08T03:59:04Z

examples/step-66/doc/intro.dox

+step during assembly by the use of the member functions get_function_values and
+get_function_gradients of the FEValuesBase class. The assemble_system function


Suggested change

step during assembly by the use of the member functions get_function_values and

get_function_gradients of the FEValuesBase class. The assemble_system function

step during assembly by the use of the member functions FEValuesBase::get_function_values() and

FEValuesBase::get_function_gradients(). The assemble_system function

Here and later: If you write it like this, doxygen will be place a link to the member functions in the documentation.

Yes thanks for this hint.

step-66: Avoid deprecated functions.

step-66: Minor typo and grammar suggestions.

Step 66

peterrum

Looks quite good already! I would be in favor of including this tutorial in the 9.3 release. A non-linear matrix-free tutorial was definitely missing (and would have helped one or two persons I know)! Personally, I find the usage of multigrid here a bit of an overkill but in the combination with the transfer of the solution to the levels has its useful purpose 👍

examples/step-66/doc/intro.dox

peterrum · 2021-05-13T14:47:33Z

examples/step-66/step-66.cc

+  // the quadrature points with the gather_evaluate function. Remember if we
+  // only loop over cells this function is just a wrapper around the functions
+  // read_dof_values and evaluate. Since we store the evaluated values of the
+  // finite element function in a table we do not have to call integrate in
+  // combination with distribute_local_to_global or integrate scatter.


Suggested change

// the quadrature points with the gather_evaluate function. Remember if we

// only loop over cells this function is just a wrapper around the functions

// read_dof_values and evaluate. Since we store the evaluated values of the

// finite element function in a table we do not have to call integrate in

// combination with distribute_local_to_global or integrate scatter.

// the quadrature points with the gather_evaluate function. We store the evaluated

// values of the finite element function directly in a table.

peterrum · 2021-05-13T14:48:27Z

examples/step-66/step-66.cc

+  // The clear function resets the table holding the values for the
+  // nonlinearity and call the clear function of the base class.
+  template <int dim, int fe_degree, typename number>
+  void JacobianOperator<dim, fe_degree, number>::clear()
+  {
+    nonlinear_values.reinit(0, 0);
+    MatrixFreeOperators::Base<dim, LinearAlgebra::distributed::Vector<number>>::
+      clear();
+  }


Is this really needed?

When writing the first version of this example I copied the MatrixFreeOperator from step-37 an adapted it. So this function exsists in accordance with step-37. If it is totally unnecessary we can of course delete it.

If the umber of iterations stay the same, it can be deleted ;)

examples/step-66/step-66.cc

peterrum · 2021-05-13T14:50:41Z

examples/step-66/step-66.cc

+  // The remaining two functions of the JacobianOperator calculate the diagonal
+  // entries of the Jacobian. The only difference compared to step-37 is the
+  // calculation of the cell contribution in the local_compute_diagonal
+  // function. Therefore, we only have to extend and change the
+  // arguments for the submit functions in the loop over all quadrature points
+  // and this can be done according to the local_apply function. So no further
+  // comments to these two functions should be necessary.
+  template <int dim, int fe_degree, typename number>
+  void JacobianOperator<dim, fe_degree, number>::compute_diagonal()
+  {
+    this->inverse_diagonal_entries.reset(
+      new DiagonalMatrix<LinearAlgebra::distributed::Vector<number>>());
+    LinearAlgebra::distributed::Vector<number> &inverse_diagonal =
+      this->inverse_diagonal_entries->get_vector();
+    this->data->initialize_dof_vector(inverse_diagonal);
+
+    unsigned int dummy = 0;
+
+    this->data->cell_loop(&JacobianOperator::local_compute_diagonal,
+                          this,
+                          inverse_diagonal,
+                          dummy);
+
+    this->set_constrained_entries_to_one(inverse_diagonal);
+
+    for (unsigned int i = 0; i < inverse_diagonal.local_size(); ++i)
+      {
+        Assert(
+          inverse_diagonal.local_element(i) > 0.,
+          ExcMessage(
+            "No diagonal entry in a positive definite operator should be zero"));
+        inverse_diagonal.local_element(i) =
+          1. / inverse_diagonal.local_element(i);
+      }
+  }
+
+
+
+  template <int dim, int fe_degree, typename number>
+  void JacobianOperator<dim, fe_degree, number>::local_compute_diagonal(
+    const MatrixFree<dim, number> &             data,
+    LinearAlgebra::distributed::Vector<number> &dst,
+    const unsigned int &,
+    const std::pair<unsigned int, unsigned int> &cell_range) const
+  {
+    FEEvaluation<dim, fe_degree, fe_degree + 1, 1, number> phi(data);
+
+    AlignedVector<VectorizedArray<number>> diagonal(phi.dofs_per_cell);
+
+    for (unsigned int cell = cell_range.first; cell < cell_range.second; ++cell)
+      {
+        AssertDimension(nonlinear_values.size(0), data.n_cell_batches());
+        AssertDimension(nonlinear_values.size(1), phi.n_q_points);
+
+        phi.reinit(cell);
+        for (unsigned int i = 0; i < phi.dofs_per_cell; ++i)
+          {
+            for (unsigned int j = 0; j < phi.dofs_per_cell; ++j)
+              phi.submit_dof_value(VectorizedArray<number>(), j);
+            phi.submit_dof_value(make_vectorized_array<number>(1.), i);
+
+            phi.evaluate(true, true);
+            for (unsigned int q = 0; q < phi.n_q_points; ++q)
+              {
+                phi.submit_value(-nonlinear_values(cell, q) * phi.get_value(q),
+                                 q);
+                phi.submit_gradient(phi.get_gradient(q), q);
+              }
+            phi.integrate(true, true);
+            diagonal[i] = phi.get_dof_value(i);
+          }
+        for (unsigned int i = 0; i < phi.dofs_per_cell; ++i)
+          phi.submit_dof_value(diagonal[i], i);
+        phi.distribute_local_to_global(dst);
+      }
+  }


Could I motivate you to use MatrixFreeTools::compute_diagonal() here?

Good point, this funciton looks good, however, @peterrum would you please take a look on this, whether it is possible in the context here? Yesterday evening it was a bit late and I just tried it straightforewardly following @marcfehling's step-75. I arrived at the problem where his do_cell_integral_local needs in the nonlinear case to know the cell number for getting the value out of the nonlinear_values table.

https://www.dealii.org/developer/doxygen/deal.II/classFEEvaluationBaseData.html#a6874c90c1c3f54737636cd30b46ffe47 ;)

Of course ... thanks, now it works.

peterrum · 2021-05-13T14:55:59Z

examples/step-66/step-66.cc

+  template <int dim, int fe_degree>
+  void GelfandProblem<dim, fe_degree>::evaluate_residual(
+    LinearAlgebra::distributed::Vector<double> &      dst,
+    const LinearAlgebra::distributed::Vector<double> &src) const
+  {
+    // First we update the ghost values of the given input vector src and clear
+    // the output vector dst.
+    src.update_ghost_values();
+    dst = 0.0;
+
+    // Then we get a reference to the MatrixFree object stored in the
+    // JacobianOperator and set up the FEEvaluation.
+    const MatrixFree<dim, double> &data = *system_matrix.get_matrix_free();
+    FEEvaluation<dim, fe_degree>   phi(data);
+
+    // At the main part of this function we loop over all cell batches defined
+    // in the MatrixFree object and compute the residual evaluation, by
+    // evaluating the input vector and integrate against the test functions
+    // according to the weak formulation of the Gelfand problem.
+    for (unsigned int cell = 0; cell < data.n_cell_batches(); ++cell)
+      {
+        phi.reinit(cell);
+        phi.read_dof_values_plain(src);
+        phi.evaluate(true, true);
+
+        for (unsigned int q = 0; q < phi.n_q_points; ++q)
+          {
+            phi.submit_value(-std::exp(phi.get_value(q)), q);
+            phi.submit_gradient(phi.get_gradient(q), q);
+          }
+
+        phi.integrate_scatter(true, true, dst);
+      }
+
+    // Finally, we must not forget to initiate the MPI data exchange via the
+    // compress function.
+    dst.compress(VectorOperation::add);
+  }


Why are you not using a normal cell-loop? In that case you could skip all the MPI vector handling.

Originally this was done in a ResidualOperator with the cell_loop(), but then shifted to member function. I observed, that with this implementations is slightly faster than with the cell_loop in an extra operator. Is there a nice way to use the cell loop directly in the evaluate_residual function without adding an further function for the local_cell_operation?

You can pass a lambda function to MatrixFree::cell_loop() like in step 76. But if you do this, I would like to be consistent in the whole tutorial: either member function or lambda function.

I observed, that with this implementations is slightly faster than with the cell_loop in an extra operator.

Personally, I have doubts that this version is faster than the normal version. You are doing dst = 0.0; which adds an additional read/write operation (which could be hidden by MatrixFree).

You can pass a lambda function to MatrixFree::cell_loop() like in step 76. But if you do this, I would like to be consistent in the whole tutorial: either member function or lambda function.

Now it uses the cell_loop (implemented with an additional member function local_evaluate_residual).

I observed, that with this implementations is slightly faster than with the cell_loop in an extra operator.

Personally, I have doubts that this version is faster than the normal version. You are doing dst = 0.0; which adds an additional read/write operation (which could be hidden by MatrixFree).

In the past, I did some time measurements with prior dst=0.0 and false flag compared to directly true flag. However, I have never seen a clear result which is faster...

peterrum · 2021-05-13T14:59:48Z

examples/step-66/step-66.cc

+  template <int dim, int fe_degree>
+  double GelfandProblem<dim, fe_degree>::compute_solution_norm() const
+  {
+    solution.update_ghost_values();


May I ask you that you always when you call update_ghost_values() you also call zero_out_ghost_values(). Just regard it as malloc-free or new-delete. If you let MatrixFree do the the update_ghost_values and compression you often are able get a speedup of a couple of percent.

Honestly, maybe I didnt get your comment... I thought, that for the evaluation ghost values must be active. But with zero_ou_ghost_values() I would remove them? How can I make MatrixFree do that?

Honestly, maybe I didnt get your comment... I thought, that for the evaluation ghost values must be active. But with zero_ou_ghost_values() I would remove them? How can I make MatrixFree do that?

I meant to call zero_out_ghost_values() at the end of the function. This shouldn't be a problem, or?

Thats of course no problem, zeroing out the ghost in the end of each function updating the ghosts.

examples/step-66/step-66.cc

peterrum · 2021-05-13T15:02:21Z

examples/step-66/step-66.cc

+// @sect3{The main function}
+
+// As typical for programs running in parallel with MPI we set up the MPI
+// framework and limit the number of threads to one. Finally to run the solver


// framework. Finally to run the solver

I would not be surprised that the code also works with threads. Could you try it out. Thx.

Of course I will try it. BUt maybe let us postpone this detail to a later update of the example, as time is running?

peterrum · 2021-05-13T15:03:16Z

.mailmap

+
+#
+Fabian Castelli <fabian.castelli@kit.edu>
+Fabian Castelli <fabian.castelli@kit.edu> <50630942+gfcas@users.noreply.github.com>


Do we still need to do this manully?

@tjhei maybe you know about that? Personally I have no knowledge on these internals.

There shouldn't really be any need for this if you have set up your GitHub account properly (and we don't already have commits with the "wrong" e-mail-address in the repository). I guess this was just a quick and dirty solution.

So nothing to do for me?

Just remove these lines.

ghost · 2021-05-14T09:40:48Z

@tjhei may I ask: you mentioned, that you will goning for a draft of the results section. Do you have already something? Should I try a draft?

ghost · 2021-05-14T10:08:33Z

@tjhei @peterrum @marcfehling I created a new pr tjhei#12 with some updates according your suggestions. Thanks a lot for your comments so far!

ghost · 2021-05-14T11:09:16Z

Sorry for the circumstances, forget about tjhei#12 I opened #12201 directly. So this pr can be closed?

peterrum · 2021-05-14T11:59:24Z

Sorry for the circumstances, forget about tjhei#12 I opened #12201 directly. So this pr can be closed?

I am fine with closing this PR. Except @tjhei gives you the right to his branch, this should make our life easier!

peterrum · 2021-05-14T12:02:23Z

@tjhei may I ask: you mentioned, that you will goning for a draft of the results section. Do you have already something? Should I try a draft?

I don't think you don't need to much results. I think it is a good result if MatrixFree users know after reading this tutorial that they can solve non-linear problems with MatrixFree and what the steps are!

step-66: a nonlinear, parallel matrix-free example [WIP]

c7be7de

I am working with Fabian Castelli on a nonlinear, parallel, matrix-free tutorial. Because this is the second time my chosen tutorial number was taken, I would like to reserve it with this PR.

tjhei added the Tutorials label May 17, 2019

indent

e6a9e3c

masterleinad added the WIP ⚠️ label May 18, 2019

gfcas added 13 commits May 21, 2019 12:14

Update builds-on

eaef39b

Tutorial program based also on step-15.

step-66: Add LAPACK check

7b783d5

I noticed, that without LAPACK the function copy_to_mg will throw an error.

Update tooltip

efa68d3

step-66: Ideas and first draft of intro

2146eea

Code example for intro

10bece0

Reformulation of discretization

1fe0195

Fix some typos

78cb308

GMG Abbrev.

8b7a0ae

Include headers

2016e2a

JacobianOperator

4ece7de

ResidualOperator

014cde0

GelfandProblem class

ff9901b

The main function

09b9726

kronbichler mentioned this pull request Jun 13, 2019

step-67: explicit time integration with matrix-free implementations #8319

Merged

peterrum mentioned this pull request May 7, 2020

Tutorial introducing particles (step-68?) #10043

Closed

tjhei force-pushed the step-66 branch from 1294e66 to 061ece5 Compare May 21, 2020 17:43

bangerth mentioned this pull request May 22, 2020

step-19: A simple particles tutorial. #10301

Merged

4 tasks

kronbichler reviewed May 22, 2020

View reviewed changes

Current program output and ideas for results section

705937d

tjhei and others added 3 commits May 3, 2021 18:52

indent fix

3d3df63

Merge branch 'step-66' of https://github.com/tjhei/dealii into tjhei-…

e144a90

…step-66

Merge branch 'tjhei-step-66' into step-66

c45b2ec

Fabian added 6 commits May 4, 2021 16:09

Remove ResidualOperator and update comments

afb66a2

Update Newton loop with documents

796076c

Bugfix and comment about adaptive Newton

c01aec9

typedef to using

1c7e042

FE degree as template parameter of solver class

769d743

Citation of phd and funding

a7c401f

marcfehling reviewed May 8, 2021

View reviewed changes

marcfehling and others added 6 commits May 8, 2021 16:10

Avoid deprecated functions.

b77d2f4

Update CMake required version.

984666c

Minor typo and grammar suggestions.

88d08af

Merge pull request #3 from marcfehling/step-66-deprecated

779d6f1

step-66: Avoid deprecated functions.

Merge pull request #5 from marcfehling/step-66

604e02a

step-66: Minor typo and grammar suggestions.

Merge pull request #11 from gfcas/step-66

d3138f8

Step 66

peterrum reviewed May 13, 2021

View reviewed changes

ghost mentioned this pull request May 14, 2021

Step 66 Parallel Nonlinear Matrix-Free Example (2. PR) #12201

Closed

tjhei closed this May 14, 2021

ghost mentioned this pull request May 19, 2021

Step 66 Update #12252

Closed

5 tasks

	$u\colon\Omega\to\mathbb{R}$ such that holds:
	$u\colon\Omega\to\mathbb{R}$ such that it holds:



		<h3>Discretization with finite elements</h3>
		Even it is a nonlinear problem, we first derive the weak formulation for this

	Even it is a nonlinear problem, we first derive the weak formulation for this
	As usual, we first derive the weak formulation for this

	respecting the boundary condition and integrate over the domain $\Omega$.
	respecting the boundary condition and integrating over the domain $\Omega$.

	such that for all test functions $v$ holds:
	such that for all test functions $v$ it holds:

	// $\alpha=1$ is the best we can do. An adaptive verison of Newton's method
	// $\alpha=1$ is the best we can do. An adaptive version of Newton's method

		MGTransferMatrixFree<dim, float> mg_transfer(mg_constrained_dofs);
		mg_transfer.build(dof_handler);

	assemble_system function we would gather this information from the last Newton
	<code>assemble_system()</code> function we would gather this information from the last Newton

		step during assembly by the use of the member functions get_function_values and
		get_function_gradients of the FEValuesBase class. The assemble_system function

step-66: a nonlinear, parallel matrix-free example [WIP] #8229

step-66: a nonlinear, parallel matrix-free example [WIP] #8229

Conversation

tjhei commented May 17, 2019

bangerth commented Jan 28, 2020

bangerth commented May 7, 2020

bangerth commented May 21, 2020

tjhei commented May 21, 2020

kronbichler commented May 21, 2020

bangerth commented May 21, 2020

drwells commented May 21, 2020

bangerth commented May 21, 2020

kronbichler left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ghost commented May 3, 2021

tjhei commented May 4, 2021

ghost commented May 4, 2021

ghost commented May 4, 2021

marcfehling left a comment • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

peterrum left a comment • edited

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ghost May 14, 2021 • edited by ghost

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ghost commented May 14, 2021

ghost commented May 14, 2021

ghost commented May 14, 2021

peterrum commented May 14, 2021

peterrum commented May 14, 2021

marcfehling left a comment •

edited

peterrum left a comment •

edited

ghost May 14, 2021 •

edited by ghost