<2020-07-16>

  • Meet with Daniela to discuss 1 and its implementation in the wave project in bamps.
  • Picked up my advection equation project in bamps. Started to implement penalty conditions adapted to the advection equation.

<2020-07-15>

  • Studied the penalty method for imposition of boundary conditions from
  1. I have to understand this to be able to port my calculations to bamps.

<2020-07-14>

  • Repeated shock wave tests with filtering after each substage in RK scheme. No improvements observed.
  • I prepared a letter to Jean-Luc Guermond to ask about the problem I am having with the blast wave tests.
  • I agreed with Bernd that I put the EV calculations to the side for around two weeks in order to get some distance and perhaps a new few onto the problem.

<2020-07-13>

  • Implemented aliasing filter according to 2, section 5.3.

<2020-07-09>

  • Scalar conservation law:
    • Tested code with example 5.3 from 2. To my surprise, it works although in the book they state that it should be unstable (perhaps I did not use the same fluxes as they did). If EV is turned on, then solution changes, because of artificial diffusion. Also the CFL has to be lowered when EV is used.

    • I went back to 2. While reading it the following questions came up which I think should be answered before continuing any further:

      • Is it even possible to use the weak formulation for problems with discontinuous solutions? Background: In the derivation of the weak form of the PDE one explicitly assumes that the test functions are smooth across the domain.

      Answer: I guess it is.

      • In subsection 7.1.1. of 2 they examine PDEs with higher spatial derivatives. Regarding the example they discuss, is it really necessary to split the equations like \[ \partial_t u = \partial_x \sqrt{a} q, \qquad q = \sqrt{a} \partial_x u. \] Or could one also arrive at a stable algorithm if \(q = \partial_x u\), etc.?

      Answer: I think the splitting was made for convinience, because in the proof of stability that follows in the discussion, one could choose the \(\phi, \pi\) functions to account for an asymmetric splitting.

      • Did I take the generalization from nonlinear scalar conservation laws to nonlinear systems of conservation laws (Euler equations) too sloppy? Keywords: Variational crimes and aliasing, cf. discussion 6.6.1
      1. If aliasing is really the problem, then this would perhaps explain why papers never spell out details about the numerical implementation, but rather state the problem or refer to a library they used.

<2020-07-08>

  • SR & nSR Euler equations:
    • I came across the work Wintersteiger (2014) which implemented the method of V. Zingan et al. (2013). They give explicit formulae for the implementation. At the moment, it seems that I have always forgotten to account for aliasing in my implementation. This is sad, because I once have thought about this problem, but then I somehow stopped and forgot about it again.
  • Next:
    • Check my implementation to see if aliasing is a problem for me. Test program with Example 5.3 from 2.
    • Fix aliasing issues if present.

<2020-07-07>

  • SR and ordinary Euler equations
    • Experimented with different tests.
    • Revisited literature based on Guermond’s EV method to see if I missed something really obvious.
    • Observation: My results for the tests of Nazarov and Larcher (2017) show always overshoots of some kind, whereas their results don’t (if Guermond-Popov flux is used).
  • Next:
    • See if I can find a reason for the overshoots in the Nazarov and Larcher (2017) tests.
    • Come up with a strategy or plan on how to continue with my EV program.

<2020-07-06>

  • Euler equations
    • I played around with my Euler equations code to see if I can get it to work in the way I described in the previous diary entry - no success.

<2020-07-03>

  • Started formulating questions for Jean-Luc Guermond regarding V. N. Zingan (2012), V. Zingan et al. (2013).
    • While formulating questions, I have thought about the problem once again. This lead me to experiment and check how some variables evolve in the blast wave tests and what causes the crash. I observed the following:
      • If the initial discontinuity sits at the edge of a cell, then the gradient is about a factor of at least 3 bigger than if the discontinuity is at the center of the cell.
      • If I chose the cells such that the initial discontinuity is in the cell center and an appropriate CFL number, then the crash happens because the pressure gets negative in the neighbouring cell of the discontinuity, not in the same cell as I remembered. Perhaps the blast wave test could be passed if I somehow manage to get the program to do the first RK step with special parameters (CFL and entropy parameters) so that the data gets smoothed out a bit?

<2020-07-02>

  • SR Euler equations:
    • Studied derivation of boundary conditions for Euler equations.
    • Checked implementation for obvious bugs - nothing found so far.

<2020-07-01>

  • SR Euler equations:
    • Studied derivation of boundary conditions for Euler equations.

<2020-06-30>

  • SR Euler equations:
    • Tested implementation with tests from Bugner et al. (2015).
      • First tests with smooth initial data showed strong dissipation, shock tube tests crashed with failure in primitive recovery. Tests taken from Bugner et al. (2015).
      • Fixed incorrect formula for primitive variable recovery, smooth test problem evolves nicely (no dissipation).
      • Shock tube test fails, because of a problem at the boundary (negative pressure again, what a surprise ;))
    • Studied SR Euler equations: Took notes on derivation and Eulerian frame as well as primitive variable recovery.

<2020-06-29>

  • SR Euler equations:
    • Finished implementation with DG+EV:
      • Implemented Newton solver (needed for recovery of primitive variables from conservative ones).
      • Implemented simplest artificial regularization scheme similar to Yu, Yan, and Jiang (2018).
      • Set upper bound maximum propagation speed to the speed of light. Perhaps there is a better estimate, but I have not looked into this yet.

<2020-06-25>

  • Euler equations:
    • Studied literature about SR Euler equations.
    • Started implementing SR Euler equations with DG+EV.

<2020-06-24>

  • Euler equations:
    • Fixed RK4+EV implementation. This approach does improve certain test results, but the blast wave problem still remains unsolved.
    • Skimmed of V. N. Zingan (2012) again, but did not find any hints about their numerical implementation (e.g. polynomial type, grid type, etc.) besides the note that they use a FEM method.
    • Inspected the available artificial viscosity regularizations from the literature (Nazarov and Larcher (2017)). To my understanding non of these regularizations is capable of evolving the blast wave problem from the start without any additional help (e.g. limiter).

<2020-06-23>

  • Test RK4 scheme and extended it to also evolve EV.
  • Scalar equations:
    • Adapt program to use RK4+EV scheme. Results show very very small improvement compared to when EV is only evolved after each full RK4 step.
  • Euler equations:
    • Started to adapt program to use RK4+EV scheme. Takes longer than anticipated, because somehow I have messed up the implementation and I cannot find the commit where the bug was introduced.

<2020-06-22>

  • Implemented custom RK4 scheme.

<2020-06-18>

  • Euler equations
    • Refactor code for scalar conservation laws and prepare for use with custom RK4 method and entropy viscosity computation in sub steps.

<2020-06-16>

  • Euler equations
    • Studied V. N. Zingan (2012), V. Zingan et al. (2013) again and compared with my implementation to find potential bugs - WIP.

<2020-06-12>

  • Euler equations
    • Read literature about RKDG method (Cockburn and Shu, 1989) to improve understanding of DG methods. The method is presented in a more comprehensive way in the book by Hesthaven 2007.
    • Found and read PhD thesis of Zingan. I have to check all details of his work and compare with my code.

<2020-06-10>

  • Euler equations
    • Implemented Zingan (2013) for Burger’s equation, also fixed incorrect normalization in entropy viscosity calculation. Results now show more wiggles than before.

<2020-06-09>

  • Euler equations
    • Meeting today: I elaborated on my findings about potential issues with the EV method. I think Bernd would like to not use any limiters, but I have not understood his reason. Anyway, I am not sure if this is possible, although Zingan et al. (2013) give good results for the blast wave tests.
    • After the meeting, I reread the paper about positivity preservation that I stuied and implemented last week. As it turns out, my code does work properly, but the problem of the algorithm is that it only ensures positivity of the cell averages, instead of the point values. Nevertheless, I commit this work in case I want to come back to this approach.
    • I reread Zingan (2013) and implemented their algorithm - no success with Euler equations. Perhaps try Burger’s equation first.

<2020-06-08>

  • Euler equations
    • I studied parts of the paper Francesco sent me ()[https://arxiv.org/pdf/1712.07538.pdf]. In this paper they discuss and benchmark different algorithms for the conservative to primitive recovery problem. This may be of interest for future work.

<2020-06-04>

  • Euler equations
    • I studied literature about positivity preserving schemes for the Euler equations.
    • I implemented a limiter to enforce positivity preservation, not working yet.

<2020-06-03>

  • Euler equations
    • Because I have fixed the incorrect backward FD stencil previously, I repeated the test calculations with RK4 instead of SSPRK4 to see if this makes a difference. Result: With adaptive time stepping (custom CFL, not in-build stepping), RK4 performs as good (qualitatively) as SSPRK4.

<2020-06-02>

  • Euler equations
    • Yorgos and I discussed experiences with shock tube tests. He pointed out that the test which I cannot evolve are called blast wave tests and are also listed in the classical paper of Marti, Mueller (table 7, p. 40). His code also fails these tests if he uses simple unfiltered reconstruction operators plus viscosity. Accroding to David Radice, the ELH also could only pass those tests, because they are using a positivity preserving limiter. Yorgos can pass the blast wave tests if he uses one of the following methods:
      • use reconstruction operator that can capture shocks,
      • spread out the shock in a few cells by using a tanh mapping.

<2020-05-28>

  • Euler equations
    • Refactored initial data computation and boundary condition interface
    • Discovered reason why evolution fails for tests with initial zero velocity and discontinuities for density and energy: the flux terms used in Yu (2017) fail to compensate steep gradients, because for zero velocity the corresponding momentum residual does not obtain any corrections from a second order derivative of the momentum (=velocity).
    • I repeated the failing shock tube tests with the Navier-Stokes and Guermond- Popov regularizations - no success. The reason is that all regularizations use the gradient of the velocity to regularize the momentum, but since it is constant initially those regularizations do not contribute anything.
    • I sent an email to Yorgos asking about his experiences with the Euler equations and shock tube tests.
    • Moving the computation of max velocity after full RK step does not solve problem. The problem is still that an initial constant velocity yields negative temperatures.

<2020-05-27>

  • Euler equations
    • To get an overview over all implementations of EV for the Euler equations, I created a table that compares implementation characteristics for the.
    • On advice from Bernd, I started a list to keep track of things that did and did not work in my implementation of the Euler equations.
    • Fixed incorrect implementation of backward finite difference time derivative used for the evaluation of the entropy residual.
    • Tests indicate that another problem for failing test cases is that an initial discontinuity yield to invalid values for computation. Q: How to initialize mu? Or should mu be calculated at each substage as well?
    • If I initialize EV with the maximum EV, then tests 1,2,5,6 can be evolved.

<2020-05-26>

  • Euler equations
    • Implemented correct boundary conditions for Euler equations and refactored code in wave.jl and euler.jl.
    • I have been playing around with test cases. I still have problems to evolve test case #2.

<2020-05-25>

  • Euler equations
    • Implemented a SSPRK (three stages, third order) to use with the Euler equations, needs further testing. However, before that I have to fix implementation of boundary conditions.

<2020-05-22>

  • Euler equations
    • Yesterday I realized that all the papers that discuss the EV method use so called strong-stability-preserving Runge Kutta methods (SSRK) for the time evolution of their space discretized systems. I changed the solver routine from RK4 to SSRK432 (see DifferentialEquations.jl documentation) in my program and things have improved now: The residual oscillations in the pressure for the smooth test problem are not totally gone, but have decreased in magnitude. With the SSRK method I can now evolve some of the non smooth test problems I could not evolve with the RK4 method. However, I have not tested all test problems and adjustments may still be needed to see whether this has solved the problem.
    • Yesterday I also read about that the DG+EV method is unstable for certain parameter values if the artificial viscosity is incorporated via a Navier-Stokes flux regularization. To account for this, the Guermond-Popov flux has been introduced. Perhaps this statement may also lead to instabilities in the DG+EV code for the Euler equations even if I use a SSRK scheme - investigation needed.

<2020-05-21>

  • Wave equation
    • Since I got a working wave equation problem I thought I try to implement reflective boundary conditions. My first implementation did not work and after some tinkering I figured out how to do it. This gave me some insight in how to set the numerical fluxes at boundaries. TLDR: use same numerical flux as in interior region, but adjust exterior states to reflect the desired bdry value.
    • Compared DG program for burger’s equation before and after code refactoring (commit 4bc79e4 vs 5abf7a5) to figure out what can cause additional oscillations if one uses the same parameters. It turned out that in the old code I overwrote a variable that lead to different scaling of the viscosity.

<2020-05-20>

  • Wave equation I study the wave equation in conservation form to see if my understanding of DG methods and their implementation for system of equations is correct. Implementation of wave equation done - works like a charm. Continue the hunt for bugs, next stop: ?

<2020-05-19>

  • Euler equations
    • Checked following parts of DG program
      • computation of interface values and fluxes,
      • Euler equations: derivation and implementation, No apparent bug found. From this check I conclude that the bug is not due to artificial viscosity, I expect it to be a problem of the underlying DG implementation.
    • Checked implementation scalar equation for potential bug that causes oscillations. Perhaps it is related to the problem with the Euler equations - nothing found.

<2020-05-18>

  • Euler equations
    • Only 1 out of 6 test problems gives correct results (or even finishes evolving).
    • Analysis of smooth test problem showed that already in this case oscillations (because of numerical errors?) appear in the pressure p, although the evolved variables p, rho and E look smooth. Reason unclear. Using constant time step instead of adapted stepping removes oscillations. However, this does not work for the non smooth test problems.
    • Expect for tests 1 and 5, the program terminates already in the first RK stage (hist.tn1 is still 0).

<2020-05-15>

  • Euler equations
    • Implemented test problems 2 & 3 from Zingan et al. 2013, but program fails to evolve those initial data. Reason yet unclear - investigation ongoing.
    • Testing program with test problems taken from Liska, Wendroff (2003).

<2020-05-14>

  • Euler equations
    • I realized that the smooth test problem with periodic boundaries can only be evolved when a central flux is used (Test parameters: N=3, K=80). Why is this the case? Shouldn’t it also work with an upwind flux? Issue resolve, problem was incorrect call of lax friedrich flux method. Program now gives acceptable results even if viscosity is enabled, no artificial diffusion observed so far.
    • Implemented first non-smooth test problem (Zingan 2013, Table 5.5, Test 1). Results qualitatively agree with the results from the paper, but remaining oscillations can be observed. This needs further investigation.

<2020-05-13>

  • Euler equations
    • For the smooth test problem the DG program is only stable if a central flux is used (\(\alpha = 1\)).
    • Adjust boundary conditions for first derivative terms. Boundary conditions were correct and it looks like that this is not what is causing the problem.
Bugner, Marcus, Tim Dietrich, Sebastiano Bernuzzi, Andreas Weyhausen, and Bernd Brügmann. 2015. “Solving 3d Relativistic Hydrodynamical Problems with WENO Discontinuous Galerkin Methods.” arXiv Preprint arXiv:1508.07147.
Nazarov, Murtazo, and Aurélien Larcher. 2017. “Numerical Investigation of a Viscous Regularization of the Euler Equations by Entropy Viscosity.” Computer Methods in Applied Mechanics and Engineering 317: 128–52.
Wintersteiger, Christoph. 2014. “Solving Hyperbolic Conservation Laws with Guermond’s Entropy Viscosity Regularization and Discontinuous Galerkin Method.”
Yu, Jian, Chao Yan, and Zhenhua Jiang. 2018. “Effects of Artificial Viscosity and Upwinding on Spectral Properties of the Discontinuous Galerkin Method.” Computers & Fluids 175: 276–92.
Zingan, Valentin Nikolaevich. 2012. Discontinuous Galerkin Finite Element Method for the Nonlinear Hyperbolic Problems with Entropy-Based Artificial Viscosity Stabilization. Texas A&M University.
Zingan, Valentin, Jean-Luc Guermond, Jim Morel, and Bojan Popov. 2013. “Implementation of the Entropy Viscosity Method with the Discontinuous Galerkin Method.” Computer Methods in Applied Mechanics and Engineering 253: 479–90.