shallowwater1d.h File Reference

1D Shallow Water Equations More...

#include <basic.h>
#include <math.h>
#include <matops.h>

Go to the source code of this file.

Data Structures
struct	ShallowWater1D
	Structure containing variables and parameters specific to the 1D Shallow Water equations. This structure contains the physical parameters, variables, and function pointers specific to the 1D ShallowWater equations. More...

Macros
#define	_SHALLOW_WATER_1D_   "shallow-water-1d"
#define	_MODEL_NDIMS_   1
#define	_MODEL_NVARS_   2
#define	_ROE_   "roe"
#define	_LLF_   "llf-char"
#define	_XDIR_   0
#define	_ShallowWater1DGetFlowVar_(u, h, v)
#define	_ShallowWater1DSetFlux_(f, h, v, g)
#define	_ShallowWater1DRoeAverage_(uavg, uL, uR, p)
#define	_ShallowWater1DEigenvalues_(u, D, p, dir)
#define	_ShallowWater1DLeftEigenvectors_(u, L, p, dir)
#define	_ShallowWater1DRightEigenvectors_(u, R, p, dir)

Functions
int	ShallowWater1DInitialize (void *, void *)
int	ShallowWater1DCleanup (void *)

Detailed Description

1D Shallow Water Equations

Author

Debojyoti Ghosh

1D Shallow Water Equations

\begin{equation} \frac {\partial} {\partial t} \left[\begin{array}{c} h \\ hu \end{array} \right] + \frac {\partial} {\partial x} \left[\begin{array}{c} hu \\ hu^2 + \frac{1}{2}gh^2 \end{array} \right] = \left[\begin{array}{c} 0 \\ -ghb_x \end{array}\right] \end{equation}

where \(h\) is the height, \(u\) is the velocity, \(b(x)\) is the bottom topography, and \(g\) is the gravitational constant.

For the treatment of the source term (well-balanced formulation), refer to:

• Xing, Y., Shu, C.-W., "High order finite difference WENO schemes with the exact conservation property for the shallow water equations", Journal of Computational Physics, 208, 2005, pp. 206-227. http://dx.doi.org/10.1016/j.jcp.2005.02.006

Definition in file shallowwater1d.h.

Macro Definition Documentation

_SHALLOW_WATER_1D_

#define _SHALLOW_WATER_1D_   "shallow-water-1d"

1D Shallow Water equations

Definition at line 29 of file shallowwater1d.h.

_MODEL_NDIMS_

#define _MODEL_NDIMS_   1

Number of spatial dimensions

Definition at line 35 of file shallowwater1d.h.

_MODEL_NVARS_

#define _MODEL_NVARS_   2

Number of variables per grid point

Definition at line 37 of file shallowwater1d.h.

_ROE_

#define _ROE_   "roe"

Roe upwinding scheme

Definition at line 41 of file shallowwater1d.h.

_LLF_

#define _LLF_   "llf-char"

Local Lax-Friedrich upwinding scheme

Definition at line 43 of file shallowwater1d.h.

_XDIR_

#define _XDIR_   0

dimension corresponding to the x spatial dimension

Definition at line 48 of file shallowwater1d.h.

_ShallowWater1DGetFlowVar_

#define _ShallowWater1DGetFlowVar_	(		u,
			h,
			v
	)

Value:

{ \
    h = u[0]; \
    v = u[1] / h; \
  }

Compute the flow variables (height, velocity) from the conserved solution vector.

Definition at line 54 of file shallowwater1d.h.

_ShallowWater1DSetFlux_

#define _ShallowWater1DSetFlux_	(		f,
			h,
			v,
			g
	)

Value:

{ \
    f[0] = (h) * (v); \
    f[1] = (h) * (v) * (v) + 0.5 * (g) * (h) * (h); \
  }

Set the flux vector given the flow variables (height, velocity).

Definition at line 64 of file shallowwater1d.h.

_ShallowWater1DRoeAverage_

#define _ShallowWater1DRoeAverage_	(		uavg,
			uL,
			uR,
			p
	)

Value:

{ \
    double h ,v; \
    double hL,vL; \
    double hR,vR; \
    _ShallowWater1DGetFlowVar_(uL,hL,vL); \
    _ShallowWater1DGetFlowVar_(uR,hR,vR); \
    h  = 0.5 * (hL + hR); \
    v  = (sqrt(hL)*vL + sqrt(hR)*vR) / (sqrt(hL) + sqrt(hR)); \
    uavg[0] = h; \
    uavg[1] = h*v; \
  }

Compute the Roe average of two conserved solution vectors.

Definition at line 74 of file shallowwater1d.h.

_ShallowWater1DEigenvalues_

#define _ShallowWater1DEigenvalues_	(		u,
			D,
			p,
			dir
	)

Value:

{ \
    double h,v,c; \
    _ShallowWater1DGetFlowVar_(u,h,v); \
    c = sqrt(p->g*h); \
    D[0*_MODEL_NVARS_+0] = (v+c);  D[0*_MODEL_NVARS_+1] = 0;     \
    D[1*_MODEL_NVARS_+0] = 0;      D[1*_MODEL_NVARS_+1] = (v-c); \
  }

Compute the eigenvalues, given the conserved solution vector. The eigenvalues are returned as a 3x3 matrix stored in row-major format. It is a diagonal matrix with the eigenvalues as diagonal elements. Admittedly, it is a wasteful way of storing the eigenvalues.

Definition at line 93 of file shallowwater1d.h.

_ShallowWater1DLeftEigenvectors_

#define _ShallowWater1DLeftEigenvectors_	(		u,
			L,
			p,
			dir
	)

Value:

{ \
    double R[_MODEL_NVARS_*_MODEL_NVARS_]; \
    _ShallowWater1DRightEigenvectors_(u,R,p,dir); \
    _MatrixInvert_(R,L,_MODEL_NVARS_); \
  }

Compute the matrix that has the left-eigenvectors as its rows. Stored in row-major format.

Definition at line 106 of file shallowwater1d.h.

_ShallowWater1DRightEigenvectors_

#define _ShallowWater1DRightEigenvectors_	(		u,
			R,
			p,
			dir
	)

Value:

{ \
    double h,v,c; \
    _ShallowWater1DGetFlowVar_(u,h,v); \
    c    = sqrt(p->g*h); \
    R[0*_MODEL_NVARS_+0] = 1.0; \
    R[1*_MODEL_NVARS_+0] = v+c; \
    R[0*_MODEL_NVARS_+1] = 1.0; \
    R[1*_MODEL_NVARS_+1] = v-c; \
  }

Compute the matrix that has the right-eigenvectors as its columns. Stored in row-major format.

Definition at line 117 of file shallowwater1d.h.

Function Documentation

ShallowWater1DInitialize()

int ShallowWater1DInitialize	(	void *	s,
		void *	m
	)

Function to initialize the 1D ShallowWater module

Function to initialize the 1D shallow water equations (ShallowWater1D) module: Sets the default parameters, read in and set physics-related parameters, and set the physics-related function pointers in HyPar.

Parameters

s	Solver object of type HyPar
m	Object of type MPIVariables containing MPI-related info

Definition at line 37 of file ShallowWater1DInitialize.c.

{
  HyPar           *solver  = (HyPar*)         s;
  MPIVariables    *mpi     = (MPIVariables*)  m; 
  ShallowWater1D  *physics = (ShallowWater1D*)       solver->physics;
  int             ferr, d;

  static int count = 0;

  if (solver->nvars != _MODEL_NVARS_) {
    fprintf(stderr,"Error in ShallowWater1DInitialize(): nvars has to be %d.\n",_MODEL_NVARS_);
    return(1);
  }
  if (solver->ndims != _MODEL_NDIMS_) {
    fprintf(stderr,"Error in ShallowWater1DInitialize(): ndims has to be %d.\n",_MODEL_NDIMS_);
    return(1);
  }

  /* default values */
  physics->g       = 1.0; 
  physics->bt_type = 0;
  strcpy(physics->upw_choice,"roe");

  /* reading physical model specific inputs */
  if (!mpi->rank) {
    FILE *in;
    if (!count) printf("Reading physical model inputs from file \"physics.inp\".\n");
    in = fopen("physics.inp","r");
    if (!in) printf("Warning: File \"physics.inp\" not found. Using default values.\n");
    else {
      char word[_MAX_STRING_SIZE_];
      ferr = fscanf(in,"%s",word); if (ferr != 1) return(1);
      if (!strcmp(word, "begin")){
          while (strcmp(word, "end")){
              ferr = fscanf(in,"%s",word); if (ferr != 1) return(1);
          if (!strcmp(word, "gravity")) { 
            ferr = fscanf(in,"%lf",&physics->g); 
            if (ferr != 1) return(1);
          } else if (!strcmp(word, "topography_type")) { 
            ferr = fscanf(in,"%d",&physics->bt_type); 
            if (ferr != 1) return(1);
          } else if (!strcmp(word,"upwinding")) {
            ferr = fscanf(in,"%s",physics->upw_choice); 
            if (ferr != 1) return(1);
          } else if (strcmp(word,"end")) {
            char useless[_MAX_STRING_SIZE_];
            ferr = fscanf(in,"%s",useless); if (ferr != 1) return(ferr);
            printf("Warning: keyword %s in file \"physics.inp\" with value %s not ",word,useless);
            printf("recognized or extraneous. Ignoring.\n");
          }
        }
        } else {
          fprintf(stderr,"Error: Illegal format in file \"physics.inp\".\n");
        return(1);
        }
    }
    fclose(in);
  }

#ifndef serial
  IERR MPIBroadcast_double    (&physics->g        ,1,0,&mpi->world);                  CHECKERR(ierr);
  IERR MPIBroadcast_integer   (&physics->bt_type  ,1,0,&mpi->world);                  CHECKERR(ierr);
  IERR MPIBroadcast_character (physics->upw_choice,_MAX_STRING_SIZE_,0,&mpi->world);  CHECKERR(ierr);
#endif

  /* initializing physical model-specific functions */
  solver->ComputeCFL = ShallowWater1DComputeCFL;
  solver->FFunction  = ShallowWater1DFlux;
  solver->SFunction  = ShallowWater1DSource;
  solver->UFunction  = ShallowWater1DModifiedSolution;
  solver->JFunction  = ShallowWater1DJacobian;
  if      (!strcmp(physics->upw_choice,_ROE_ )) solver->Upwind = ShallowWater1DUpwindRoe;
  else if (!strcmp(physics->upw_choice,_LLF_ )) solver->Upwind = ShallowWater1DUpwindLLF;
  else {
    if (!mpi->rank) fprintf(stderr,"Error in ShallowWater1DInitialize(): %s is not a valid upwinding scheme.\n",
                            physics->upw_choice);
    return(1);
  }
  solver->AveragingFunction     = ShallowWater1DRoeAverage;
  solver->GetLeftEigenvectors   = ShallowWater1DLeftEigenvectors;
  solver->GetRightEigenvectors  = ShallowWater1DRightEigenvectors;
  solver->PhysicsOutput         = ShallowWater1DWriteTopography;
   
  if      (!strcmp(physics->upw_choice,_LLF_ )) physics->SourceUpwind = ShallowWater1DSourceUpwindLLF;
  else if (!strcmp(physics->upw_choice,_ROE_ )) physics->SourceUpwind = ShallowWater1DSourceUpwindRoe;

  /* allocate array to hold the bottom topography field */
  physics->b = (double*) calloc (solver->npoints_local_wghosts, sizeof(double));
  /* set function pointer to read this topography */
  solver->PhysicsInput = ShallowWater1DTopography;

  count++;
  return(0);
}

ShallowWater1DCleanup()

int ShallowWater1DCleanup

(

void *

s

)

Function to clean up the 1D ShallowWater module

Function to clean up all physics-related allocations for the 1D shallow water equations

Parameters

s	Solver object of type HyPar

Definition at line 10 of file ShallowWater1DCleanup.c.

{
  ShallowWater1D *param  = (ShallowWater1D*) s;
  free(param->b);
  return(0);
}