HyPar  1.0
Finite-Difference Hyperbolic-Parabolic PDE Solver on Cartesian Grids
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
Functions
WENOFifthOrderInitializeWeights.c File Reference

Initialize the arrays for nonlinear weights of WENO-type schemes. More...

#include <stdlib.h>
#include <string.h>
#include <basic.h>
#include <arrayfunctions.h>
#include <mathfunctions.h>
#include <interpolation.h>
#include <mpivars.h>
#include <hypar.h>

Go to the source code of this file.

Functions

int WENOFifthOrderInitializeWeights (double *const a_w1, double *const a_w2, double *const a_w3, const int *const a_offset, int dir, void *s, void *m)
 

Detailed Description

Initialize the arrays for nonlinear weights of WENO-type schemes.

Author
Debojyoti Ghosh

Definition in file WENOFifthOrderInitializeWeights.c.

Function Documentation

int WENOFifthOrderInitializeWeights ( double *const  a_w1,
double *const  a_w2,
double *const  a_w3,
const int *const  a_offset,
int  dir,
void *  s,
void *  m 
)

This function initializes the arrays to store the nonlinear weights for fifth order WENO-type schemes to their optimal values (i.e. values of the weights for a perfectly smooth solution). 5th order methods need three weights at each grid interface.

Notes:

  • The three weights at all the grid interfaces along all the dimensions are stored in three big arrays (WENOParameters::w1, WENOParameters::w2, WENOParameters::w3), one for each weight.
  • This function initializes the values for the spatial dimension given by the input dir.
  • offset indicates the location in WENOParameters::w1,WENOParameters::w2, and WENOParameters::w3 from where the chunk of memory with the weights for the spatial dimension dir starts.
  • This chunk of memory (1D array) represents a multidimensional array of the following size: 4 X (number of interfaces) X (number of solution components HyPar::nvars). The factor 4 comes from the fact that the array stores weights for the interpolation of left-biased flux function, left-biased solution, right-biased flux function, and right-biased solution, one after the other, in this order.
  • The weights are initialized to their optimal values so that, if no limiting is specified (WENOParameters::no_limiting = 1), then no further computation of weights are required.
Parameters
a_w1Weight array
a_w2Weight array
a_w3Weight array
a_offsetOffset array
dirSpatial dimension
sSolver object of type HyPar
mMPI object of type MPIVariables

Definition at line 33 of file WENOFifthOrderInitializeWeights.c.

41 {
42  HyPar *solver = (HyPar*) s;
43  WENOParameters *weno = (WENOParameters*) solver->interp;
44  MPIVariables *mpi = (MPIVariables*) m;
45  int done;
46  double *ww1, *ww2, *ww3;
47 
48 
49  int ndims = solver->ndims;
50  int nvars = solver->nvars;
51  int *dim = solver->dim_local;
52 
53  /* calculate dimension offset */
54  int offset = a_offset[dir];
55 
56  /* create index and bounds for the outer loop, i.e., to loop over all 1D lines along
57  dimension "dir" */
58  int indexI[ndims], index_outer[ndims], bounds_outer[ndims], bounds_inter[ndims];
59  _ArrayCopy1D_(dim,bounds_outer,ndims); bounds_outer[dir] = 1;
60  _ArrayCopy1D_(dim,bounds_inter,ndims); bounds_inter[dir] += 1;
61 
62  /* calculate weights for a left-biased interpolation */
63  ww1 = a_w1 + offset;
64  ww2 = a_w2 + offset;
65  ww3 = a_w3 + offset;
66  done = 0; _ArraySetValue_(index_outer,ndims,0);
67  while (!done) {
68  _ArrayCopy1D_(index_outer,indexI,ndims);
69  for (indexI[dir] = 0; indexI[dir] < dim[dir]+1; indexI[dir]++) {
70  int p, v;
71  _ArrayIndex1D_(ndims,bounds_inter,indexI,0,p);
72  for (v=0; v<nvars; v++) {
73  /* optimal weights*/
74  double c1, c2, c3;
75  if (!strcmp(solver->spatial_scheme_hyp,_FIFTH_ORDER_CRWENO_)) {
76  if ( ((mpi->ip[dir] == 0 ) && (indexI[dir] == 0 ))
77  || ((mpi->ip[dir] == mpi->iproc[dir]-1) && (indexI[dir] == dim[dir])) ) {
78  /* Use WENO5 at the physical boundaries */
79  c1 = _WENO_OPTIMAL_WEIGHT_1_;
80  c2 = _WENO_OPTIMAL_WEIGHT_2_;
81  c3 = _WENO_OPTIMAL_WEIGHT_3_;
82  } else {
83  /* CRWENO5 at the interior points */
84  c1 = _CRWENO_OPTIMAL_WEIGHT_1_;
85  c2 = _CRWENO_OPTIMAL_WEIGHT_2_;
86  c3 = _CRWENO_OPTIMAL_WEIGHT_3_;
87  }
88  } else {
89  /* WENO5 and HCWENO5 */
90  c1 = _WENO_OPTIMAL_WEIGHT_1_;
91  c2 = _WENO_OPTIMAL_WEIGHT_2_;
92  c3 = _WENO_OPTIMAL_WEIGHT_3_;
93  }
94 
95  /* save the weights */
96  *(ww1+p*nvars+v) = c1;
97  *(ww2+p*nvars+v) = c2;
98  *(ww3+p*nvars+v) = c3;
99  }
100  }
101  _ArrayIncrementIndex_(ndims,bounds_outer,index_outer,done);
102  }
103 
104  ww1 = a_w1 + weno->size + offset;
105  ww2 = a_w2 + weno->size + offset;
106  ww3 = a_w3 + weno->size + offset;
107  done = 0; _ArraySetValue_(index_outer,ndims,0);
108  while (!done) {
109  _ArrayCopy1D_(index_outer,indexI,ndims);
110  for (indexI[dir] = 0; indexI[dir] < dim[dir]+1; indexI[dir]++) {
111  int p, v;
112  _ArrayIndex1D_(ndims,bounds_inter,indexI,0,p);
113  for (v=0; v<nvars; v++) {
114 
115  /* optimal weights*/
116  double c1, c2, c3;
117  if (!strcmp(solver->spatial_scheme_hyp,_FIFTH_ORDER_CRWENO_)) {
118  if ( ((mpi->ip[dir] == 0 ) && (indexI[dir] == 0 ))
119  || ((mpi->ip[dir] == mpi->iproc[dir]-1) && (indexI[dir] == dim[dir])) ) {
120  /* Use WENO5 at the physical boundaries */
121  c1 = _WENO_OPTIMAL_WEIGHT_1_;
122  c2 = _WENO_OPTIMAL_WEIGHT_2_;
123  c3 = _WENO_OPTIMAL_WEIGHT_3_;
124  } else {
125  /* CRWENO5 at the interior points */
126  c1 = _CRWENO_OPTIMAL_WEIGHT_1_;
127  c2 = _CRWENO_OPTIMAL_WEIGHT_2_;
128  c3 = _CRWENO_OPTIMAL_WEIGHT_3_;
129  }
130  } else {
131  /* WENO5 and HCWENO5 */
132  c1 = _WENO_OPTIMAL_WEIGHT_1_;
133  c2 = _WENO_OPTIMAL_WEIGHT_2_;
134  c3 = _WENO_OPTIMAL_WEIGHT_3_;
135  }
136 
137  /* save the weights */
138  *(ww1+p*nvars+v) = c1;
139  *(ww2+p*nvars+v) = c2;
140  *(ww3+p*nvars+v) = c3;
141  }
142  }
143  _ArrayIncrementIndex_(ndims,bounds_outer,index_outer,done);
144  }
145 
146  /* calculate weights for a right-biased interpolation */
147  ww1 = a_w1 + 2*weno->size + offset;
148  ww2 = a_w2 + 2*weno->size + offset;
149  ww3 = a_w3 + 2*weno->size + offset;
150  done = 0; _ArraySetValue_(index_outer,ndims,0);
151  while (!done) {
152  _ArrayCopy1D_(index_outer,indexI,ndims);
153  for (indexI[dir] = 0; indexI[dir] < dim[dir]+1; indexI[dir]++) {
154  int p, v;
155  _ArrayIndex1D_(ndims,bounds_inter,indexI,0,p);
156  for (v=0; v<nvars; v++) {
157 
158  /* optimal weights*/
159  double c1, c2, c3;
160  if (!strcmp(solver->spatial_scheme_hyp,_FIFTH_ORDER_CRWENO_)) {
161  if ( ((mpi->ip[dir] == 0 ) && (indexI[dir] == 0 ))
162  || ((mpi->ip[dir] == mpi->iproc[dir]-1) && (indexI[dir] == dim[dir])) ) {
163  /* Use WENO5 at the physical boundaries */
164  c1 = _WENO_OPTIMAL_WEIGHT_1_;
165  c2 = _WENO_OPTIMAL_WEIGHT_2_;
166  c3 = _WENO_OPTIMAL_WEIGHT_3_;
167  } else {
168  /* CRWENO5 at the interior points */
169  c1 = _CRWENO_OPTIMAL_WEIGHT_1_;
170  c2 = _CRWENO_OPTIMAL_WEIGHT_2_;
171  c3 = _CRWENO_OPTIMAL_WEIGHT_3_;
172  }
173  } else {
174  /* WENO5 and HCWENO5 */
175  c1 = _WENO_OPTIMAL_WEIGHT_1_;
176  c2 = _WENO_OPTIMAL_WEIGHT_2_;
177  c3 = _WENO_OPTIMAL_WEIGHT_3_;
178  }
179 
180  /* save the weights */
181  *(ww1+p*nvars+v) = c1;
182  *(ww2+p*nvars+v) = c2;
183  *(ww3+p*nvars+v) = c3;
184  }
185  }
186  _ArrayIncrementIndex_(ndims,bounds_outer,index_outer,done);
187  }
188 
189  ww1 = a_w1 + 2*weno->size + weno->size + offset;
190  ww2 = a_w2 + 2*weno->size + weno->size + offset;
191  ww3 = a_w3 + 2*weno->size + weno->size + offset;
192  done = 0; _ArraySetValue_(index_outer,ndims,0);
193  while (!done) {
194  _ArrayCopy1D_(index_outer,indexI,ndims);
195  for (indexI[dir] = 0; indexI[dir] < dim[dir]+1; indexI[dir]++) {
196  int p, v;
197  _ArrayIndex1D_(ndims,bounds_inter,indexI,0,p);
198  for (v=0; v<nvars; v++) {
199 
200  /* optimal weights*/
201  double c1, c2, c3;
202  if (!strcmp(solver->spatial_scheme_hyp,_FIFTH_ORDER_CRWENO_)) {
203  if ( ((mpi->ip[dir] == 0 ) && (indexI[dir] == 0 ))
204  || ((mpi->ip[dir] == mpi->iproc[dir]-1) && (indexI[dir] == dim[dir])) ) {
205  /* Use WENO5 at the physical boundaries */
206  c1 = _WENO_OPTIMAL_WEIGHT_1_;
207  c2 = _WENO_OPTIMAL_WEIGHT_2_;
208  c3 = _WENO_OPTIMAL_WEIGHT_3_;
209  } else {
210  /* CRWENO5 at the interior points */
211  c1 = _CRWENO_OPTIMAL_WEIGHT_1_;
212  c2 = _CRWENO_OPTIMAL_WEIGHT_2_;
213  c3 = _CRWENO_OPTIMAL_WEIGHT_3_;
214  }
215  } else {
216  /* WENO5 and HCWENO5 */
217  c1 = _WENO_OPTIMAL_WEIGHT_1_;
218  c2 = _WENO_OPTIMAL_WEIGHT_2_;
219  c3 = _WENO_OPTIMAL_WEIGHT_3_;
220  }
221 
222  /* save the weights */
223  *(ww1+p*nvars+v) = c1;
224  *(ww2+p*nvars+v) = c2;
225  *(ww3+p*nvars+v) = c3;
226  }
227  }
228  _ArrayIncrementIndex_(ndims,bounds_outer,index_outer,done);
229  }
230 
231  return(0);
232 }
HyPar::spatial_scheme_hyp
char spatial_scheme_hyp[_MAX_STRING_SIZE_]
Definition: hypar.h:84
HyPar::interp
void * interp
Definition: hypar.h:362
_ArraySetValue_
#define _ArraySetValue_(x, size, value)
Definition: arrayfunctions.h:169
_ArrayIncrementIndex_
#define _ArrayIncrementIndex_(N, imax, i, done)
Definition: arrayfunctions.h:126
HyPar::dim_local
int * dim_local
Definition: hypar.h:37
_WENO_OPTIMAL_WEIGHT_2_
#define _WENO_OPTIMAL_WEIGHT_2_
Definition: interpolation.h:230
WENOParameters
Structure of variables/parameters needed by the WENO-type scheme.
Definition: interpolation.h:194
_ArrayIndex1D_
#define _ArrayIndex1D_(N, imax, i, ghost, index)
Definition: arrayfunctions.h:40
_CRWENO_OPTIMAL_WEIGHT_1_
#define _CRWENO_OPTIMAL_WEIGHT_1_
Definition: interpolation.h:234
_WENO_OPTIMAL_WEIGHT_3_
#define _WENO_OPTIMAL_WEIGHT_3_
Definition: interpolation.h:232
_WENO_OPTIMAL_WEIGHT_1_
#define _WENO_OPTIMAL_WEIGHT_1_
Definition: interpolation.h:228
_ArrayCopy1D_
#define _ArrayCopy1D_(x, y, size)
Definition: arrayfunctions.h:319
HyPar::nvars
int nvars
Definition: hypar.h:29
_CRWENO_OPTIMAL_WEIGHT_2_
#define _CRWENO_OPTIMAL_WEIGHT_2_
Definition: interpolation.h:236
_CRWENO_OPTIMAL_WEIGHT_3_
#define _CRWENO_OPTIMAL_WEIGHT_3_
Definition: interpolation.h:238
HyPar::ndims
int ndims
Definition: hypar.h:26
_FIFTH_ORDER_CRWENO_
#define _FIFTH_ORDER_CRWENO_
Definition: interpolation.h:28
MPIVariables
Structure of MPI-related variables.
Definition: mpivars_struct.h:24
HyPar
Structure containing all solver-specific variables and functions.
Definition: hypar.h:23