PLUTO
ppm_states.c
Go to the documentation of this file.
1 /* ///////////////////////////////////////////////////////////////////// */
2 /*!
3  \file
4  \brief Piecewise parabolic reconstruction.
5 
6  Compute interface states using piecewise parabolic reconstruction
7  inside each zone.
8  Reconstruction is performed in primitive variable (when
9  <tt>CHAR_LIMITING == NO</tt>) or characteristic variables
10  (when <tt>CHAR_LIMITING == YES</tt>).
11  The reconstruction process follows the following steps:
12  - compute unlimited 4-th or 5-th order interface values from within
13  the zone (\f${\rm vp} = v_{i,+},\; {\rm vm} = v_{i,-} \f$).
14 
15  - interface states must lie between adjacent cell averages.
16  This is achieved by working on the increments,
17  \f[
18  \left\{\begin{array}{lll}
19  \min(v_{i+1},v_i) \le v_{i,+} \le \max(v_{i+1},v_i)
20  & \qquad \Longrightarrow\qquad &
21  \delta v_{i,+} \to {\rm minmod}(\delta v_{i,+}, \Delta v_{i+\HALF})
22  \\ \noalign{\medskip}
23  \min(v_{i-1},v_i) \le v_{i,-} \le \max(v_{i-1},v_i)
24  & \qquad \Longrightarrow\qquad &
25  \delta v_{i,-} \to {\rm minmod}(\delta v_{i,-}, \Delta v_{i+\HALF})
26  \end{array}\right.
27  \f]
28  where \f$\delta v_{i,\pm} = v_{i,\pm} - v_i\f$.
29  This step is equivalent to Eq. [45] of Mignone (JCP, 2014).
30  The previous operation replaces, starting with PLUTO 4.1, the
31  conventional van-Leer limiting used in the original PPM formulation.
32 
33  - the parabola does not take any extrema inside the zone, see
34  Eq. [46] in Mignone (JCP, 2014).
35 
36  When interpolation is carried out in characteristic variables, we
37  first compute \c vp and \c vm (unlimited) in primitive variables and
38  then project the increments in characteristic space:
39  \f[
40  \delta w_{i,\pm} = \vec{l}_i\cdot\delta v_{i,\pm}
41  \f]
42  At this point, Eq. [45] (written in terms of increments) is
43  imposed on characteristic variables while Eq. [46] can be imposed
44  in characteristic variables (<tt>PRIMITIVE_LIM == 0</tt>),
45  primitive (<tt>PRIMITIVE_LIM == 1</tt>) or both
46  (<tt>PRIMITIVE_LIM == 2</tt>).
47 
48 
49  \author A. Mignone (mignone@ph.unito.it)
50  \date June 11, 2015
51 
52  \b References
53  - "High-order conservative reconstruction schemes for finite
54  volume methods in cylindrical and spherical coordinates"
55  A. Mignone, JCP (2014), 270, 784.
56  - "Accurate monotonicity- and extrema-preserving methods
57  through adaptive nonlinear hybridizations"
58  Rider, Greenough and Kamm, JCP (2007) 225, 1827
59  - "A limiter for PPM that preserved accuracy at smooth extrema"
60  Colella and Sekora, JCP (2008) 227, 7069
61 
62 */
63 /* ///////////////////////////////////////////////////////////////////// */
64 #include "pluto.h"
65 
66 #if CHAR_LIMITING == NO
67 /* ********************************************************************** */
68 void States (const State_1D *state, int beg, int end, Grid *grid)
69 /*!
70  *
71  * \param [in] state pointer to State_1D structure
72  * \param [in] beg initial index of computation
73  * \param [in] end final index of computation
74  * \param [in] grid pointer to an array of Grid structures
75  *
76  ************************************************************************ */
77 {
78  int i, nv;
79  double dv, **v;
80  double dvp, cp, *wp, *hp, **vp;
81  double dvm, cm, *wm, *hm, **vm;
82  PPM_Coeffs ppm_coeffs;
83  PLM_Coeffs plm_coeffs;
84 
85 /* ---------------------------------------------------------
86  0. Set pointers, compute geometrical coefficients
87  --------------------------------------------------------- */
88 
89  v = state->v;
90  vm = state->vm;
91  vp = state->vp;
92 
93  PPM_CoefficientsGet(&ppm_coeffs, g_dir);
94  #if SHOCK_FLATTENING == MULTID
95  PLM_CoefficientsGet(&plm_coeffs, g_dir);
96  #endif
97 
98  hp = ppm_coeffs.hp;
99  hm = ppm_coeffs.hm;
100 
101 /* ---------------------------------------
102  1b. Need to reconstruct 4-velocity ?
103  --------------------------------------- */
104 
105 #if RECONSTRUCT_4VEL
106  ConvertTo4vel (state->v, beg-2, end+2);
107 #endif
108 
109 /* ---------------------------------------------------------
110  2a. Define unlimited left and right interface values and
111  make sure they lie between adjacent cell averages.
112  --------------------------------------------------------- */
113 
114  #if PPM_ORDER == 3 || PPM_ORDER == 5
115  for (i = beg; i <= end; i++) {
116  wp = ppm_coeffs.wp[i];
117  wm = ppm_coeffs.wm[i];
118  VAR_LOOP(nv){
119  #if PPM_ORDER == 3
120  vp[i][nv] = wp[-1]*v[i-1][nv] + wp[0]*v[i][nv] + wp[1]*v[i+1][nv];
121  vm[i][nv] = wm[-1]*v[i-1][nv] + wm[0]*v[i][nv] + wm[1]*v[i+1][nv];
122  #elif PPM_ORDER == 5
123  vp[i][nv] = wp[-2]*v[i-2][nv] + wp[-1]*v[i-1][nv] +
124  wp[ 0]*v[i][nv] + wp[ 1]*v[i+1][nv] + wp[ 2]*v[i+2][nv];
125 
126  vm[i][nv] = wm[-2]*v[i-2][nv] + wm[-1]*v[i-1][nv] + wm[0]*v[i][nv]
127  + wm[ 1]*v[i+1][nv] + wm[ 2]*v[i+2][nv];
128  #endif
129  dvp = vp[i][nv] - v[i][nv];
130  dvm = vm[i][nv] - v[i][nv];
131 
132  dv = v[i+1][nv] - v[i][nv];
133  vp[i][nv] = v[i][nv] + MINMOD(dvp, dv);
134 
135  dv = v[i][nv] - v[i-1][nv];
136  vm[i][nv] = v[i][nv] + MINMOD(dvm, -dv);
137  }
138  }
139  #elif PPM_ORDER == 4 /* -- set a unique interface value -- */
140  for (i = beg-1; i <= end; i++) {
141  wp = ppm_coeffs.wp[i];
142  VAR_LOOP(nv){
143  vp[i][nv] = wp[-1]*v[i-1][nv] + wp[0]*v[i][nv]
144  + wp[ 1]*v[i+1][nv] + wp[2]*v[i+2][nv];
145 
146  dv = v[i+1][nv] - v[i][nv];
147  dvp = vp[i][nv] - v[i][nv];
148  vp[i][nv] = v[i][nv] + MINMOD(dvp, dv);
149  }
150  }
151  for (i = beg; i <= end; i++) VAR_LOOP(nv) vm[i][nv] = vp[i-1][nv];
152  #endif
153 
154 /* ---------------------------------------------------------
155  2b. Apply parabolic limiter: no new extrema should appear
156  in the parabola defined by vp, vm and v.
157  --------------------------------------------------------- */
158 
159  for (i = beg; i <= end; i++) {
160 #if SHOCK_FLATTENING == MULTID
161  if (state->flag[i] & FLAG_MINMOD) {
162  wp = plm_coeffs.wp;
163  wm = plm_coeffs.wm;
164  VAR_LOOP(nv) {
165  dvp = (v[i+1][nv] - v[i][nv])*wp[i];
166  dvm = (v[i][nv] - v[i-1][nv])*wm[i];
167  dv = MINMOD(dvp, dvm);
168  vp[i][nv] = v[i][nv] + dv*plm_coeffs.dp[i];
169  vm[i][nv] = v[i][nv] - dv*plm_coeffs.dm[i];
170  }
171  #if PHYSICS == RHD || PHYSICS == RMHD
172  VelocityLimiter (v[i], vp[i], vm[i]);
173  #endif
174  continue;
175  }
176 #endif
177 
178  #if PPM_ORDER == 0
179  cm = cp = 2.0;
180  #else
181  cm = (hm[i] + 1.0)/(hp[i] - 1.0);
182  cp = (hp[i] + 1.0)/(hm[i] - 1.0);
183  #endif
184 
185  for (nv = 0; nv < NVAR; nv++){
186  dvp = vp[i][nv] - v[i][nv];
187  dvm = vm[i][nv] - v[i][nv];
188 
189  if (dvp*dvm >= 0.0) dvp = dvm = 0.0;
190  else{
191  if (fabs(dvp) >= cm*fabs(dvm)) dvp = -cm*dvm;
192  else if (fabs(dvm) >= cp*fabs(dvp)) dvm = -cp*dvp;
193  }
194  vp[i][nv] = v[i][nv] + dvp;
195  vm[i][nv] = v[i][nv] + dvm;
196  }
197  #if PHYSICS == RHD || PHYSICS == RMHD
198  VelocityLimiter (v[i], vp[i], vm[i]);
199  #endif
200  }
201 
202 /* --------------------------------------------------------
203  3a. Apply 1D shock flattening
204  -------------------------------------------------------- */
205 
206  #if SHOCK_FLATTENING == YES
207  Flatten (state, beg, end, grid);
208  #endif
209 
210 /* -------------------------------------------
211  4. Assign face-centered magnetic field
212  ------------------------------------------- */
213 
214  #ifdef STAGGERED_MHD
215  for (i = beg-1; i <= end; i++) {
216  state->vR[i][BXn] = state->vL[i][BXn] = state->bn[i];
217  }
218  #endif
219 
220 /* --------------------------------------------------------
221  5. Evolve L/R states and center value by dt/2
222  -------------------------------------------------------- */
223 
224 #if TIME_STEPPING == CHARACTERISTIC_TRACING
225  CharTracingStep (state, beg, end, grid);
226 #endif
227 
228 /* --------------------------------------------------------
229  6. Convert back to 3-velocity
230  -------------------------------------------------------- */
231 
232 #if RECONSTRUCT_4VEL
233  ConvertTo3vel (state->v, beg-2, end+2);
234  ConvertTo3vel (state->vp, beg, end);
235  ConvertTo3vel (state->vm, beg, end);
236 #endif
237 
238 /* ----------------------------------------------
239  7. Obtain L/R states in conservative variables
240  ---------------------------------------------- */
241 
242  PrimToCons (state->vp, state->up, beg, end);
243  PrimToCons (state->vm, state->um, beg, end);
244 }
245 #endif /* CHAR_LIMITING == NO */
246 
247 
248 
249 #if CHAR_LIMITING == YES
250 
251 /* ---------------------------------------------------------
252  Set PARABOLIC_LIM to 0,1,2 to apply the parabolic
253  limiter of PPM to either characteristic (0),
254  primitive (1) or both variables (2).
255  --------------------------------------------------------- */
256 
257 #define PARABOLIC_LIM 1
258 /* ********************************************************************* */
259 void States (const State_1D *state, int beg, int end, Grid *grid)
260 /*
261  *
262  *********************************************************************** */
263 {
264  int i, j, k, nv, S=1;
265  double dtdx, dx, dx2;
266  double dp, cp, dvp[NVAR], dwp[NVAR], dwp1[NVAR], *wp, *hp, **vp;
267  double dm, cm, dvm[NVAR], dwm[NVAR], dwm1[NVAR], *wm, *hm, **vm;
268  double dv, **v, **L, **R, *lambda;
269  double tau, a0, a1, w0, w1;
270  static double **dvF, **vppm4;
271  PPM_Coeffs ppm_coeffs;
272  PLM_Coeffs plm_coeffs;
273 
274 /* ---------------------------------------------
275  0. Allocate memory and set pointer shortcuts,
276  get interp. coefficients
277  --------------------------------------------- */
278 
279  if (dvF == NULL){
280  dvF = ARRAY_2D(NMAX_POINT, NVAR, double);
281  vppm4 = ARRAY_2D(NMAX_POINT,NVAR,double);
282  }
283  v = state->v;
284  vp = state->vp;
285  vm = state->vm;
286 
287 #if RECONSTRUCT_4VEL
288  ConvertTo4vel (state->v, beg-2, end+2);
289 #endif
290 
291  PPM_CoefficientsGet(&ppm_coeffs, g_dir);
292 #if SHOCK_FLATTENING == MULTID
293  PLM_CoefficientsGet(&plm_coeffs, g_dir);
294 #endif
295 
296  hp = ppm_coeffs.hp;
297  hm = ppm_coeffs.hm;
298 
299 /* ---------------------------------------------
300  define some useful quantities, compute
301  source term and undivided differences
302  --------------------------------------------- */
303 
304  #if RECONSTRUCTION == PARABOLIC
305  S = 2;
306  #endif
307  SoundSpeed2 (state->v, state->a2, state->h, beg, end, CELL_CENTER, grid);
308 
309  for (i = beg-S; i <= end+S-1; i++){
310  NVAR_LOOP(nv) dvF[i][nv] = v[i+1][nv] - v[i][nv];
311  }
312 
313 /* -----------------------------------------------------------
314  1. Compute unlimited interface values in primitive vars
315  ----------------------------------------------------------- */
316 
317  #if RECONSTRUCTION == PARABOLIC && PPM_ORDER != 4
318  print1 ("! States(): characteristic PPM interpolation requires PPM_ORDER = 4\n");
319  QUIT_PLUTO(1);
320  #endif
321  for (i = beg-1; i <= end; i++) {
322  wp = ppm_coeffs.wp[i];
323  VAR_LOOP(nv){
324  vppm4[i][nv] = wp[-1]*v[i-1][nv] + wp[0]*v[i][nv]
325  + wp[ 1]*v[i+1][nv] + wp[2]*v[i+2][nv];
326  }
327  }
328 
329 /* --------------------------------------------------------------
330  2. Begin main spatial loop
331  -------------------------------------------------------------- */
332 
333  for (i = beg; i <= end; i++){
334 
335  dx = grid[g_dir].dx[beg];
336  dx2 = dx*dx;
337  dtdx = g_dt/dx;
338 
339  /* ------------------------------------------------------------------
340  2a. Compute eigenvectors at cell center
341  ------------------------------------------------------------------ */
342 
343  L = state->Lp[i];
344  R = state->Rp[i];
345  lambda = state->lambda[i];
346 
347  PrimEigenvectors(v[i], state->a2[i], state->h[i], lambda, L, R);
348  #if NVAR != NFLX
349  for (k = NFLX; k < NVAR; k++) lambda[k] = v[i][VXn];
350  #endif
351 
352 #if SHOCK_FLATTENING == MULTID
353  if (state->flag[i] & FLAG_MINMOD) {
354  for (nv = 0; nv < NVAR; nv++){
355  dp = dvF[i][nv] *plm_coeffs.wp[i];
356  dm = dvF[i-1][nv]*plm_coeffs.wm[i];
357  dv = MINMOD(dp, dm);
358  vp[i][nv] = v[i][nv] + dv*plm_coeffs.dp[i];
359  vm[i][nv] = v[i][nv] - dv*plm_coeffs.dm[i];
360  }
361  #if PHYSICS == RHD || PHYSICS == RMHD
362  VelocityLimiter (v[i], vp[i], vm[i]);
363  #endif
364  continue;
365  }
366 #endif /* SHOCK_FLATTENING == MULTID */
367 
368  /* ------------------------------------------------------------------
369  2a. Project unlimited increments (vp - v) and (vm - v)
370  along characteristics and apply limiter.
371  ------------------------------------------------------------------ */
372 
373  #if RECONSTRUCTION == WENO3
374 
375  /* -- compute undivided differences and
376  reconstruct characteristic fields -- */
377 
378  PrimToChar(L, dvF[i-1], dwm1);
379  PrimToChar(L, dvF[i ], dwp1);
380  for (k = 0; k < NVAR; k++){
381  tau = (dwp1[k] - dwm1[k]);
382  tau = tau*tau;
383 
384  a0 = 1.0 + tau/(dx2 + dwp1[k]*dwp1[k]);
385  a1 = 1.0 + tau/(dx2 + dwm1[k]*dwm1[k]);
386 
387  dwp[k] = (a0*dwp1[k] + 0.5*a1*dwm1[k])/(2.0*a0 + a1);
388  dwm[k] = -(a1*dwm1[k] + 0.5*a0*dwp1[k])/(2.0*a1 + a0);
389  }
390 
391  #endif /* RECONSTRUCTION == WENO3 */
392 
393  #if RECONSTRUCTION == PARABOLIC
394 
395  /* -- write states in terms of differences -- */
396 
397  VAR_LOOP(nv) {
398  dvp[nv] = vppm4[i][nv] - v[i][nv];
399  dvm[nv] = vppm4[i-1][nv] - v[i][nv];
400  }
401 
402  /* -- Project to characteristic spcae -- */
403 
404  PrimToChar(L, dvp, dwp);
405  PrimToChar(L, dvm, dwm);
406 
407  PrimToChar(L, dvF[i-1], dwm1);
408  PrimToChar(L, dvF[i ], dwp1);
409 
410  /* -- Enforce monotonicity by constraining interface
411  values to lie between adjacent cell averages -- */
412 
413  for (k = 0; k < NVAR; k++){
414  dwp[k] = MINMOD(dwp[k], dwp1[k]);
415  dwm[k] = MINMOD(dwm[k], -dwm1[k]);
416  }
417 
418  /* -- cm and cp are coefficients used in the parabolic limiter -- */
419 
420  cm = (hm[i] + 1.0)/(hp[i] - 1.0);
421  cp = (hp[i] + 1.0)/(hm[i] - 1.0);
422 
423  /* -- parabolic limiter using characteristics or primitive -- */
424 
425  #if PARABOLIC_LIM == 0 || PARABOLIC_LIM == 2
426  for (k = 0; k < NVAR; k++){
427  if (dwp[k]*dwm[k] >= 0.0) dwm[k] = dwp[k] = 0.0;
428  else{
429  if (fabs(dwp[k]) >= cm*fabs(dwm[k])) dwp[k] = -cm*dwm[k];
430  else if (fabs(dwm[k]) >= cp*fabs(dwp[k])) dwm[k] = -cp*dwp[k];
431  }
432  }
433  #endif
434 
435  #endif /* RECONSTRUCTION == PARABOLIC */
436 
437  /* -------------------------------------------------------------------
438  2b. Project limited differences in characteristic variables on right
439  eigenvectors to obtain the corresponding primitive quantities,
440 
441  dv = \sum dw.R
442  ------------------------------------------------------------------- */
443 
444  for (nv = 0; nv < NFLX; nv++) {
445  dp = dm = 0.0;
446  for (k = 0; k < NFLX; k++){
447  dp += dwp[k]*R[nv][k];
448  dm += dwm[k]*R[nv][k];
449  }
450  dvp[nv] = dp;
451  dvm[nv] = dm;
452  }
453  #if NVAR != NFLX
454  for (nv = NFLX; nv < NVAR; nv++){
455  dvp[nv] = dwp[nv];
456  dvm[nv] = dwm[nv];
457  }
458  #endif
459 
460  /* --------------------------------------------------------------------
461  2c. Build L/R states in primitive variables and apply parabolic
462  limiter to primitive variables if required.
463  -------------------------------------------------------------------- */
464 
465  for (nv = 0; nv < NVAR; nv++) {
466  #if PARABOLIC_LIM == 1 || PARABOLIC_LIM == 2
467  if (dvp[nv]*dvm[nv] >= 0.0) dvp[nv] = dvm[nv] = 0.0;
468  else {
469  if (fabs(dvp[nv]) >= cm*fabs(dvm[nv])) dvp[nv] = -cm*dvm[nv];
470  else if (fabs(dvm[nv]) >= cp*fabs(dvp[nv])) dvm[nv] = -cp*dvp[nv];
471  }
472  #endif
473  vp[i][nv] = v[i][nv] + dvp[nv];
474  vm[i][nv] = v[i][nv] + dvm[nv];
475  }
476 
477  /* ------------------------------------------------------------------
478  2d. Make sure that left and right states at time t^n are
479  physically admissible. If not, use linear reconstruction on
480  density and pressure.
481  ------------------------------------------------------------------ */
482 
483  if (vp[i][RHO] < 0.0 || vm[i][RHO] < 0.0) {
484  dvp[RHO] = 0.5*(MINMOD(dvF[i][RHO], dvF[i-1][RHO]));
485  dvm[RHO] = - dvp[RHO];
486  vp[i][RHO] = v[i][RHO] + dvp[RHO];
487  vm[i][RHO] = v[i][RHO] + dvm[RHO];
488  }
489  #if HAVE_ENERGY
490  if (vp[i][PRS] < 0.0 || vm[i][PRS] < 0.0) {
491  dvp[PRS] = 0.5*(MINMOD(dvF[i][PRS], dvF[i-1][PRS]));
492  dvm[PRS] = - dvp[PRS];
493  vp[i][PRS] = v[i][PRS] + dvp[PRS];
494  vm[i][PRS] = v[i][PRS] + dvm[PRS];
495  }
496  #endif
497 
498  #if PHYSICS == RHD || PHYSICS == RMHD
499  VelocityLimiter (v[i], vp[i], vm[i]);
500  #endif
501 
502  } /* -- end main loop on grid points -- */
503 
504 /* -------------------------------------------
505  3. Assign face-centered magnetic field
506  ------------------------------------------- */
507 
508  #ifdef STAGGERED_MHD
509  for (i = beg-1; i <= end; i++) {
510  state->vR[i][BXn] = state->vL[i][BXn] = state->bn[i];
511  }
512  #endif
513 
514 /* --------------------------------------------------------
515  5. Evolve L/R states and center value by dt/2
516  -------------------------------------------------------- */
517 
518  #if TIME_STEPPING == CHARACTERISTIC_TRACING
519  CharTracingStep(state, beg, end, grid);
520  #endif
521 
522 /* --------------------------------------------------------
523  6. Convert back to 3-velocity
524  -------------------------------------------------------- */
525 
526 #if RECONSTRUCT_4VEL
527  ConvertTo3vel (state->v, beg-2, end+2);
528  ConvertTo3vel (state->vp, beg, end);
529  ConvertTo3vel (state->vm, beg, end);
530 #endif
531 
532 /* ----------------------------------------------
533  7. Obtain L/R states in conservative variables
534  ---------------------------------------------- */
535 
536  PrimToCons (state->vp, state->up, beg, end);
537  PrimToCons (state->vm, state->um, beg, end);
538 }
539 #undef PARABOLIC_LIM
540 #endif /* CHAR_LIMITING == YES */
541 
STATE_1D::v
double ** v
Cell-centered primitive varables at the base time level, v[i] = .
Definition: structs.h:134
VelocityLimiter
void VelocityLimiter(double *, double *, double *)
Definition: vel_limiter.c:16
ConvertTo4vel
void ConvertTo4vel(double **, int, int)
Definition: four_vel.c:4
Flatten
void Flatten(const State_1D *, int, int, Grid *)
Definition: flatten.c:4
print1
void print1(const char *fmt,...)
Definition: amrPluto.cpp:511
STATE_1D::Lp
double *** Lp
Definition: structs.h:155
PrimEigenvectors
void PrimEigenvectors(double *q, double cs2, double h, double *lambda, double **LL, double **RR)
Definition: eigenv.c:91
RHO
#define RHO
Definition: mod_defs.h:19
CharTracingStep
void CharTracingStep(const State_1D *, int, int, Grid *)
Definition: char_tracing.c:198
PPM_CoefficientsGet
void PPM_CoefficientsGet(PPM_Coeffs *ppm_coeffs, int dir)
Definition: ppm_coeffs.c:591
g_dt
double g_dt
The current integration time step.
Definition: globals.h:118
PPM_COEFFS
Definition: ppm_coeffs.h:29
STATE_1D::vR
double ** vR
Primitive variables to the right of the interface, .
Definition: structs.h:139
GRID::dx
double * dx
Definition: structs.h:83
STATE_1D::h
double * h
Enthalpy.
Definition: structs.h:159
FLAG_MINMOD
#define FLAG_MINMOD
Reconstruct using MINMOD limiter.
Definition: pluto.h:179
SoundSpeed2
void SoundSpeed2(double **v, double *cs2, double *h, int beg, int end, int pos, Grid *grid)
Definition: eos.c:16
BXn
int BXn
Definition: globals.h:75
STATE_1D::vp
double ** vp
prim vars at i+1/2 edge, vp[i] = vL(i+1/2)
Definition: structs.h:142
PPM_COEFFS::hm
double * hm
Definition: ppm_coeffs.h:33
PPM_COEFFS::wp
double ** wp
Definition: ppm_coeffs.h:30
CELL_CENTER
#define CELL_CENTER
Definition: pluto.h:205
VAR_LOOP
#define VAR_LOOP(n)
Definition: macros.h:226
NFLX
#define NFLX
Definition: mod_defs.h:32
g_dir
int g_dir
Specifies the current sweep or direction of integration.
Definition: globals.h:86
NVAR_LOOP
#define NVAR_LOOP(n)
Definition: pluto.h:618
GRID
Definition: structs.h:78
j
int j
Definition: analysis.c:2
STATE_1D::lambda
double ** lambda
Characteristic speed associated to Lp and Rp.
Definition: structs.h:156
STATE_1D::flag
unsigned char * flag
Definition: structs.h:168
k
int k
Definition: analysis.c:2
ConvertTo3vel
void ConvertTo3vel(double **, int, int)
Definition: four_vel.c:25
MINMOD
#define MINMOD(a, b)
Definition: macros.h:112
PrimToChar
void PrimToChar(double **L, double *v, double *w)
Definition: eigenv.c:593
VXn
int VXn
Definition: globals.h:73
STATE_1D::vm
double ** vm
prim vars at i-1/2 edge, vm[i] = vR(i-1/2)
Definition: structs.h:141
PLM_COEFFS
Definition: plm_coeffs.h:38
PLM_CoefficientsGet
void PLM_CoefficientsGet(PLM_Coeffs *plm_coeffs, int dir)
Definition: plm_coeffs.c:79
pluto.h
PLUTO main header file.
w0
#define w0
Definition: rk_step.c:20
PLM_COEFFS::dm
double * dm
Definition: plm_coeffs.h:44
PLM_COEFFS::dp
double * dp
Definition: plm_coeffs.h:43
NMAX_POINT
long int NMAX_POINT
Maximum number of points among the three directions, boundaries excluded.
Definition: globals.h:62
STATE_1D
Definition: structs.h:133
PrimToCons
void PrimToCons(double **uprim, double **ucons, int ibeg, int iend)
Definition: mappers.c:26
i
int i
Definition: analysis.c:2
PPM_COEFFS::hp
double * hp
Definition: ppm_coeffs.h:32
STATE_1D::bn
double * bn
Face magentic field, bn = bx(i+1/2)
Definition: structs.h:165
PPM_COEFFS::wm
double ** wm
Definition: ppm_coeffs.h:31
STATE_1D::um
double ** um
same as vm, in conservative vars
Definition: structs.h:146
PLM_COEFFS::wm
double * wm
Definition: plm_coeffs.h:42
STATE_1D::vL
double ** vL
Primitive variables to the left of the interface, .
Definition: structs.h:136
STATE_1D::a2
double * a2
Sound speed squared.
Definition: structs.h:158
STATE_1D::up
double ** up
same as vp, in conservative vars
Definition: structs.h:147
ARRAY_2D
#define ARRAY_2D(nx, ny, type)
Definition: prototypes.h:171
States
void States(const State_1D *state, int beg, int end, Grid *grid)
Definition: ppm_states.c:68
STATE_1D::Rp
double *** Rp
Left and right primitive eigenvectors.
Definition: structs.h:155
NVAR
#define NVAR
Definition: pluto.h:609
QUIT_PLUTO
#define QUIT_PLUTO(e_code)
Definition: macros.h:125
PLM_COEFFS::wp
double * wp
Definition: plm_coeffs.h:41