www.mooseframework.org
CNSFVHLLCInternalSideFlux.C
Go to the documentation of this file.
1 /****************************************************************/
2 /* MOOSE - Multiphysics Object Oriented Simulation Environment */
3 /* */
4 /* All contents are licensed under LGPL V2.1 */
5 /* See LICENSE for full restrictions */
6 /****************************************************************/
7 
9 
10 template <>
11 InputParameters
13 {
14  InputParameters params = validParams<InternalSideFluxBase>();
15 
16  params.addClassDescription(
17  "A user object that computes internal side flux using the HLLC approximate Riemann solver.");
18 
19  params.addRequiredParam<UserObjectName>("fluid_properties",
20  "Name for fluid properties user object");
21 
22  return params;
23 }
24 
25 CNSFVHLLCInternalSideFlux::CNSFVHLLCInternalSideFlux(const InputParameters & parameters)
26  : InternalSideFluxBase(parameters),
27  _fp(getUserObject<SinglePhaseFluidProperties>("fluid_properties"))
28 {
29 }
30 
32 
33 void
35  dof_id_type ielem,
36  dof_id_type ineig,
37  const std::vector<Real> & uvec1,
38  const std::vector<Real> & uvec2,
39  const RealVectorValue & dwave,
40  std::vector<Real> & flux) const
41 {
42  Real eps = 1e-6;
43 
45 
46  Real rho1 = uvec1[0];
47  Real rhou1 = uvec1[1];
48  Real rhov1 = uvec1[2];
49  Real rhow1 = uvec1[3];
50  Real rhoe1 = uvec1[4];
51 
52  Real rho2 = uvec2[0];
53  Real rhou2 = uvec2[1];
54  Real rhov2 = uvec2[2];
55  Real rhow2 = uvec2[3];
56  Real rhoe2 = uvec2[4];
57 
58  Real nx = dwave(0);
59  Real ny = dwave(1);
60  Real nz = dwave(2);
61 
63 
64  flux.resize(5);
65 
67 
68  Real uadv1 = rhou1 / rho1;
69  Real vadv1 = rhov1 / rho1;
70  Real wadv1 = rhow1 / rho1;
71  Real v1 = 1. / rho1;
72  Real e1 = rhoe1 / rho1 - 0.5 * (uadv1 * uadv1 + vadv1 * vadv1 + wadv1 * wadv1);
73  Real pres1 = _fp.pressure(v1, e1);
74  Real csou1 = _fp.c(v1, e1);
75  Real gamma = _fp.gamma(v1, e1);
76  Real enth1 = (rhoe1 + pres1) / rho1;
77 
79 
80  Real uadv2 = rhou2 / rho2;
81  Real vadv2 = rhov2 / rho2;
82  Real wadv2 = rhow2 / rho2;
83  Real v2 = 1. / rho2;
84  Real e2 = rhoe2 / rho2 - 0.5 * (uadv2 * uadv2 + vadv2 * vadv2 + wadv2 * wadv2);
85  Real pres2 = _fp.pressure(v2, e2);
86  Real csou2 = _fp.c(v2, e2);
87  Real enth2 = (rhoe2 + pres2) / rho2;
88 
90 
91  Real rhsca = std::sqrt(rho2 / rho1);
92  Real rmden = 1.0 / (rhsca + 1.0);
93 
94  // Real rhoav = rhsca * rho1;
95  Real uaver = (rhsca * uadv2 + uadv1) * rmden;
96  Real vaver = (rhsca * vadv2 + vadv1) * rmden;
97  Real waver = (rhsca * wadv2 + wadv1) * rmden;
98  Real entav = (rhsca * enth2 + enth1) * rmden;
99 
101 
102  Real qave5 = 0.5 * (uaver * uaver + vaver * vaver + waver * waver);
103  Real cssa2 = std::max(eps, (gamma - 1.) * (entav - qave5));
104  Real cssav = std::sqrt(cssa2);
105 
107 
108  Real vdon1 = uadv1 * nx + vadv1 * ny + wadv1 * nz;
109  Real vdon2 = uadv2 * nx + vadv2 * ny + wadv2 * nz;
110  Real vnave = uaver * nx + vaver * ny + waver * nz;
111 
113 
114  Real s1 = std::min(vdon1 - csou1, vnave - cssav);
115  Real s2 = std::max(vdon2 + csou2, vnave + cssav);
116 
117  Real dsv1 = s1 - vdon1;
118  Real dsv2 = s2 - vdon2;
119 
121 
122  Real sm =
123  (rho2 * vdon2 * dsv2 - rho1 * vdon1 * dsv1 + pres1 - pres2) / (rho2 * dsv2 - rho1 * dsv1);
124 
126 
127  Real omeg1 = 1.0 / (s1 - sm);
128  Real omeg2 = 1.0 / (s2 - sm);
129  Real prsta = rho1 * dsv1 * (sm - vdon1) + pres1;
130 
131  Real prst1 = prsta - pres1;
132  Real prst2 = prsta - pres2;
133 
135 
136  Real rhol = omeg1 * dsv1 * rho1;
137  Real rhoul = omeg1 * (dsv1 * rhou1 + prst1 * nx);
138  Real rhovl = omeg1 * (dsv1 * rhov1 + prst1 * ny);
139  Real rhowl = omeg1 * (dsv1 * rhow1 + prst1 * nz);
140  Real rhoel = omeg1 * (dsv1 * rhoe1 - pres1 * vdon1 + prsta * sm);
141 
142  Real rhor = omeg2 * dsv2 * rho2;
143  Real rhour = omeg2 * (dsv2 * rhou2 + prst2 * nx);
144  Real rhovr = omeg2 * (dsv2 * rhov2 + prst2 * ny);
145  Real rhowr = omeg2 * (dsv2 * rhow2 + prst2 * nz);
146  Real rhoer = omeg2 * (dsv2 * rhoe2 - pres2 * vdon2 + prsta * sm);
147 
149 
150  if (s1 > 0.)
151  {
152  flux[0] = vdon1 * rho1;
153  flux[1] = vdon1 * rhou1 + pres1 * nx;
154  flux[2] = vdon1 * rhov1 + pres1 * ny;
155  flux[3] = vdon1 * rhow1 + pres1 * nz;
156  flux[4] = vdon1 * (rhoe1 + pres1);
157  }
158  else if (s1 <= 0. && sm > 0.)
159  {
160  flux[0] = sm * rhol;
161  flux[1] = sm * rhoul + prsta * nx;
162  flux[2] = sm * rhovl + prsta * ny;
163  flux[3] = sm * rhowl + prsta * nz;
164  flux[4] = sm * (rhoel + prsta);
165  }
166  else if (sm <= 0. && s2 >= 0.)
167  {
168  flux[0] = sm * rhor;
169  flux[1] = sm * rhour + prsta * nx;
170  flux[2] = sm * rhovr + prsta * ny;
171  flux[3] = sm * rhowr + prsta * nz;
172  flux[4] = sm * (rhoer + prsta);
173  }
174  else if (s2 < 0.)
175  {
176  flux[0] = vdon2 * rho2;
177  flux[1] = vdon2 * rhou2 + pres2 * nx;
178  flux[2] = vdon2 * rhov2 + pres2 * ny;
179  flux[3] = vdon2 * rhow2 + pres2 * nz;
180  flux[4] = vdon2 * (rhoe2 + pres2);
181  }
182  else
183  {
184  mooseError("Weird wave speed occured in ",
185  name(),
186  ": ",
187  __FUNCTION__,
188  "\n",
189  "iside = ",
190  iside,
191  "\n",
192  "ielem = ",
193  ielem,
194  "\n",
195  "ineig = ",
196  ineig,
197  "\n",
198  "rho1 = ",
199  rho1,
200  "\n",
201  "rhou1 = ",
202  rhou1,
203  "\n",
204  "rhov1 = ",
205  rhov1,
206  "\n",
207  "rhow1 = ",
208  rhow1,
209  "\n",
210  "rhoe1 = ",
211  rhoe1,
212  "\n",
213  "pres1 = ",
214  pres1,
215  "\n",
216  "enth1 = ",
217  enth1,
218  "\n",
219  "csou1 = ",
220  csou1,
221  "\n",
222  "rho2 = ",
223  rho2,
224  "\n",
225  "rhou2 = ",
226  rhou2,
227  "\n",
228  "rhov2 = ",
229  rhov2,
230  "\n",
231  "rhoe2 = ",
232  rhoe2,
233  "\n",
234  "pres2 = ",
235  pres2,
236  "\n",
237  "enth2 = ",
238  enth2,
239  "\n",
240  "csou2 = ",
241  csou2,
242  "\n",
243  "vdon1 = ",
244  vdon1,
245  "\n",
246  "vdon2 = ",
247  vdon2,
248  "\n",
249  "vnave = ",
250  vnave,
251  "\n",
252  "cssav = ",
253  cssav,
254  "\n",
255  "s1 = ",
256  s1,
257  "\n",
258  "s2 = ",
259  s2,
260  "\n",
261  "sm = ",
262  sm,
263  "\n",
264  "omeg1 = ",
265  omeg1,
266  "\n",
267  "omeg2 = ",
268  omeg2,
269  "\n",
270  "prsta = ",
271  prsta,
272  "\n",
273  "Please check before continuing!\n");
274  }
275 }
276 
277 void
279  dof_id_type ielem,
280  dof_id_type ineig,
281  const std::vector<Real> & uvec1,
282  const std::vector<Real> & uvec2,
283  const RealVectorValue & dwave,
284  DenseMatrix<Real> & jac1,
285  DenseMatrix<Real> & jac2) const
286 {
287  Real eps = 1e-6;
288 
290 
291  Real rho1 = uvec1[0];
292  Real rhou1 = uvec1[1];
293  Real rhov1 = uvec1[2];
294  Real rhow1 = uvec1[3];
295  Real rhoe1 = uvec1[4];
296 
297  Real rho2 = uvec2[0];
298  Real rhou2 = uvec2[1];
299  Real rhov2 = uvec2[2];
300  Real rhow2 = uvec2[3];
301  Real rhoe2 = uvec2[4];
302 
303  Real nx = dwave(0);
304  Real ny = dwave(1);
305  Real nz = dwave(2);
306 
308 
309  jac1.resize(5, 5);
310  jac2.resize(5, 5);
311 
313 
314  Real uadv1 = rhou1 / rho1;
315  Real vadv1 = rhov1 / rho1;
316  Real wadv1 = rhow1 / rho1;
317  Real vdov1 = uadv1 * uadv1 + vadv1 * vadv1 + wadv1 * wadv1;
318  Real v1 = 1. / rho1;
319  Real e1 = rhoe1 / rho1 - 0.5 * vdov1;
320  Real pres1 = _fp.pressure(v1, e1);
321  Real csou1 = _fp.c(v1, e1);
322  Real gamma = _fp.gamma(v1, e1);
323  Real gamm1 = gamma - 1.;
324  Real gamm2 = 2. - gamma;
325  Real enth1 = (rhoe1 + pres1) / rho1;
326  Real rq051 = 0.5 * gamm1 * vdov1;
327 
329 
330  Real uadv2 = rhou2 / rho2;
331  Real vadv2 = rhov2 / rho2;
332  Real wadv2 = rhow2 / rho2;
333  Real vdov2 = uadv2 * uadv2 + vadv2 * vadv2 + wadv2 * wadv2;
334  Real v2 = 1. / rho2;
335  Real e2 = rhoe2 / rho2 - 0.5 * vdov2;
336  Real pres2 = _fp.pressure(v2, e2);
337  Real csou2 = _fp.c(v2, e2);
338  Real enth2 = (rhoe2 + pres2) / rho2;
339  Real rq052 = 0.5 * gamm1 * vdov2;
340 
342 
343  Real rhsca = std::sqrt(rho2 / rho1);
344  Real rmden = 1.0 / (rhsca + 1.0);
345 
346  // Real rhoav = rhsca * rho1;
347  Real uaver = (rhsca * uadv2 + uadv1) * rmden;
348  Real vaver = (rhsca * vadv2 + vadv1) * rmden;
349  Real waver = (rhsca * wadv2 + wadv1) * rmden;
350  Real entav = (rhsca * enth2 + enth1) * rmden;
351 
353 
354  Real qave5 = 0.5 * (uaver * uaver + vaver * vaver + waver * waver);
355  Real cssa2 = std::max(eps, (gamma - 1.) * (entav - qave5));
356  Real cssav = std::sqrt(cssa2);
357 
359 
360  Real vdon1 = uadv1 * nx + vadv1 * ny + wadv1 * nz;
361  Real vdon2 = uadv2 * nx + vadv2 * ny + wadv2 * nz;
362  Real vnave = uaver * nx + vaver * ny + waver * nz;
363 
365 
366  Real s1 = std::min(vdon1 - csou1, vnave - cssav);
367  Real s2 = std::max(vdon2 + csou2, vnave + cssav);
368 
369  Real dsv1 = s1 - vdon1;
370  Real dsv2 = s2 - vdon2;
371 
373 
374  Real sm =
375  (rho2 * vdon2 * dsv2 - rho1 * vdon1 * dsv1 + pres1 - pres2) / (rho2 * dsv2 - rho1 * dsv1);
376 
378 
379  if (s1 > 0.)
380  {
382 
383  jac1(0, 0) = 0.;
384  jac1(0, 1) = nx;
385  jac1(0, 2) = ny;
386  jac1(0, 3) = nz;
387  jac1(0, 4) = 0.;
388 
389  jac1(1, 0) = rq051 * nx - uadv1 * vdon1;
390  jac1(1, 1) = gamm2 * nx * uadv1 + vdon1;
391  jac1(1, 2) = ny * uadv1 - vadv1 * gamm1 * nx;
392  jac1(1, 3) = nz * uadv1 - wadv1 * gamm1 * nx;
393  jac1(1, 4) = gamm1 * nx;
394 
395  jac1(2, 0) = rq051 * ny - vadv1 * vdon1;
396  jac1(2, 1) = nx * vadv1 - uadv1 * gamm1 * ny;
397  jac1(2, 2) = gamm2 * ny * vadv1 + vdon1;
398  jac1(2, 3) = nz * vadv1 - wadv1 * gamm1 * ny;
399  jac1(2, 4) = gamm1 * ny;
400 
401  jac1(3, 0) = rq051 * nz - wadv1 * vdon1;
402  jac1(3, 1) = nx * wadv1 - uadv1 * gamm1 * nz;
403  jac1(3, 2) = ny * wadv1 - vadv1 * gamm1 * nz;
404  jac1(3, 3) = gamm2 * nz * wadv1 + vdon1;
405  jac1(3, 4) = gamm1 * nz;
406 
407  jac1(4, 0) = (rq051 - enth1) * vdon1;
408  jac1(4, 1) = nx * enth1 - gamm1 * uadv1 * vdon1;
409  jac1(4, 2) = ny * enth1 - gamm1 * vadv1 * vdon1;
410  jac1(4, 3) = nz * enth1 - gamm1 * wadv1 * vdon1;
411  jac1(4, 4) = gamma * vdon1;
412  }
413  else if (s1 <= 0. && sm > 0.)
414  {
416 
417  Real omeg1 = 1. / (s1 - sm);
418  Real prsta = rho1 * dsv1 * (sm - vdon1) + pres1;
419 
420  Real prst1 = prsta - pres1;
421 
423 
424  Real rhol = omeg1 * dsv1 * rho1;
425  Real rhoul = omeg1 * (dsv1 * rhou1 + prst1 * nx);
426  Real rhovl = omeg1 * (dsv1 * rhov1 + prst1 * ny);
427  Real rhowl = omeg1 * (dsv1 * rhow1 + prst1 * nz);
428  Real rhoel = omeg1 * (dsv1 * rhoe1 - pres1 * vdon1 + prsta * sm);
429 
430  Real rhoepl = rhoel + prsta;
431 
433 
434  Real rhotd = std::max(eps, rho2 * (s2 - vdon2) - rho1 * (s1 - vdon1));
435  Real rhotm = 1. / rhotd;
436 
438 
439  Real sm_rho1 = rhotm * (-vdon1 * vdon1 + rq051 + sm * s1);
440  Real sm_rhou1 = rhotm * (nx * (2. * vdon1 - s1 - sm) - gamm1 * uadv1);
441  Real sm_rhov1 = rhotm * (ny * (2. * vdon1 - s1 - sm) - gamm1 * vadv1);
442  Real sm_rhow1 = rhotm * (nz * (2. * vdon1 - s1 - sm) - gamm1 * wadv1);
443  Real sm_rhoe1 = rhotm * gamm1;
444 
446 
447  Real sm_rho2 = rhotm * (vdon2 * vdon2 - rq052 - sm * s2);
448  Real sm_rhou2 = rhotm * (nx * (-2. * vdon2 + s2 + sm) + gamm1 * uadv2);
449  Real sm_rhov2 = rhotm * (ny * (-2. * vdon2 + s2 + sm) + gamm1 * vadv2);
450  Real sm_rhow2 = rhotm * (nz * (-2. * vdon2 + s2 + sm) + gamm1 * wadv2);
451  Real sm_rhoe2 = -rhotm * gamm1;
452 
454 
455  Real ps_rho1 = rho2 * dsv2 * sm_rho1;
456  Real ps_rhou1 = rho2 * dsv2 * sm_rhou1;
457  Real ps_rhov1 = rho2 * dsv2 * sm_rhov1;
458  Real ps_rhow1 = rho2 * dsv2 * sm_rhow1;
459  Real ps_rhoe1 = rho2 * dsv2 * sm_rhoe1;
460 
462 
463  Real ps_rho2 = rho1 * dsv1 * sm_rho2;
464  Real ps_rhou2 = rho1 * dsv1 * sm_rhou2;
465  Real ps_rhov2 = rho1 * dsv1 * sm_rhov2;
466  Real ps_rhow2 = rho1 * dsv1 * sm_rhow2;
467  Real ps_rhoe2 = rho1 * dsv1 * sm_rhoe2;
468 
470 
471  Real rhol_rho1 = omeg1 * (s1 + rhol * sm_rho1);
472  Real rhol_rhou1 = omeg1 * (-nx + rhol * sm_rhou1);
473  Real rhol_rhov1 = omeg1 * (-ny + rhol * sm_rhov1);
474  Real rhol_rhow1 = omeg1 * (-nz + rhol * sm_rhow1);
475  Real rhol_rhoe1 = omeg1 * (rhol * sm_rhoe1);
476 
478 
479  Real rhol_rho2 = omeg1 * rhol * sm_rho2;
480  Real rhol_rhou2 = omeg1 * rhol * sm_rhou2;
481  Real rhol_rhov2 = omeg1 * rhol * sm_rhov2;
482  Real rhol_rhow2 = omeg1 * rhol * sm_rhow2;
483  Real rhol_rhoe2 = omeg1 * rhol * sm_rhoe2;
484 
486 
487  Real rhoul_rho1 = omeg1 * (uadv1 * vdon1 - nx * rq051 + nx * ps_rho1 + rhoul * sm_rho1);
488  Real rhoul_rhou1 = omeg1 * (dsv1 - gamm2 * nx * uadv1 + nx * ps_rhou1 + rhoul * sm_rhou1);
489  Real rhoul_rhov1 =
490  omeg1 * (-uadv1 * ny + gamm1 * nx * vadv1 + nx * ps_rhov1 + rhoul * sm_rhov1);
491  Real rhoul_rhow1 =
492  omeg1 * (-uadv1 * nz + gamm1 * nx * wadv1 + nx * ps_rhow1 + rhoul * sm_rhow1);
493  Real rhoul_rhoe1 = omeg1 * (-gamm1 * nx + nx * ps_rhoe1 + rhoul * sm_rhoe1);
494 
496 
497  Real rhoul_rho2 = omeg1 * (nx * ps_rho2 + rhoul * sm_rho2);
498  Real rhoul_rhou2 = omeg1 * (nx * ps_rhou2 + rhoul * sm_rhou2);
499  Real rhoul_rhov2 = omeg1 * (nx * ps_rhov2 + rhoul * sm_rhov2);
500  Real rhoul_rhow2 = omeg1 * (nx * ps_rhow2 + rhoul * sm_rhow2);
501  Real rhoul_rhoe2 = omeg1 * (nx * ps_rhoe2 + rhoul * sm_rhoe2);
502 
504 
505  Real rhovl_rho1 = omeg1 * (vadv1 * vdon1 - ny * rq051 + ny * ps_rho1 + rhovl * sm_rho1);
506  Real rhovl_rhou1 =
507  omeg1 * (-vadv1 * nx + gamm1 * ny * uadv1 + ny * ps_rhou1 + rhovl * sm_rhou1);
508  Real rhovl_rhov1 = omeg1 * (dsv1 - gamm2 * ny * vadv1 + ny * ps_rhov1 + rhovl * sm_rhov1);
509  Real rhovl_rhow1 =
510  omeg1 * (-vadv1 * nz + gamm1 * ny * wadv1 + ny * ps_rhow1 + rhovl * sm_rhow1);
511  Real rhovl_rhoe1 = omeg1 * (-gamm1 * ny + ny * ps_rhoe1 + rhovl * sm_rhoe1);
512 
514 
515  Real rhovl_rho2 = omeg1 * (ny * ps_rho2 + rhovl * sm_rho2);
516  Real rhovl_rhou2 = omeg1 * (ny * ps_rhou2 + rhovl * sm_rhou2);
517  Real rhovl_rhov2 = omeg1 * (ny * ps_rhov2 + rhovl * sm_rhov2);
518  Real rhovl_rhow2 = omeg1 * (ny * ps_rhow2 + rhovl * sm_rhow2);
519  Real rhovl_rhoe2 = omeg1 * (ny * ps_rhoe2 + rhovl * sm_rhoe2);
520 
522 
523  Real rhowl_rho1 = omeg1 * (wadv1 * vdon1 - nz * rq051 + nz * ps_rho1 + rhowl * sm_rho1);
524  Real rhowl_rhou1 =
525  omeg1 * (-wadv1 * nx + gamm1 * nz * uadv1 + nz * ps_rhou1 + rhowl * sm_rhou1);
526  Real rhowl_rhov1 =
527  omeg1 * (-wadv1 * ny + gamm1 * nz * vadv1 + nz * ps_rhov1 + rhowl * sm_rhov1);
528  Real rhowl_rhow1 = omeg1 * (dsv1 - gamm2 * nz * wadv1 + nz * ps_rhow1 + rhowl * sm_rhow1);
529  Real rhowl_rhoe1 = omeg1 * (-gamm1 * nz + nz * ps_rhoe1 + rhowl * sm_rhoe1);
530 
532 
533  Real rhowl_rho2 = omeg1 * (nz * ps_rho2 + rhowl * sm_rho2);
534  Real rhowl_rhou2 = omeg1 * (nz * ps_rhou2 + rhowl * sm_rhou2);
535  Real rhowl_rhov2 = omeg1 * (nz * ps_rhov2 + rhowl * sm_rhov2);
536  Real rhowl_rhow2 = omeg1 * (nz * ps_rhow2 + rhowl * sm_rhow2);
537  Real rhowl_rhoe2 = omeg1 * (nz * ps_rhoe2 + rhowl * sm_rhoe2);
538 
542 
543  Real rhoel_rho1 = omeg1 * (vdon1 * enth1 - vdon1 * rq051 + sm * ps_rho1 + rhoepl * sm_rho1);
544  Real rhoel_rhou1 =
545  omeg1 * (-nx * enth1 + gamm1 * vdon1 * uadv1 + sm * ps_rhou1 + rhoepl * sm_rhou1);
546  Real rhoel_rhov1 =
547  omeg1 * (-ny * enth1 + gamm1 * vdon1 * vadv1 + sm * ps_rhov1 + rhoepl * sm_rhov1);
548  Real rhoel_rhow1 =
549  omeg1 * (-nz * enth1 + gamm1 * vdon1 * wadv1 + sm * ps_rhow1 + rhoepl * sm_rhow1);
550  Real rhoel_rhoe1 = omeg1 * (s1 - vdon1 * gamma + sm * ps_rhoe1 + rhoepl * sm_rhoe1);
551 
553 
554  Real rhoel_rho2 = omeg1 * (sm * ps_rho2 + rhoepl * sm_rho2);
555  Real rhoel_rhou2 = omeg1 * (sm * ps_rhou2 + rhoepl * sm_rhou2);
556  Real rhoel_rhov2 = omeg1 * (sm * ps_rhov2 + rhoepl * sm_rhov2);
557  Real rhoel_rhow2 = omeg1 * (sm * ps_rhow2 + rhoepl * sm_rhow2);
558  Real rhoel_rhoe2 = omeg1 * (sm * ps_rhoe2 + rhoepl * sm_rhoe2);
559 
561 
562  jac1(0, 0) = sm * rhol_rho1 + rhol * sm_rho1;
563  jac1(0, 1) = sm * rhol_rhou1 + rhol * sm_rhou1;
564  jac1(0, 2) = sm * rhol_rhov1 + rhol * sm_rhov1;
565  jac1(0, 3) = sm * rhol_rhow1 + rhol * sm_rhow1;
566  jac1(0, 4) = sm * rhol_rhoe1 + rhol * sm_rhoe1;
567 
568  jac1(1, 0) = sm * rhoul_rho1 + rhoul * sm_rho1 + nx * ps_rho1;
569  jac1(1, 1) = sm * rhoul_rhou1 + rhoul * sm_rhou1 + nx * ps_rhou1;
570  jac1(1, 2) = sm * rhoul_rhov1 + rhoul * sm_rhov1 + nx * ps_rhov1;
571  jac1(1, 3) = sm * rhoul_rhow1 + rhoul * sm_rhow1 + nx * ps_rhow1;
572  jac1(1, 4) = sm * rhoul_rhoe1 + rhoul * sm_rhoe1 + nx * ps_rhoe1;
573 
574  jac1(2, 0) = sm * rhovl_rho1 + rhovl * sm_rho1 + ny * ps_rho1;
575  jac1(2, 1) = sm * rhovl_rhou1 + rhovl * sm_rhou1 + ny * ps_rhou1;
576  jac1(2, 2) = sm * rhovl_rhov1 + rhovl * sm_rhov1 + ny * ps_rhov1;
577  jac1(2, 3) = sm * rhovl_rhow1 + rhovl * sm_rhow1 + ny * ps_rhow1;
578  jac1(2, 4) = sm * rhovl_rhoe1 + rhovl * sm_rhoe1 + ny * ps_rhoe1;
579 
580  jac1(3, 0) = sm * rhowl_rho1 + rhowl * sm_rho1 + nz * ps_rho1;
581  jac1(3, 1) = sm * rhowl_rhou1 + rhowl * sm_rhou1 + nz * ps_rhou1;
582  jac1(3, 2) = sm * rhowl_rhov1 + rhowl * sm_rhov1 + nz * ps_rhov1;
583  jac1(3, 3) = sm * rhowl_rhow1 + rhowl * sm_rhow1 + nz * ps_rhow1;
584  jac1(3, 4) = sm * rhowl_rhoe1 + rhowl * sm_rhoe1 + nz * ps_rhoe1;
585 
586  jac1(4, 0) = sm * (rhoel_rho1 + ps_rho1) + rhoepl * sm_rho1;
587  jac1(4, 1) = sm * (rhoel_rhou1 + ps_rhou1) + rhoepl * sm_rhou1;
588  jac1(4, 2) = sm * (rhoel_rhov1 + ps_rhov1) + rhoepl * sm_rhov1;
589  jac1(4, 3) = sm * (rhoel_rhow1 + ps_rhow1) + rhoepl * sm_rhow1;
590  jac1(4, 4) = sm * (rhoel_rhoe1 + ps_rhoe1) + rhoepl * sm_rhoe1;
591 
593 
594  jac2(0, 0) = sm * rhol_rho2 + rhol * sm_rho2;
595  jac2(0, 1) = sm * rhol_rhou2 + rhol * sm_rhou2;
596  jac2(0, 2) = sm * rhol_rhov2 + rhol * sm_rhov2;
597  jac2(0, 3) = sm * rhol_rhow2 + rhol * sm_rhow2;
598  jac2(0, 4) = sm * rhol_rhoe2 + rhol * sm_rhoe2;
599 
600  jac2(1, 0) = sm * rhoul_rho2 + rhoul * sm_rho2 + nx * ps_rho2;
601  jac2(1, 1) = sm * rhoul_rhou2 + rhoul * sm_rhou2 + nx * ps_rhou2;
602  jac2(1, 2) = sm * rhoul_rhov2 + rhoul * sm_rhov2 + nx * ps_rhov2;
603  jac2(1, 3) = sm * rhoul_rhow2 + rhoul * sm_rhow2 + nx * ps_rhow2;
604  jac2(1, 4) = sm * rhoul_rhoe2 + rhoul * sm_rhoe2 + nx * ps_rhoe2;
605 
606  jac2(2, 0) = sm * rhovl_rho2 + rhovl * sm_rho2 + ny * ps_rho2;
607  jac2(2, 1) = sm * rhovl_rhou2 + rhovl * sm_rhou2 + ny * ps_rhou2;
608  jac2(2, 2) = sm * rhovl_rhov2 + rhovl * sm_rhov2 + ny * ps_rhov2;
609  jac2(2, 3) = sm * rhovl_rhow2 + rhovl * sm_rhow2 + ny * ps_rhow2;
610  jac2(2, 4) = sm * rhovl_rhoe2 + rhovl * sm_rhoe2 + ny * ps_rhoe2;
611 
612  jac2(3, 0) = sm * rhowl_rho2 + rhowl * sm_rho2 + nz * ps_rho2;
613  jac2(3, 1) = sm * rhowl_rhou2 + rhowl * sm_rhou2 + nz * ps_rhou2;
614  jac2(3, 2) = sm * rhowl_rhov2 + rhowl * sm_rhov2 + nz * ps_rhov2;
615  jac2(3, 3) = sm * rhowl_rhow2 + rhowl * sm_rhow2 + nz * ps_rhow2;
616  jac2(3, 4) = sm * rhowl_rhoe2 + rhowl * sm_rhoe2 + nz * ps_rhoe2;
617 
618  jac2(4, 0) = sm * (rhoel_rho2 + ps_rho2) + rhoepl * sm_rho2;
619  jac2(4, 1) = sm * (rhoel_rhou2 + ps_rhou2) + rhoepl * sm_rhou2;
620  jac2(4, 2) = sm * (rhoel_rhov2 + ps_rhov2) + rhoepl * sm_rhov2;
621  jac2(4, 3) = sm * (rhoel_rhow2 + ps_rhow2) + rhoepl * sm_rhow2;
622  jac2(4, 4) = sm * (rhoel_rhoe2 + ps_rhoe2) + rhoepl * sm_rhoe2;
623  }
624  else if (sm <= 0. && s2 >= 0.)
625  {
627 
628  Real omeg2 = 1. / (s2 - sm);
629  Real prsta = rho2 * dsv2 * (sm - vdon2) + pres2;
630 
631  Real prst2 = prsta - pres2;
632 
634 
635  Real rhor = omeg2 * dsv2 * rho2;
636  Real rhour = omeg2 * (dsv2 * rhou2 + prst2 * nx);
637  Real rhovr = omeg2 * (dsv2 * rhov2 + prst2 * ny);
638  Real rhowr = omeg2 * (dsv2 * rhow2 + prst2 * nz);
639  Real rhoer = omeg2 * (dsv2 * rhoe2 - pres2 * vdon2 + prsta * sm);
640 
641  Real rhoepr = rhoer + prsta;
642 
644 
645  Real rhotd = std::max(eps, rho2 * (s2 - vdon2) - rho1 * (s1 - vdon1));
646  Real rhotm = 1. / rhotd;
647 
649 
650  Real sm_rho1 = rhotm * (-vdon1 * vdon1 + rq051 + sm * s1);
651  Real sm_rhou1 = rhotm * (nx * (2. * vdon1 - s1 - sm) - gamm1 * uadv1);
652  Real sm_rhov1 = rhotm * (ny * (2. * vdon1 - s1 - sm) - gamm1 * vadv1);
653  Real sm_rhow1 = rhotm * (nz * (2. * vdon1 - s1 - sm) - gamm1 * wadv1);
654  Real sm_rhoe1 = rhotm * gamm1;
655 
657 
658  Real sm_rho2 = rhotm * (vdon2 * vdon2 - rq052 - sm * s2);
659  Real sm_rhou2 = rhotm * (nx * (-2. * vdon2 + s2 + sm) + gamm1 * uadv2);
660  Real sm_rhov2 = rhotm * (ny * (-2. * vdon2 + s2 + sm) + gamm1 * vadv2);
661  Real sm_rhow2 = rhotm * (nz * (-2. * vdon2 + s2 + sm) + gamm1 * wadv2);
662  Real sm_rhoe2 = -rhotm * gamm1;
663 
665 
666  Real ps_rho1 = rho2 * dsv2 * sm_rho1;
667  Real ps_rhou1 = rho2 * dsv2 * sm_rhou1;
668  Real ps_rhov1 = rho2 * dsv2 * sm_rhov1;
669  Real ps_rhow1 = rho2 * dsv2 * sm_rhow1;
670  Real ps_rhoe1 = rho2 * dsv2 * sm_rhoe1;
671 
673 
674  Real ps_rho2 = rho1 * dsv1 * sm_rho2;
675  Real ps_rhou2 = rho1 * dsv1 * sm_rhou2;
676  Real ps_rhov2 = rho1 * dsv1 * sm_rhov2;
677  Real ps_rhow2 = rho1 * dsv1 * sm_rhow2;
678  Real ps_rhoe2 = rho1 * dsv1 * sm_rhoe2;
679 
682 
684 
685  Real rhor_rho2 = omeg2 * (s2 + rhor * sm_rho2);
686  Real rhor_rhou2 = omeg2 * (-nx + rhor * sm_rhou2);
687  Real rhor_rhov2 = omeg2 * (-ny + rhor * sm_rhov2);
688  Real rhor_rhow2 = omeg2 * (-nz + rhor * sm_rhow2);
689  Real rhor_rhoe2 = omeg2 * (rhor * sm_rhoe2);
690 
692 
693  Real rhor_rho1 = omeg2 * rhor * sm_rho1;
694  Real rhor_rhou1 = omeg2 * rhor * sm_rhou1;
695  Real rhor_rhov1 = omeg2 * rhor * sm_rhov1;
696  Real rhor_rhow1 = omeg2 * rhor * sm_rhow1;
697  Real rhor_rhoe1 = omeg2 * rhor * sm_rhoe1;
698 
700 
701  Real rhour_rho2 = omeg2 * (uadv2 * vdon2 - nx * rq052 + nx * ps_rho2 + rhour * sm_rho2);
702  Real rhour_rhou2 = omeg2 * (dsv2 - gamm2 * nx * uadv2 + nx * ps_rhou2 + rhour * sm_rhou2);
703  Real rhour_rhov2 =
704  omeg2 * (-uadv2 * ny + gamm1 * nx * vadv2 + nx * ps_rhov2 + rhour * sm_rhov2);
705  Real rhour_rhow2 =
706  omeg2 * (-uadv2 * nz + gamm1 * nx * wadv2 + nx * ps_rhow2 + rhour * sm_rhow2);
707  Real rhour_rhoe2 = omeg2 * (-gamm1 * nx + nx * ps_rhoe2 + rhour * sm_rhoe2);
708 
710 
711  Real rhour_rho1 = omeg2 * (nx * ps_rho1 + rhour * sm_rho1);
712  Real rhour_rhou1 = omeg2 * (nx * ps_rhou1 + rhour * sm_rhou1);
713  Real rhour_rhov1 = omeg2 * (nx * ps_rhov1 + rhour * sm_rhov1);
714  Real rhour_rhow1 = omeg2 * (nx * ps_rhow1 + rhour * sm_rhow1);
715  Real rhour_rhoe1 = omeg2 * (nx * ps_rhoe1 + rhour * sm_rhoe1);
716 
718 
719  Real rhovr_rho2 = omeg2 * (vadv2 * vdon2 - ny * rq052 + ny * ps_rho2 + rhovr * sm_rho2);
720  Real rhovr_rhou2 =
721  omeg2 * (-vadv2 * nx + gamm1 * ny * uadv2 + ny * ps_rhou2 + rhovr * sm_rhou2);
722  Real rhovr_rhov2 = omeg2 * (dsv2 - gamm2 * ny * vadv2 + ny * ps_rhov2 + rhovr * sm_rhov2);
723  Real rhovr_rhow2 =
724  omeg2 * (-vadv2 * nz + gamm1 * ny * wadv2 + ny * ps_rhow2 + rhovr * sm_rhow2);
725  Real rhovr_rhoe2 = omeg2 * (-gamm1 * ny + ny * ps_rhoe2 + rhovr * sm_rhoe2);
726 
728 
729  Real rhovr_rho1 = omeg2 * (ny * ps_rho1 + rhovr * sm_rho1);
730  Real rhovr_rhou1 = omeg2 * (ny * ps_rhou1 + rhovr * sm_rhou1);
731  Real rhovr_rhov1 = omeg2 * (ny * ps_rhov1 + rhovr * sm_rhov1);
732  Real rhovr_rhow1 = omeg2 * (ny * ps_rhow1 + rhovr * sm_rhow1);
733  Real rhovr_rhoe1 = omeg2 * (ny * ps_rhoe1 + rhovr * sm_rhoe1);
734 
736 
737  Real rhowr_rho2 = omeg2 * (wadv2 * vdon2 - nz * rq052 + nz * ps_rho2 + rhowr * sm_rho2);
738  Real rhowr_rhou2 =
739  omeg2 * (-wadv2 * nx + gamm1 * nz * uadv2 + nz * ps_rhou2 + rhowr * sm_rhou2);
740  Real rhowr_rhov2 =
741  omeg2 * (-wadv2 * ny + gamm1 * nz * vadv2 + nz * ps_rhov2 + rhowr * sm_rhov2);
742  Real rhowr_rhow2 = omeg2 * (dsv2 - gamm2 * nz * wadv2 + nz * ps_rhow2 + rhowr * sm_rhow2);
743  Real rhowr_rhoe2 = omeg2 * (-gamm1 * nz + nz * ps_rhoe2 + rhowr * sm_rhoe2);
744 
746 
747  Real rhowr_rho1 = omeg2 * (nz * ps_rho1 + rhowr * sm_rho1);
748  Real rhowr_rhou1 = omeg2 * (nz * ps_rhou1 + rhowr * sm_rhou1);
749  Real rhowr_rhov1 = omeg2 * (nz * ps_rhov1 + rhowr * sm_rhov1);
750  Real rhowr_rhow1 = omeg2 * (nz * ps_rhow1 + rhowr * sm_rhow1);
751  Real rhowr_rhoe1 = omeg2 * (nz * ps_rhoe1 + rhowr * sm_rhoe1);
752 
756 
757  Real rhoer_rho2 = omeg2 * (vdon2 * enth2 - vdon2 * rq052 + sm * ps_rho2 + rhoepr * sm_rho2);
758  Real rhoer_rhou2 =
759  omeg2 * (-nx * enth2 + gamm1 * vdon2 * uadv2 + sm * ps_rhou2 + rhoepr * sm_rhou2);
760  Real rhoer_rhov2 =
761  omeg2 * (-ny * enth2 + gamm1 * vdon2 * vadv2 + sm * ps_rhov2 + rhoepr * sm_rhov2);
762  Real rhoer_rhow2 =
763  omeg2 * (-nz * enth2 + gamm1 * vdon2 * wadv2 + sm * ps_rhow2 + rhoepr * sm_rhow2);
764  Real rhoer_rhoe2 = omeg2 * (s2 - vdon2 * gamma + sm * ps_rhoe2 + rhoepr * sm_rhoe2);
765 
767 
768  Real rhoer_rho1 = omeg2 * (sm * ps_rho1 + rhoepr * sm_rho1);
769  Real rhoer_rhou1 = omeg2 * (sm * ps_rhou1 + rhoepr * sm_rhou1);
770  Real rhoer_rhov1 = omeg2 * (sm * ps_rhov1 + rhoepr * sm_rhov1);
771  Real rhoer_rhow1 = omeg2 * (sm * ps_rhow1 + rhoepr * sm_rhow1);
772  Real rhoer_rhoe1 = omeg2 * (sm * ps_rhoe1 + rhoepr * sm_rhoe1);
773 
775 
776  jac2(0, 0) = sm * rhor_rho2 + rhor * sm_rho2;
777  jac2(0, 1) = sm * rhor_rhou2 + rhor * sm_rhou2;
778  jac2(0, 2) = sm * rhor_rhov2 + rhor * sm_rhov2;
779  jac2(0, 3) = sm * rhor_rhow2 + rhor * sm_rhow2;
780  jac2(0, 4) = sm * rhor_rhoe2 + rhor * sm_rhoe2;
781 
782  jac2(1, 0) = sm * rhour_rho2 + rhour * sm_rho2 + nx * ps_rho2;
783  jac2(1, 1) = sm * rhour_rhou2 + rhour * sm_rhou2 + nx * ps_rhou2;
784  jac2(1, 2) = sm * rhour_rhov2 + rhour * sm_rhov2 + nx * ps_rhov2;
785  jac2(1, 3) = sm * rhour_rhow2 + rhour * sm_rhow2 + nx * ps_rhow2;
786  jac2(1, 4) = sm * rhour_rhoe2 + rhour * sm_rhoe2 + nx * ps_rhoe2;
787 
788  jac2(2, 0) = sm * rhovr_rho2 + rhovr * sm_rho2 + ny * ps_rho2;
789  jac2(2, 1) = sm * rhovr_rhou2 + rhovr * sm_rhou2 + ny * ps_rhou2;
790  jac2(2, 2) = sm * rhovr_rhov2 + rhovr * sm_rhov2 + ny * ps_rhov2;
791  jac2(2, 3) = sm * rhovr_rhow2 + rhovr * sm_rhow2 + ny * ps_rhow2;
792  jac2(2, 4) = sm * rhovr_rhoe2 + rhovr * sm_rhoe2 + ny * ps_rhoe2;
793 
794  jac2(3, 0) = sm * rhowr_rho2 + rhowr * sm_rho2 + nz * ps_rho2;
795  jac2(3, 1) = sm * rhowr_rhou2 + rhowr * sm_rhou2 + nz * ps_rhou2;
796  jac2(3, 2) = sm * rhowr_rhov2 + rhowr * sm_rhov2 + nz * ps_rhov2;
797  jac2(3, 3) = sm * rhowr_rhow2 + rhowr * sm_rhow2 + nz * ps_rhow2;
798  jac2(3, 4) = sm * rhowr_rhoe2 + rhowr * sm_rhoe2 + nz * ps_rhoe2;
799 
800  jac2(4, 0) = sm * (rhoer_rho2 + ps_rho2) + rhoepr * sm_rho2;
801  jac2(4, 1) = sm * (rhoer_rhou2 + ps_rhou2) + rhoepr * sm_rhou2;
802  jac2(4, 2) = sm * (rhoer_rhov2 + ps_rhov2) + rhoepr * sm_rhov2;
803  jac2(4, 3) = sm * (rhoer_rhow2 + ps_rhow2) + rhoepr * sm_rhow2;
804  jac2(4, 4) = sm * (rhoer_rhoe2 + ps_rhoe2) + rhoepr * sm_rhoe2;
805 
807 
808  jac1(0, 0) = sm * rhor_rho1 + rhor * sm_rho1;
809  jac1(0, 1) = sm * rhor_rhou1 + rhor * sm_rhou1;
810  jac1(0, 2) = sm * rhor_rhov1 + rhor * sm_rhov1;
811  jac1(0, 3) = sm * rhor_rhow1 + rhor * sm_rhow1;
812  jac1(0, 4) = sm * rhor_rhoe1 + rhor * sm_rhoe1;
813 
814  jac1(1, 0) = sm * rhour_rho1 + rhour * sm_rho1 + nx * ps_rho1;
815  jac1(1, 1) = sm * rhour_rhou1 + rhour * sm_rhou1 + nx * ps_rhou1;
816  jac1(1, 2) = sm * rhour_rhov1 + rhour * sm_rhov1 + nx * ps_rhov1;
817  jac1(1, 3) = sm * rhour_rhow1 + rhour * sm_rhow1 + nx * ps_rhow1;
818  jac1(1, 4) = sm * rhour_rhoe1 + rhour * sm_rhoe1 + nx * ps_rhoe1;
819 
820  jac1(2, 0) = sm * rhovr_rho1 + rhovr * sm_rho1 + ny * ps_rho1;
821  jac1(2, 1) = sm * rhovr_rhou1 + rhovr * sm_rhou1 + ny * ps_rhou1;
822  jac1(2, 2) = sm * rhovr_rhov1 + rhovr * sm_rhov1 + ny * ps_rhov1;
823  jac1(2, 3) = sm * rhovr_rhow1 + rhovr * sm_rhow1 + ny * ps_rhow1;
824  jac1(2, 4) = sm * rhovr_rhoe1 + rhovr * sm_rhoe1 + ny * ps_rhoe1;
825 
826  jac1(3, 0) = sm * rhowr_rho1 + rhowr * sm_rho1 + nz * ps_rho1;
827  jac1(3, 1) = sm * rhowr_rhou1 + rhowr * sm_rhou1 + nz * ps_rhou1;
828  jac1(3, 2) = sm * rhowr_rhov1 + rhowr * sm_rhov1 + nz * ps_rhov1;
829  jac1(3, 3) = sm * rhowr_rhow1 + rhowr * sm_rhow1 + nz * ps_rhow1;
830  jac1(3, 4) = sm * rhowr_rhoe1 + rhowr * sm_rhoe1 + nz * ps_rhoe1;
831 
832  jac1(4, 0) = sm * (rhoer_rho1 + ps_rho1) + rhoepr * sm_rho1;
833  jac1(4, 1) = sm * (rhoer_rhou1 + ps_rhou1) + rhoepr * sm_rhou1;
834  jac1(4, 2) = sm * (rhoer_rhov1 + ps_rhov1) + rhoepr * sm_rhov1;
835  jac1(4, 3) = sm * (rhoer_rhow1 + ps_rhow1) + rhoepr * sm_rhow1;
836  jac1(4, 4) = sm * (rhoer_rhoe1 + ps_rhoe1) + rhoepr * sm_rhoe1;
837  }
838  else if (s2 < 0.)
839  {
841 
842  jac2(0, 0) = 0.;
843  jac2(0, 1) = nx;
844  jac2(0, 2) = ny;
845  jac2(0, 3) = nz;
846  jac2(0, 4) = 0.;
847 
848  jac2(1, 0) = rq052 * nx - uadv2 * vdon2;
849  jac2(1, 1) = gamm2 * nx * uadv2 + vdon2;
850  jac2(1, 2) = ny * uadv2 - vadv2 * gamm1 * nx;
851  jac2(1, 3) = nz * uadv2 - wadv2 * gamm1 * nx;
852  jac2(1, 4) = gamm1 * nx;
853 
854  jac2(2, 0) = rq052 * ny - vadv2 * vdon2;
855  jac2(2, 1) = nx * vadv2 - uadv2 * gamm1 * ny;
856  jac2(2, 2) = gamm2 * ny * vadv2 + vdon2;
857  jac2(2, 3) = nz * vadv2 - wadv2 * gamm1 * ny;
858  jac2(2, 4) = gamm1 * ny;
859 
860  jac2(3, 0) = rq052 * nz - wadv2 * vdon2;
861  jac2(3, 1) = nx * wadv2 - uadv2 * gamm1 * ny;
862  jac2(3, 2) = ny * wadv2 - vadv2 * gamm1 * ny;
863  jac2(3, 3) = gamm2 * nz * wadv2 + vdon2;
864  jac2(3, 4) = gamm1 * ny;
865 
866  jac2(4, 0) = (rq052 - enth2) * vdon2;
867  jac2(4, 1) = nx * enth2 - gamm1 * uadv2 * vdon2;
868  jac2(4, 2) = ny * enth2 - gamm1 * vadv2 * vdon2;
869  jac2(4, 3) = nz * enth2 - gamm1 * wadv2 * vdon2;
870  jac2(4, 4) = gamma * vdon2;
871  }
872  else
873  {
875 
876  Real omeg1 = 1. / (s1 - sm);
877  Real omeg2 = 1. / (s2 - sm);
878  Real prsta = rho1 * dsv1 * (sm - vdon1) + pres1;
879 
880  mooseError("Weird wave speed occured in ",
881  name(),
882  ": ",
883  __FUNCTION__,
884  "\n",
885  "iside = ",
886  iside,
887  "\n",
888  "ielem = ",
889  ielem,
890  "\n",
891  "ineig = ",
892  ineig,
893  "\n",
894  "rho1 = ",
895  rho1,
896  "\n",
897  "rhou1 = ",
898  rhou1,
899  "\n",
900  "rhov1 = ",
901  rhov1,
902  "\n",
903  "rhow1 = ",
904  rhow1,
905  "\n",
906  "rhoe1 = ",
907  rhoe1,
908  "\n",
909  "pres1 = ",
910  pres1,
911  "\n",
912  "enth1 = ",
913  enth1,
914  "\n",
915  "csou1 = ",
916  csou1,
917  "\n",
918  "rho2 = ",
919  rho2,
920  "\n",
921  "rhou2 = ",
922  rhou2,
923  "\n",
924  "rhov2 = ",
925  rhov2,
926  "\n",
927  "rhoe2 = ",
928  rhoe2,
929  "\n",
930  "pres2 = ",
931  pres2,
932  "\n",
933  "enth2 = ",
934  enth2,
935  "\n",
936  "csou2 = ",
937  csou2,
938  "\n",
939  "vdon1 = ",
940  vdon1,
941  "\n",
942  "vdon2 = ",
943  vdon2,
944  "\n",
945  "vnave = ",
946  vnave,
947  "\n",
948  "cssav = ",
949  cssav,
950  "\n",
951  "s1 = ",
952  s1,
953  "\n",
954  "s2 = ",
955  s2,
956  "\n",
957  "sm = ",
958  sm,
959  "\n",
960  "omeg1 = ",
961  omeg1,
962  "\n",
963  "omeg2 = ",
964  omeg2,
965  "\n",
966  "prsta = ",
967  prsta,
968  "\n",
969  "Please check before continuing!\n");
970  }
971 }
InputParameters validParams< InternalSideFluxBase >()
virtual Real c(Real v, Real u) const =0
Sound speed.
InputParameters validParams< CNSFVHLLCInternalSideFlux >()
CNSFVHLLCInternalSideFlux(const InputParameters &parameters)
const SinglePhaseFluidProperties & _fp
Common class for single phase fluid properties.
virtual void calcJacobian(unsigned int iside, dof_id_type ielem, dof_id_type ineig, const std::vector< Real > &uvec1, const std::vector< Real > &uvec2, const RealVectorValue &dwave, DenseMatrix< Real > &jac1, DenseMatrix< Real > &jac2) const
Compute the Jacobian matrix.
A base class for computing and caching internal side flux.
virtual void calcFlux(unsigned int iside, dof_id_type ielem, dof_id_type ineig, const std::vector< Real > &uvec1, const std::vector< Real > &uvec2, const RealVectorValue &dwave, std::vector< Real > &flux) const
Solve the Riemann problem.
virtual Real gamma(Real v, Real u) const
Compute the ratio of specific heats.
virtual Real pressure(Real v, Real u) const =0
Pressure as a function of specific internal energy and specific volume.