numa2d.h File Reference

#include <basic.h>
#include <mathfunctions.h>

Go to the source code of this file.

Data Structures
struct	Numa2D

Macros
#define	_NUMA2D_   "numa2d"
#define	_MODEL_NDIMS_   2
#define	_MODEL_NVARS_   4
#define	_XDIR_   0
#define	_YDIR_   1
#define	_Numa2DGetFlowVars_(u, drho, uvel, vvel, dT, rho0)
#define	_Numa2DSetFlux_(f, dir, drho, uvel, vvel, dT, dP, rho0, T0)
#define	_Numa2DSetLinearFlux_(f, dir, drho, uvel, vvel, dT, dP, rho0, T0)
#define	_Numa2DSetSource_(s, param, drho)
#define	_Numa2DComputePressure_(params, T0, dT, P0, dP)
#define	_Numa2DComputeLinearizedPressure_(params, T0, dT, P0, dP)
#define	_Numa2DComputeTemperature_(rho0, drho, T0, dT, temperature)
#define	_Numa2DComputeSpeedofSound_(gamma, R, T0, dT, rho0, drho, EP, c)
#define	_Numa2DComputeLinearizedSpeedofSound_(gamma, R, T0, rho0, EP, c)
#define	_RUSANOV_UPWINDING_   "rusanov"

Functions
int	Numa2DInitialize (void *, void *)
int	Numa2DCleanup (void *)

Macro Definition Documentation

_NUMA2D_

#define _NUMA2D_   "numa2d"

Definition at line 21 of file numa2d.h.

_MODEL_NDIMS_

#define _MODEL_NDIMS_   2

Definition at line 26 of file numa2d.h.

_MODEL_NVARS_

#define _MODEL_NVARS_   4

Definition at line 27 of file numa2d.h.

_XDIR_

#define _XDIR_   0

Definition at line 30 of file numa2d.h.

_YDIR_

#define _YDIR_   1

Definition at line 31 of file numa2d.h.

_Numa2DGetFlowVars_

#define _Numa2DGetFlowVars_	(		u,
			drho,
			uvel,
			vvel,
			dT,
			rho0
	)

Value:

{ \
    drho = u[0]; \
    uvel = u[1]/(rho0+drho); \
    vvel = u[2]/(rho0+drho); \
    dT   = u[3]; \
  }

Definition at line 33 of file numa2d.h.

_Numa2DSetFlux_

#define _Numa2DSetFlux_	(		f,
			dir,
			drho,
			uvel,
			vvel,
			dT,
			dP,
			rho0,
			T0
	)

Value:

{ \
    if (dir == _XDIR_) { \
      f[0] = (rho0+drho) * uvel; \
      f[1] = (rho0+drho)*uvel*uvel + dP; \
      f[2] = (rho0+drho)*uvel*vvel; \
      f[3] = uvel*(dT+T0); \
    } else if (dir == _YDIR_) { \
      f[0] = (rho0+drho) * vvel; \
      f[1] = (rho0+drho)*uvel*vvel; \
      f[2] = (rho0+drho)*vvel*vvel + dP; \
      f[3] = vvel*(dT+T0); \
    } \
  }

Definition at line 41 of file numa2d.h.

_Numa2DSetLinearFlux_

#define _Numa2DSetLinearFlux_	(		f,
			dir,
			drho,
			uvel,
			vvel,
			dT,
			dP,
			rho0,
			T0
	)

Value:

{ \
    if (dir == _XDIR_) { \
      f[0] = (rho0+drho) * uvel; \
      f[1] = dP; \
      f[2] = 0.0; \
      f[3] = (rho0+drho)*uvel*T0/rho0; \
    } else if (dir == _YDIR_) { \
      f[0] = (rho0+drho) * vvel; \
      f[1] = 0.0; \
      f[2] = dP; \
      f[3] = (rho0+drho)*vvel*T0/rho0; \
    } \
  }

Definition at line 56 of file numa2d.h.

_Numa2DSetSource_

#define _Numa2DSetSource_	(		s,
			param,
			drho
	)

Value:

{ \
    s[0] =  0.0; \
    s[1] =  0.0; \
    s[2] = -param->g*drho; \
    s[3] =  0.0; \
  }

Definition at line 71 of file numa2d.h.

_Numa2DComputePressure_

#define _Numa2DComputePressure_	(		params,
			T0,
			dT,
			P0,
			dP
	)

Value:

{ \
    double gamma    = params->gamma; \
    double Pref     = params->Pref; \
    double R        = params->R; \
    double P_total  = Pref * raiseto((R*(T0+dT)/Pref),gamma); \
    dP  = P_total - P0; \
  }

Definition at line 79 of file numa2d.h.

_Numa2DComputeLinearizedPressure_

#define _Numa2DComputeLinearizedPressure_	(		params,
			T0,
			dT,
			P0,
			dP
	)

Value:

{ \
    double gamma    = params->gamma; \
    dP  = (gamma*P0/T0) * dT; \
  }

Definition at line 88 of file numa2d.h.

_Numa2DComputeTemperature_

#define _Numa2DComputeTemperature_	(		rho0,
			drho,
			T0,
			dT,
			temperature
	)

Value:

{ \
    temperature = (T0+dT)*EP/(rho0+drho); \
  }

Definition at line 94 of file numa2d.h.

_Numa2DComputeSpeedofSound_

#define _Numa2DComputeSpeedofSound_	(		gamma,
			R,
			T0,
			dT,
			rho0,
			drho,
			EP,
			c
	)

Value:

{ \
    c = sqrt(gamma*R*(T0+dT)*EP/(rho0+drho)); \
  }

Definition at line 99 of file numa2d.h.

_Numa2DComputeLinearizedSpeedofSound_

#define _Numa2DComputeLinearizedSpeedofSound_	(		gamma,
			R,
			T0,
			rho0,
			EP,
			c
	)

Value:

{ \
    c = sqrt(gamma*R*T0*EP/rho0); \
  }

Definition at line 104 of file numa2d.h.

_RUSANOV_UPWINDING_

#define _RUSANOV_UPWINDING_   "rusanov"

Definition at line 130 of file numa2d.h.

Function Documentation

Numa2DInitialize()

int Numa2DInitialize	(	void *	,
		void *
	)

Definition at line 25 of file Numa2DInitialize.c.

{
  HyPar           *solver  = (HyPar*)         s;
  MPIVariables    *mpi     = (MPIVariables*)  m; 
  Numa2D          *physics = (Numa2D*)        solver->physics;
  int             ferr     = 0;

  static int count = 0;

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

  /* default values */
  physics->gamma  = 1.4; 
  physics->R      = 287.058;        /* J kg^{-1} K^{-1} */
  physics->g      = 9.8;            /* m s^{-2}         */
  physics->mu     = 0.0;            /* m^2 s^{-1}       */

  physics->Pref   = 101327.0;       /* N m^{-2}         */
  physics->Tref   = 288.15;         /* Kelvin           */

  strcpy(physics->upwind,_RUSANOV_UPWINDING_);

  /* default choice of initial atmosphere */
  physics->init_atmos = 1;

  /* reading physical model specific inputs - rank 0 */
  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, "gamma")) { 
            ferr = fscanf(in,"%lf",&physics->gamma); if (ferr != 1) return(1);
          } else if (!strcmp(word,"R")) {
            ferr = fscanf(in,"%lf",&physics->R); if (ferr != 1) return(1);
          } else if (!strcmp(word,"g")) {
            ferr = fscanf(in,"%lf",&physics->g); if (ferr != 1) return(1);
          } else if (!strcmp(word,"mu")) {
            ferr = fscanf(in,"%lf",&physics->mu); if (ferr != 1) return(1);
          } else if (!strcmp(word,"Pref")) {
            ferr = fscanf(in,"%lf",&physics->Pref); if (ferr != 1) return(1);
          } else if (!strcmp(word,"Tref")) {
            ferr = fscanf(in,"%lf",&physics->Tref); if (ferr != 1) return(1);
          } else if (!strcmp(word,"init_atmos")) {
            ferr = fscanf(in,"%d",&physics->init_atmos); if (ferr != 1) return(1);
          } else if (!strcmp(word,"upwinding")) {
            ferr = fscanf(in,"%s",physics->upwind); 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->gamma     ,1                ,0,&mpi->world);CHECKERR(ierr);
  IERR MPIBroadcast_double   (&physics->R         ,1                ,0,&mpi->world);CHECKERR(ierr);
  IERR MPIBroadcast_double   (&physics->g         ,1                ,0,&mpi->world);CHECKERR(ierr);
  IERR MPIBroadcast_double   (&physics->mu        ,1                ,0,&mpi->world);CHECKERR(ierr);
  IERR MPIBroadcast_double   (&physics->Pref      ,1                ,0,&mpi->world);CHECKERR(ierr);
  IERR MPIBroadcast_double   (&physics->Tref      ,1                ,0,&mpi->world);CHECKERR(ierr);
  IERR MPIBroadcast_integer  (&physics->init_atmos,1                ,0,&mpi->world);CHECKERR(ierr);
  IERR MPIBroadcast_character( physics->upwind    ,_MAX_STRING_SIZE_,0,&mpi->world);CHECKERR(ierr);
#endif

  /* calculate the mean hydrostatic atmosphere as a function of altitude */
  if (physics->init_atmos == 1) {
    physics->StandardAtmosphere = Numa2DCalculateStandardAtmosphere_1;
  } else if (physics->init_atmos == 2) {
    physics->StandardAtmosphere = Numa2DCalculateStandardAtmosphere_2;
  } else {
    if (!mpi->rank) {
      fprintf(stderr,"Error in Numa2DInitialize(): invalid choice of initial atmosphere (init_atmos).\n");
      return(1);
    }
  }
  CHECKERR(ierr);

  /* initializing physical model-specific functions */
  if (!strcmp(solver->SplitHyperbolicFlux,"yes")) 
    solver->dFFunction    = Numa2DStiffFlux;
  else solver->dFFunction = NULL;
  solver->FFunction       = Numa2DFlux;
  solver->ComputeCFL      = Numa2DComputeCFL;
  solver->SFunction       = Numa2DSource;
  if (!strcmp(physics->upwind,_RUSANOV_UPWINDING_)) {
    solver->Upwind        = Numa2DRusanovFlux;
    if (!strcmp(solver->SplitHyperbolicFlux,"yes")) 
      solver->UpwinddF    = Numa2DRusanovLinearFlux;
    else solver->UpwinddF = NULL;
  } else {
    if (!mpi->rank) fprintf(stderr,"Error in Numa2DInitialize(): Invalid choice of upwinding scheme.\n");
    return(1);
  }

  /* set the value of gamma in all the boundary objects */
  int n;
  DomainBoundary  *boundary = (DomainBoundary*) solver->boundary;
  for (n = 0; n < solver->nBoundaryZones; n++)  boundary[n].gamma = physics->gamma;

  /* finally, hijack the main solver's dissipation function pointer
   * to this model's own function, since it's difficult to express 
   * the dissipation terms in the general form                      */
  solver->ParabolicFunction = Numa2DParabolicFunction;

  /* check that solver has the correct choice of diffusion formulation */
  if (strcmp(solver->spatial_type_par,_NC_2STAGE_)) {
    if (!mpi->rank) {
      fprintf(stderr,"Error in Numa2DInitialize(): Parabolic term spatial discretization must be \"%s\"\n",_NC_2STAGE_);
    }
    return(1);
  }

  count++;
  return(0);
}

Numa2DCleanup()

int Numa2DCleanup

(

void *

)

Definition at line 5 of file Numa2DCleanup.c.

{
  return(0);
}