[P]arallel [Hi]gh-order [Li]brary for [P]DEs  Latest
Parallel High-Order Library for PDEs through hp-adaptive Discontinuous Galerkin methods
burgers.cpp
1 #include "ADTypes.hpp"
2 
3 #include "burgers.h"
4 
5 namespace PHiLiP {
6 namespace Physics {
7 
8 template <int dim, int nstate, typename real>
10  const Parameters::AllParameters *const parameters_input,
11  const double diffusion_coefficient,
12  const bool convection,
13  const bool diffusion,
14  const dealii::Tensor<2,3,double> input_diffusion_tensor,
15  std::shared_ptr< ManufacturedSolutionFunction<dim,real> > manufactured_solution_function,
16  const Parameters::AllParameters::TestType parameters_test,
17  const bool has_nonzero_physical_source)
18  : PhysicsBase<dim,nstate,real>(parameters_input, diffusion, has_nonzero_physical_source, input_diffusion_tensor, manufactured_solution_function)
19  , diffusion_scaling_coeff(diffusion_coefficient)
20  , hasConvection(convection)
21  , hasDiffusion(diffusion)
22  , test_type(parameters_test)
23 {
24  static_assert(nstate==dim, "Physics::Burgers() should be created with nstate==dim");
25 }
26 
27 template <int dim, int nstate, typename real>
30  const int /*boundary_type*/,
31  const dealii::Point<dim, real> &pos,
32  const dealii::Tensor<1,dim,real> &normal_int,
33  const std::array<real,nstate> &soln_int,
34  const std::array<dealii::Tensor<1,dim,real>,nstate> &soln_grad_int,
35  std::array<real,nstate> &soln_bc,
36  std::array<dealii::Tensor<1,dim,real>,nstate> &soln_grad_bc) const
37 {
38  std::array<real,nstate> boundary_values;
39  std::array<dealii::Tensor<1,dim,real>,nstate> boundary_gradients;
40  for (int i=0; i<nstate; i++) {
41  boundary_values[i] = this->manufactured_solution_function->value (pos, i);
42  boundary_gradients[i] = this->manufactured_solution_function->gradient (pos, i);
43  }
44 
45  for (int istate=0; istate<nstate; ++istate) {
46 
47  std::array<real,nstate> characteristic_dot_n = convective_eigenvalues(boundary_values, normal_int);
48  const bool inflow = (characteristic_dot_n[istate] <= 0.);
49 
50  if (inflow || hasDiffusion) { // Dirichlet boundary condition
51  // soln_bc[istate] = boundary_values[istate];
52  // soln_grad_bc[istate] = soln_grad_int[istate];
53 
54  soln_bc[istate] = boundary_values[istate];
55  soln_grad_bc[istate] = soln_grad_int[istate];
56 
57  } else { // Neumann boundary condition
58  // //soln_bc[istate] = soln_int[istate];
59  // //soln_bc[istate] = boundary_values[istate];
60  //soln_bc[istate] = -soln_int[istate]+2*boundary_values[istate];
61  soln_bc[istate] = soln_int[istate];
62 
63  // **************************************************************************************************************
64  // Note I don't know how to properly impose the soln_grad_bc to obtain an adjoint consistent scheme
65  // Currently, Neumann boundary conditions are only imposed for the linear advection
66  // Therefore, soln_grad_bc does not affect the solution
67  // **************************************************************************************************************
68  soln_grad_bc[istate] = soln_grad_int[istate];
69  //soln_grad_bc[istate] = boundary_gradients[istate];
70  //soln_grad_bc[istate] = -soln_grad_int[istate]+2*boundary_gradients[istate];
71  }
72  }
73 }
74 
75 template <int dim, int nstate, typename real>
76 std::array<dealii::Tensor<1,dim,real>,nstate> Burgers<dim,nstate,real>
77 ::convective_flux (const std::array<real,nstate> &solution) const
78 {
79  std::array<dealii::Tensor<1,dim,real>,nstate> conv_flux;
80  for (int flux_dim=0; flux_dim<dim; ++flux_dim) {
81  for (int s=0; s<nstate; ++s) {
82  conv_flux[s][flux_dim] = 0.5*solution[flux_dim]*solution[s];
83  }
84  }
85  return conv_flux;
86 }
87 
88 template <int dim, int nstate, typename real>
89 std::array<dealii::Tensor<1,dim,real>,nstate> Burgers<dim,nstate,real>::convective_numerical_split_flux (
90  const std::array<real,nstate> &conservative_soln1,
91  const std::array<real,nstate> &conservative_soln2) const
92 {
93  std::array<dealii::Tensor<1,dim,real>,nstate> conv_flux;
94  for (int flux_dim=0; flux_dim<dim; ++flux_dim) {
95  for (int s=0; s<nstate; ++s) {
96  conv_flux[s][flux_dim] = 1./6. * (conservative_soln1[flux_dim]*conservative_soln1[flux_dim] + conservative_soln1[flux_dim]*conservative_soln2[s] + conservative_soln2[s]*conservative_soln2[s]);
97  }
98  }
99  return conv_flux;
100 }
101 
102 template <int dim, int nstate, typename real>
103 std::array<real,nstate> Burgers<dim, nstate, real>
105  const std::array<real,nstate> &conservative_soln) const
106 {
107  return conservative_soln;
108 }
109 
110 template <int dim, int nstate, typename real>
111 std::array<real,nstate> Burgers<dim, nstate, real>
113  const std::array<real,nstate> &entropy_var) const
114 {
115  return entropy_var;
116 }
117 
118 template <int dim, int nstate, typename real>
121 {
122  if(hasDiffusion) return this->diffusion_scaling_coeff;
123  const real zero = 0.0;
124  return zero;
125 }
126 
127 template <int dim, int nstate, typename real>
128 std::array<real,nstate> Burgers<dim,nstate,real>
130  const std::array<real,nstate> &solution,
131  const dealii::Tensor<1,dim,real> &normal) const
132 {
133  std::array<real,nstate> eig;
134  for (int i=0; i<nstate; i++) {
135  eig[i] = 0.0;
136  for (int d=0;d<dim;++d) {
137  eig[i] += solution[d]*normal[d];
138  }
139  }
140  return eig;
141 }
142 
143 template <int dim, int nstate, typename real>
145 ::max_convective_eigenvalue (const std::array<real,nstate> &soln) const
146 {
147  real max_eig = 0;
148  for (int i=0; i<dim; i++) {
149  //max_eig = std::max(max_eig,std::abs(soln[i]));
150  const real abs_soln = abs(soln[i]);
151  max_eig = std::max(max_eig, abs_soln);
152  //max_eig += soln[i] * soln[i];
153  }
154  return max_eig;
155 }
156 
157 template <int dim, int nstate, typename real>
159 ::max_viscous_eigenvalue (const std::array<real,nstate> &/*conservative_soln*/) const
160 {
161  return 0.0;
162 }
163 
164 template <int dim, int nstate, typename real>
165 std::array<dealii::Tensor<1,dim,real>,nstate> Burgers<dim,nstate,real>
167  const std::array<real,nstate> &solution,
168  const std::array<dealii::Tensor<1,dim,real>,nstate> &solution_gradient,
169  const dealii::types::global_dof_index /*cell_index*/) const
170 {
171  return dissipative_flux(solution, solution_gradient);
172 }
173 
174 template <int dim, int nstate, typename real>
175 std::array<dealii::Tensor<1,dim,real>,nstate> Burgers<dim,nstate,real>
177  const std::array<real,nstate> &/*solution*/,
178  const std::array<dealii::Tensor<1,dim,real>,nstate> &solution_gradient) const
179 {
180  std::array<dealii::Tensor<1,dim,real>,nstate> diss_flux;
181  const real diff_coeff = diffusion_coefficient();
182  for (int i=0; i<nstate; i++) {
183  for (int d1=0; d1<dim; d1++) {
184  diss_flux[i][d1] = 0.0;
185  for (int d2=0; d2<dim; d2++) {
186  diss_flux[i][d1] += -diff_coeff*((this->diffusion_tensor[d1][d2])*solution_gradient[i][d2]);
187  }
188  }
189  }
190  return diss_flux;
191 }
192 
193 template <int dim, int nstate, typename real>
194 std::array<real,nstate> Burgers<dim,nstate,real>
196  const dealii::Point<dim,real> &pos,
197  const std::array<real,nstate> &solution,
198  const real current_time,
199  const dealii::types::global_dof_index /*cell_index*/) const
200 {
201  return source_term(pos,solution,current_time);
202 }
203 
204 template <int dim, int nstate, typename real>
205 std::array<real,nstate> Burgers<dim,nstate,real>
207  const dealii::Point<dim,real> &pos,
208  const std::array<real,nstate> &/*solution*/,
209  const real current_time) const
210 {
211  std::array<real,nstate> source;
212 
213  using TestType = Parameters::AllParameters::TestType;
214 
215  if(this->test_type == TestType::burgers_energy_stability || this->test_type == TestType::burgers_limiter){
216  for(int istate =0; istate<nstate; istate++){
217  source[istate] = 0.0;
218  const double pi = atan(1)*4.0;
219  const real pi_xmt = pi * (pos[0] - current_time);
220  const real pi_ymt = pi * (pos[1] - current_time);
221  const real pi_zmt = pi * (pos[2] - current_time);
222 
223  if(dim==1)
224  {
225  source[istate] = pi * sin(pi_xmt)
226  *(1.0 - cos(pi_xmt));
227  }
228 
229  if(dim==2)
230  {
231  const real sourcedt = pi*sin(pi_xmt)*cos(pi_ymt)
232  +pi*cos(pi_xmt)*sin(pi_ymt);
233  const real sourcedx = -pi*sin(pi_xmt)*(cos(pi_xmt))
234  *pow(cos(pi_ymt),2.0);
235  const real sourcedy = -pi*sin(pi_ymt)*(cos(pi_ymt))
236  *pow(cos(pi_xmt),2.0);
237  source[istate] = sourcedt + sourcedx + sourcedy;
238  }
239 
240  if(dim==3)
241  {
242  const real sourcedt = pi*sin(pi_xmt)*cos(pi_ymt)*cos(pi_zmt)
243  +pi*cos(pi_xmt)*sin(pi_ymt)*cos(pi_zmt)
244  +pi*cos(pi_xmt)*cos(pi_ymt)*sin(pi_zmt);
245  const real sourcedx = -pi*sin(pi_xmt)*(cos(pi_xmt))
246  *pow(cos(pi_ymt),2.0)*pow(cos(pi_zmt),2.0);
247  const real sourcedy = -pi*sin(pi_ymt)*(cos(pi_ymt))
248  *pow(cos(pi_xmt),2.0)*pow(cos(pi_zmt),2.0);
249  const real sourcedz = -pi*sin(pi_zmt)*(cos(pi_zmt))
250  *pow(cos(pi_xmt),2.0)*pow(cos(pi_ymt),2.0);
251  source[istate] = sourcedt + sourcedx + sourcedy + sourcedz;
252  }
253  }
254  }
255  else{
256  const real diff_coeff = diffusion_coefficient();
257  // for (int istate=0; istate<nstate; istate++) {
258  // dealii::Tensor<1,dim,real> manufactured_gradient = this->manufactured_solution_function.gradient (pos, istate);
259  // dealii::SymmetricTensor<2,dim,real> manufactured_hessian = this->manufactured_solution_function.hessian (pos, istate);
260  // source[istate] = 0.0;
261  // for (int d=0;d<dim;++d) {
262  // real manufactured_solution = this->manufactured_solution_function.value (pos, d);
263  // source[istate] += manufactured_solution*manufactured_gradient[d];
264  // }
265  // source[istate] += -diff_coeff*scalar_product((this->diffusion_tensor),manufactured_hessian);
266  // }
267  for (int istate=0; istate<nstate; istate++) {
268  source[istate] = 0.0;
269  dealii::Tensor<1,dim,real> manufactured_gradient = this->manufactured_solution_function->gradient (pos, istate);
270  dealii::SymmetricTensor<2,dim,real> manufactured_hessian = this->manufactured_solution_function->hessian (pos, istate);
271  for (int d=0;d<dim;++d) {
272  real manufactured_solution = this->manufactured_solution_function->value (pos, d);
273  source[istate] += 0.5*manufactured_solution*manufactured_gradient[d];
274  }
275  //source[istate] += -diff_coeff*scalar_product((this->diffusion_tensor),manufactured_hessian);
276  real hess = 0.0;
277  for (int dr=0; dr<dim; ++dr) {
278  for (int dc=0; dc<dim; ++dc) {
279  hess += (this->diffusion_tensor)[dr][dc] * manufactured_hessian[dr][dc];
280  }
281  }
282  source[istate] += -diff_coeff*hess;
283  }
284  for (int istate=0; istate<nstate; istate++) {
285  real manufactured_solution = this->manufactured_solution_function->value (pos, istate);
286  real divergence = 0.0;
287  for (int d=0;d<dim;++d) {
288  dealii::Tensor<1,dim,real> manufactured_gradient = this->manufactured_solution_function->gradient (pos, d);
289  divergence += manufactured_gradient[d];
290  }
291  source[istate] += 0.5*manufactured_solution*divergence;
292  }
293 
294  }
295  // for (int istate=0; istate<nstate; istate++) {
296  // source[istate] = 0.0;
297  // for (int d=0;d<dim;++d) {
298  // dealii::Point<dim,real> posp = pos;
299  // dealii::Point<dim,real> posm = pos;
300  // posp[d] += 1e-8;
301  // posm[d] -= 1e-8;
302  // std::array<real,nstate> solp,solm;
303  // for (int s=0; s<nstate; s++) {
304  // solp[s] = this->manufactured_solution_function.value (posp, s);
305  // solm[s] = this->manufactured_solution_function.value (posm, s);
306  // }
307  // std::array<dealii::Tensor<1,dim,real>,nstate> convp = convective_flux (solp);
308  // std::array<dealii::Tensor<1,dim,real>,nstate> convm = convective_flux (solm);
309  // source[istate] += (convp[istate][d] - convm[istate][d]) / 2e-8;
310  // }
311  // }
312  return source;
313 }
314 
320 
321 } // Physics namespace
322 } // PHiLiP namespace
323 
324 
325 
326 
real max_viscous_eigenvalue(const std::array< real, nstate > &soln) const
Maximum viscous eigenvalue.
Definition: burgers.cpp:159
std::array< real, nstate > compute_entropy_variables(const std::array< real, nstate > &conservative_soln) const
Computes the entropy variables.
Definition: burgers.cpp:104
std::array< dealii::Tensor< 1, dim, real >, nstate > convective_numerical_split_flux(const std::array< real, nstate > &conservative_soln1, const std::array< real, nstate > &conservative_soln2) const override
Convective split flux.
Definition: burgers.cpp:89
TestType
Possible integration tests to run.
std::array< dealii::Tensor< 1, dim, real >, nstate > convective_flux(const std::array< real, nstate > &solution) const
Convective flux: .
Definition: burgers.cpp:77
Base class from which Advection, Diffusion, ConvectionDiffusion, and Euler is derived.
Definition: physics.h:34
Manufactured solution used for grid studies to check convergence orders.
std::array< dealii::Tensor< 1, dim, real >, nstate > dissipative_flux(const std::array< real, nstate > &solution, const std::array< dealii::Tensor< 1, dim, real >, nstate > &solution_gradient, const dealii::types::global_dof_index cell_index) const
Dissipative flux: u.
Definition: burgers.cpp:166
Files for the baseline physics.
Definition: ADTypes.hpp:10
Main parameter class that contains the various other sub-parameter classes.
std::array< real, nstate > compute_conservative_variables_from_entropy_variables(const std::array< real, nstate > &entropy_var) const
Computes the conservative variables from the entropy variables.
Definition: burgers.cpp:112
std::array< real, nstate > convective_eigenvalues(const std::array< real, nstate > &, const dealii::Tensor< 1, dim, real > &) const
Spectral radius of convective term Jacobian is &#39;c&#39;.
Definition: burgers.cpp:129
void boundary_face_values(const int, const dealii::Point< dim, real > &, const dealii::Tensor< 1, dim, real > &, const std::array< real, nstate > &, const std::array< dealii::Tensor< 1, dim, real >, nstate > &, std::array< real, nstate > &, std::array< dealii::Tensor< 1, dim, real >, nstate > &) const
If diffusion is present, assign Dirichlet boundary condition.
Definition: burgers.cpp:29
real max_convective_eigenvalue(const std::array< real, nstate > &soln) const
Maximum convective eigenvalue.
Definition: burgers.cpp:145
std::array< real, nstate > source_term(const dealii::Point< dim, real > &pos, const std::array< real, nstate > &solution, const real current_time, const dealii::types::global_dof_index cell_index) const
Source term is zero or depends on manufactured solution.
Definition: burgers.cpp:195
double diffusion_scaling_coeff
Diffusion scaling coefficient in front of the diffusion tensor.
Definition: burgers.h:44
dealii::Tensor< 2, dim, double > diffusion_tensor
Anisotropic diffusion matrix.
Definition: physics.h:218
const Parameters::AllParameters::TestType test_type
Allows Burgers to distinguish between different unsteady test types.
Definition: burgers.h:52
Burgers(const Parameters::AllParameters *const parameters_input, const double diffusion_coefficient, const bool convection=true, const bool diffusion=true, const dealii::Tensor< 2, 3, double > input_diffusion_tensor=Parameters::ManufacturedSolutionParam::get_default_diffusion_tensor(), std::shared_ptr< ManufacturedSolutionFunction< dim, real > > manufactured_solution_function=nullptr, const Parameters::AllParameters::TestType parameters_test=Parameters::AllParameters::TestType::run_control, const bool has_nonzero_physical_source=false)
Constructor.
Definition: burgers.cpp:9
Burger&#39;s equation with nonlinear advective term and linear diffusive term. Derived from PhysicsBase...
Definition: burgers.h:30
const bool hasDiffusion
Turns on diffusive part of the Burgers problem.
Definition: burgers.h:50
std::shared_ptr< ManufacturedSolutionFunction< dim, real > > manufactured_solution_function
Manufactured solution function.
Definition: physics.h:71
real diffusion_coefficient() const
Diffusion coefficient.
Definition: burgers.cpp:120