Euler1DFlux.c File Reference

Contains the functions to compute the hyperbolic flux for the 1D Euler equations over the domain. More...

#include <stdlib.h>
#include <arrayfunctions.h>
#include <physicalmodels/euler1d.h>
#include <hypar.h>

Go to the source code of this file.

Functions
int	Euler1DFlux (double *f, double *u, int dir, void *s, double t)
int	Euler1DStiffFlux (double *f, double *u, int dir, void *s, double t)

Detailed Description

Contains the functions to compute the hyperbolic flux for the 1D Euler equations over the domain.

Author

Debojyoti Ghosh

Definition in file Euler1DFlux.c.

Function Documentation

int Euler1DFlux	(	double *	f,
		double *	u,
		int	dir,
		void *	s,
		double	t
	)

Compute the hyperbolic flux over the local domain.

\begin{equation} {\bf F}\left({\bf u}\right) = \left[\begin{array}{c} \rho u \\ \rho u^2 + p \\ (e+p) u \end{array}\right] \end{equation}

Parameters

f	Array to hold the computed flux (same size and layout as u)
u	Array containing the conserved solution
dir	Spatial dimension (unused since this is a 1D system)
s	Solver object of type HyPar
t	Current time

Definition at line 16 of file Euler1DFlux.c.

{
  HyPar             *solver = (HyPar*)   s;
  Euler1D           *param  = (Euler1D*) solver->physics;
  int               *dim    = solver->dim_local;
  int               ghosts  = solver->ghosts;
  static const int  ndims   = _MODEL_NDIMS_;
  static const int  nvars   = _MODEL_NVARS_;
  static int        index[_MODEL_NDIMS_], bounds[_MODEL_NDIMS_], offset[_MODEL_NDIMS_];

  /* set bounds for array index to include ghost points */
  _ArrayAddCopy1D_(dim,(2*ghosts),bounds,ndims);
  /* set offset such that index is compatible with ghost point arrangement */
  _ArraySetValue_(offset,ndims,-ghosts);

  int done = 0; _ArraySetValue_(index,ndims,0);
  while (!done) {
    int p; _ArrayIndex1DWO_(ndims,dim,index,offset,ghosts,p);
    double rho, v, e, P;
    _Euler1DGetFlowVar_((u+nvars*p),rho,v,e,P,param);
    _Euler1DSetFlux_((f+nvars*p),rho,v,e,P);
    _ArrayIncrementIndex_(ndims,bounds,index,done);
  }

  return(0);
}

int Euler1DStiffFlux	(	double *	f,
		double *	u,
		int	dir,
		void *	s,
		double	t
	)

Compute the stiff component of the hyperbolic flux over the local domain.

\begin{equation} {\bf F}_F\left({\bf u}\right) = A_f\left({\bf u}\right){\bf u} \end{equation}

where \(A_f\left({\bf u}\right) \) is the fast Jacobian representing the acoustic waves only. A linearized formulation is used where the fast Jacobian \(A_f\) is computed for the solution at the beginning of each time step in Euler1DPreStep.

See Also

_Euler1DSetStiffFlux_, _Euler1DSetLinearizedStiffFlux_, _Euler1DSetStiffJac_

Reference:

• Ghosh, D., Constantinescu, E. M., Semi-Implicit Time Integration of Atmospheric Flows with Characteristic-Based Flux Partitioning, SIAM Journal on Scientific Computing, 38 (3), 2016, A1848-A1875, http://dx.doi.org/10.1137/15M1044369

Parameters

f	Array to hold the computed flux (same size and layout as u)
u	Array containing the conserved solution
dir	Spatial dimension (unused since this is a 1D system)
s	Solver object of type HyPar
t	Current time

Definition at line 64 of file Euler1DFlux.c.

{
  HyPar             *solver = (HyPar*)   s;
  Euler1D           *param  = (Euler1D*) solver->physics;
  int               *dim    = solver->dim_local;
  int               ghosts  = solver->ghosts;
  static const int  ndims   = _MODEL_NDIMS_;
  static const int  nvars   = _MODEL_NVARS_;
  static int        index[_MODEL_NDIMS_], bounds[_MODEL_NDIMS_], offset[_MODEL_NDIMS_];

  /* set bounds for array index to include ghost points */
  _ArrayAddCopy1D_(dim,(2*ghosts),bounds,ndims);
  /* set offset such that index is compatible with ghost point arrangement */
  _ArraySetValue_(offset,ndims,-ghosts);

  int done = 0; _ArraySetValue_(index,ndims,0);
  while (!done) {
    int p; _ArrayIndex1DWO_(ndims,dim,index,offset,ghosts,p);
    _Euler1DSetLinearizedStiffFlux_((f+nvars*p),(u+nvars*p),(param->fast_jac+nvars*nvars*p));
    _ArrayIncrementIndex_(ndims,bounds,index,done);
  }

  return(0);
}