linearadr.h File Reference

Linear Advection-Diffusion-Reaction model. More...

#include <basic.h>

Go to the source code of this file.

Data Structures
struct	LinearADR
	Structure containing variables and parameters specific to the linear advection-diffusion-reaction model. More...

Macros
#define	_LINEAR_ADVECTION_DIFFUSION_REACTION_   "linear-advection-diffusion-reaction"

Functions
int	LinearADRInitialize (void *, void *)
int	LinearADRCleanup (void *)

Detailed Description

Linear Advection-Diffusion-Reaction model.

Author

Debojyoti Ghosh

Linear Advection-Diffusion-Reachtion

\begin{equation} \frac {\partial u} {\partial t} + \sum_d \frac {\partial} {\partial x_d} \left( a_d d \right) = \sum_d \nu_d \frac {\partial^2 u} {\partial x_d^2} + k u \end{equation}

where \(a_d\) are the advection speeds, \(\nu_d\) are the diffusion coefficients, and \(k\) is the reaction rate.

Definition in file linearadr.h.

---

Data Structure Documentation

struct LinearADR

Structure containing variables and parameters specific to the linear advection-diffusion-reaction model.

This structure contains the physical parameters, variables, and function pointers specific to the linear advection-diffusion-reaction equation.

Definition at line 37 of file linearadr.h.

Data Fields
int	constant_advection	Is the advection field constant (1) or spatially-varying (0)
char	adv_filename[_MAX_STRING_SIZE_]	Filename of file to read in spatially-varying advection field from
int	adv_arr_size	Size of the advection array: depends on whether advection coeff is constant or spatially-varying
double *	a	advection speed for each variable along each dimension
double *	d	diffusion coefficient for each variable along each dimension
char	centered_flux[_MAX_STRING_SIZE_]	turn off upwinding and just take arithmetic average of left and right biased fluxes?

Macro Definition Documentation

#define _LINEAR_ADVECTION_DIFFUSION_REACTION_   "linear-advection-diffusion-reaction"

Linear advection-diffusion-reaction model

Definition at line 21 of file linearadr.h.

Function Documentation

int LinearADRInitialize	(	void *	s,
		void *	m
	)

Initialize the linear advection-diffusion-reaction model

Initialize the linear advection-diffusion-reaction physics module - allocate and set physics-related parameters, read physics-related inputs from file, and set the physics-related function pointers in HyPar

This file reads the file "physics.inp" that must have the following format:

begin
    <keyword>   <value>
    <keyword>   <value>
    <keyword>   <value>
    ...
    <keyword>   <value>
end

where the list of keywords are:

Keyword name	Type	Variable	Default value
advection_filename	char[]	LinearADR::adv_filename	"none"
advection	double[]	LinearADR::a	0
diffusion	double[]	LinearADR::d	0
centered_flux	char[]	LinearADR::centered_flux	"no"

Note:

• "physics.inp" is optional; if absent, default values will be used.
• Please do not specify both "advection" and "advection_filename"!

Parameters

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

Definition at line 59 of file LinearADRInitialize.c.

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

  static int count = 0;

  /* default values */
  physics->constant_advection = -1;
  strcpy(physics->adv_filename,"none");
  physics->a = NULL;
  physics->adv_arr_size = -1;
  strcpy(physics->centered_flux,"no");

  physics->d = (double*) calloc (solver->ndims*solver->nvars,sizeof(double));
  _ArraySetValue_(physics->d,solver->ndims*solver->nvars,0.0);

  /* reading physical model specific inputs - all processes */
  if (!mpi->rank) {

    FILE *in;
    if (!count) printf("Reading physical model inputs from file \"physics.inp\".\n");
    in = fopen("physics.inp","r");

    if (!in) {

      fprintf(stderr,"Error: File \"physics.inp\" not found.\n");
      return(1);

    } 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, "advection_filename")) {
            if (physics->constant_advection != -1) {
              fprintf(stderr,"Error in LinearADRInitialize():\n");
              fprintf(stderr,"Maybe advection_filename and advection are both specified.\n");
              return 1;
            } else {
              /* read filename for spatially-varying advection field */
              physics->constant_advection = 0;
              physics->adv_arr_size = solver->npoints_local_wghosts*solver->ndims*solver->nvars;
              physics->a = (double*) calloc ( physics->adv_arr_size, sizeof(double) );
              _ArraySetValue_(physics->a, physics->adv_arr_size, 0.0);
              ferr = fscanf(in,"%s",physics->adv_filename); if (ferr != 1) return(ferr);
            }
          } else if (!strcmp(word, "advection")) {
            if (physics->constant_advection != -1) {
              fprintf(stderr,"Error in LinearADRInitialize():\n");
              fprintf(stderr,"Maybe advection_filename and advection are both specified.\n");
              return 1;
            } else {
              /* read advection coefficients */
              physics->constant_advection = 1;
              physics->adv_arr_size = solver->ndims*solver->nvars;
              physics->a = (double*) calloc ( physics->adv_arr_size, sizeof(double) );
              for (i=0; i<solver->ndims*solver->nvars; i++) ferr = fscanf(in,"%lf",&physics->a[i]);
              if (ferr != 1) return(1);
            }
          } else if (!strcmp(word, "diffusion")) {
            /* read diffusion coefficients */
            for (i=0; i<solver->ndims*solver->nvars; i++) ferr = fscanf(in,"%lf",&physics->d[i]);
            if (ferr != 1) return(1);
          } else if (!strcmp(word, "centered_flux")) {
            ferr = fscanf(in, "%s", physics->centered_flux); 
            if (ferr != 1) return(ferr);
          } 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
  MPIBroadcast_integer(&physics->constant_advection,1,0,&mpi->world);
  MPIBroadcast_integer(&physics->adv_arr_size,1,0,&mpi->world);
#endif

  if (mpi->rank) {
    physics->a = (double*) calloc (physics->adv_arr_size,sizeof(double));
    _ArraySetValue_(physics->a, physics->adv_arr_size, 0.0);
  }

  if (physics->constant_advection == 1) {
#ifndef serial
    MPIBroadcast_double(physics->a,physics->adv_arr_size,0,&mpi->world);
#endif
  } else if (physics->constant_advection == 0) {
#ifndef serial
    MPIBroadcast_character(physics->adv_filename, _MAX_STRING_SIZE_,0,&mpi->world);
#endif
  }

#ifndef serial
  MPIBroadcast_double(physics->d,solver->ndims*solver->nvars,0,&mpi->world);
  MPIBroadcast_character(physics->centered_flux, _MAX_STRING_SIZE_,0,&mpi->world);
#endif

  if (!strcmp(solver->SplitHyperbolicFlux,"yes")) {
    if (!mpi->rank) {
      fprintf(stderr,"Error in LinearADRInitialize: This physical model does not have a splitting ");
      fprintf(stderr,"of the hyperbolic term defined.\n");
    }
    return(1);
  }

  /* initializing physical model-specific functions */
  solver->ComputeCFL         = LinearADRComputeCFL;
  solver->ComputeDiffNumber  = LinearADRComputeDiffNumber;
  solver->FFunction          = LinearADRAdvection;
  solver->GFunction          = LinearADRDiffusionG;
  solver->HFunction          = LinearADRDiffusionH;
  solver->SFunction          = LinearADRReaction;
  solver->JFunction          = LinearADRAdvectionJacobian;
  solver->KFunction          = LinearADRDiffusionJacobian;

  if (!strcmp(physics->centered_flux,"no")) {
    solver->Upwind = LinearADRUpwind;
  } else {
    solver->Upwind = LinearADRCenteredFlux;
  }

  if (physics->constant_advection == 0) {
    solver->PhysicsInput = LinearADRAdvectionField;
    solver->PhysicsOutput = LinearADRWriteAdvField;
  } else {
    solver->PhysicsInput = NULL;
    solver->PhysicsOutput = NULL;
  }

  count++;
  return(0);
}

int LinearADRCleanup

(

void *

s

)

Clean up the linear advection-diffusion-reaction model

Parameters

s	Solver object of type HyPar

Definition at line 10 of file LinearADRCleanup.c.

{
  LinearADR *physics = (LinearADR*) s;
  if (physics->a) free(physics->a);
  if (physics->d) free(physics->d);

  return(0);
}