proteus  1.8.1
C/C++/Fortran libraries
numericalFlux.c
Go to the documentation of this file.
1 #include "numericalFlux.h"
2 
3 #define TR_ALPHA 0.5
4 #define TR_ALPHA_EXT 1.0
5 
6 
7 /***********************************************************************
8  try some different numerical fluxes
9  ***********************************************************************/
10 
14 void calculateInteriorNumericalAdvectiveFluxConvexOneSonicPoint(double sonicPoint,
15  double sonicFlux,
16  int nInteriorElementBoundaries_global,
17  int nElementBoundaries_element,
18  int nQuadraturePoints_elementBoundary,
19  int nSpace,
20  int* interiorElementBoundaries,
21  int* elementBoundaryElements,
22  int* elementBoundaryLocalElementBoundaries,
23  double* n,
24  double* u,
25  double* f,
26  double* df,
27  double* flux,
28  double* dflux_left,
29  double* dflux_right)
30 {
31  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,J;
32  double left_flux,right_flux,u_left,u_right,left_speed,right_speed,sonicSpeed;
33  sonicSpeed = 0.0;
34  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
35  {
36  ebN = interiorElementBoundaries[ebNI];
37  left_eN_global = elementBoundaryElements[ebN*2+0];
38  right_eN_global = elementBoundaryElements[ebN*2+1];
39  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
40  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
41  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
42  {
43  left_speed =0.0;
44  right_speed=0.0;
45  left_flux=0.0;
46  right_flux=0.0;
47  for(J=0;J<nSpace;J++)
48  {
49  left_speed
50  +=
51  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
52  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
53  k*nSpace+
54  J]
55  *
56  df[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
57  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
58  k*nSpace+
59  J];
60  right_speed
61  +=
62  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
63  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
64  k*nSpace+
65  J]
66  *
67  df[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
68  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
69  k*nSpace+
70  J];
71  left_flux
72  +=
73  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
74  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
75  k*nSpace+
76  J]
77  *
78  f[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
79  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
80  k*nSpace+
81  J];
82  right_flux
83  +=
84  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
85  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
86  k*nSpace+
87  J]
88  *
89  f[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
90  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
91  k*nSpace+
92  J];
93  }
94 
95  u_left = u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
96  left_ebN_element*nQuadraturePoints_elementBoundary+
97  k];
98  u_right= u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
99  right_ebN_element*nQuadraturePoints_elementBoundary+
100  k];
101  /***************************************************
102  Simple convex flux with one sonic point potentially
103  Generic scalar riemann solution (1d too)
104  f(u_riem) = max_{u_R <= u <= u_L} if u_L >= u_R
105  = min_{u_L <= u <= u_R} if u_L < u_R
106  **************************************************/
107  /*cases*/
108  if (u_left >= u_right)
109  {
110  if (left_flux >= right_flux)
111  {
112  flux[ebN*nQuadraturePoints_elementBoundary+
113  k] = left_flux;
114  dflux_left[ebN*nQuadraturePoints_elementBoundary+
115  k] = left_speed;
116  dflux_right[ebN*nQuadraturePoints_elementBoundary+
117  k] = 0.0;
118  }
119  else
120  {
121  flux[ebN*nQuadraturePoints_elementBoundary+
122  k] = right_flux;
123  dflux_left[ebN*nQuadraturePoints_elementBoundary+
124  k] = 0.0;
125  dflux_right[ebN*nQuadraturePoints_elementBoundary+
126  k] = right_speed;
127  }
128  }/*max*/
129  else
130  {
131  /*min*/
132  flux[ebN*nQuadraturePoints_elementBoundary+
133  k] = left_flux;
134  dflux_left[ebN*nQuadraturePoints_elementBoundary+
135  k] = left_speed;
136  dflux_right[ebN*nQuadraturePoints_elementBoundary+
137  k] = 0.0;
138 
139  if (right_flux <= flux[ebN*nQuadraturePoints_elementBoundary+k])
140  {
141  flux[ebN*nQuadraturePoints_elementBoundary+
142  k] = right_flux;
143  dflux_left[ebN*nQuadraturePoints_elementBoundary+
144  k] = 0.0;
145  dflux_right[ebN*nQuadraturePoints_elementBoundary+
146  k] = right_speed;
147  }
148  if (u_left <= sonicPoint && sonicPoint <= u_right &&
149  sonicFlux < flux[ebN*nQuadraturePoints_elementBoundary+k])/*only consider if sonicPoint in interval*/
150  {
151  flux[ebN*nQuadraturePoints_elementBoundary+
152  k] = sonicFlux;
153 
154  dflux_left[ebN*nQuadraturePoints_elementBoundary+
155  k] = sonicSpeed;
156  dflux_right[ebN*nQuadraturePoints_elementBoundary+
157  k]= sonicSpeed;
158  }
159 
160  }/*min not containing sonic point*/
161  /*mwf debug
162  if (fabs(u_left-u_right) > 1.0e-2)
163  {
164  printf("conv flux ebN=%d eN_left=%d eN_right=%d u_left=%g u_right=%g left_flux=%g right_flux=%g flux=%g\n\t",
165  ebN,left_eN_global,right_eN_global,u_left,u_right,left_flux,right_flux,flux[ebN*nQuadraturePoints_elementBoundary+k]);
166  for (J=0; J < nSpace; J++)
167  {
168  printf("n[%d] = %g ",J,n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
169  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
170  k*nSpace+J]);
171  }
172  printf("\n");
173 
174  }
175  */
176  }/*k*/
177  }/*ebnI*/
178 }
179 void calculateInteriorNumericalAdvectiveFluxRusanov(double safetyFactor,
180  int nInteriorElementBoundaries_global,
181  int nElementBoundaries_element,
182  int nQuadraturePoints_elementBoundary,
183  int nQuadraturePoints_element,
184  int nSpace,
185  int* interiorElementBoundaries,
186  int* elementBoundaryElements,
187  int* elementBoundaryLocalElementBoundaries,
188  double* n,
189  double* u,
190  double* f,
191  double* df,
192  double* df_element,
193  double* flux,
194  double* dflux_left,
195  double* dflux_right)
196 {
197  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,J;
198  double left_flux,right_flux,u_left,u_right,left_speed,right_speed,
199  maxSpeed_left,maxSpeed_right,maxSpeed_element,maxSpeed,tmp_left,tmp_right;
200  /*for now use outer normal at first quadrature point for element speed calculations*/
201 
202  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
203  {
204  ebN = interiorElementBoundaries[ebNI];
205  left_eN_global = elementBoundaryElements[ebN*2+0];
206  right_eN_global = elementBoundaryElements[ebN*2+1];
207  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
208  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
209  /*first calculate maximum value for df/du on neighboring elements and use this
210  in Rusanov (local lax-friedrichs) flux
211  h(a,b) = 0.5*(f(a)+f(b)) - 0.5*alpha*(b-a)
212  */
213  maxSpeed_left =0.0; maxSpeed_right=0.0; maxSpeed=0.0;
214  for (k=0; k < nQuadraturePoints_element; k++)
215  {
216  tmp_left = 0.0; tmp_right=0.0;
217  /*evaluate df at interior elemnent point but compute its value dotted with normal for speed*/
218  for (J=0; J < nSpace; J++)
219  {
220  tmp_left +=
221  df_element[left_eN_global*nQuadraturePoints_element*nSpace+ k*nSpace + J]
222  *
223  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
224  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
225  0*nSpace+
226  J];
227 
228  tmp_right +=
229  df_element[right_eN_global*nQuadraturePoints_element*nSpace+ k*nSpace + J]
230  *
231  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
232  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
233  0*nSpace+
234  J];
235  }
236  maxSpeed_left = fabs(tmp_left) > maxSpeed_left ? fabs(tmp_left) : maxSpeed_left;
237  maxSpeed_right= fabs(tmp_right) > maxSpeed_right ? fabs(tmp_right) : maxSpeed_right;
238  }
239  maxSpeed_element = maxSpeed_right > maxSpeed_left ? maxSpeed_right : maxSpeed_left;
240  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
241  {
242  left_speed =0.0;
243  right_speed=0.0;
244  left_flux=0.0;
245  right_flux=0.0;
246  for(J=0;J<nSpace;J++)
247  {
248  left_speed
249  +=
250  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
251  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
252  k*nSpace+
253  J]
254  *
255  df[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
256  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
257  k*nSpace+
258  J];
259  right_speed
260  +=
261  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
262  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
263  k*nSpace+
264  J]
265  *
266  df[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
267  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
268  k*nSpace+
269  J];
270  left_flux
271  +=
272  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
273  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
274  k*nSpace+
275  J]
276  *
277  f[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
278  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
279  k*nSpace+
280  J];
281  right_flux
282  +=
283  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
284  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
285  k*nSpace+
286  J]
287  *
288  f[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
289  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
290  k*nSpace+
291  J];
292  }
293 
294  u_left = u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
295  left_ebN_element*nQuadraturePoints_elementBoundary+
296  k];
297  u_right= u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
298  right_ebN_element*nQuadraturePoints_elementBoundary+
299  k];
300  maxSpeed = fabs(left_speed) > maxSpeed_element ? fabs(left_speed) : maxSpeed_element;
301  maxSpeed = fabs(right_speed) > maxSpeed ? fabs(right_speed) : maxSpeed;
302  maxSpeed*= safetyFactor;
303  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.5*(left_flux + right_flux) - 0.5*maxSpeed*(u_right-u_left);
304  dflux_left[ebN*nQuadraturePoints_elementBoundary+k] = 0.5*left_speed + 0.5*maxSpeed;
305  dflux_right[ebN*nQuadraturePoints_elementBoundary+k]= 0.5*right_speed - 0.5*maxSpeed;
306  /*mwf debug
307  if (fabs(u_left-u_right) > 1.0e-2)
308  {
309  printf("Rusanov ebN=%d eN_left=%d eN_right=%d u_left=%g u_right=%g left_flux=%g right_flux=%g flux=%g\n\t",
310  ebN,left_eN_global,right_eN_global,u_left,u_right,left_flux,right_flux,flux[ebN*nQuadraturePoints_elementBoundary+k]);
311  for (J=0; J < nSpace; J++)
312  {
313  printf("n[%d] = %g ",J,n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
314  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
315  k*nSpace+J]);
316  }
317  printf("\n");
318 
319  printf("maxSpeed_element= %g maxSpeed_left=%g maxSpeed_right=%g left_speed=%g right_speed=%g maxSpeed=%g\n",
320  maxSpeed_element,maxSpeed_left,maxSpeed_right,left_speed,right_speed,maxSpeed);
321  }
322  mwf end debug*/
323  }/*k*/
324  }/*ebnI*/
325 }
326 void calculateExteriorNumericalAdvectiveFluxRusanov(double safetyFactor,
327  int nExteriorElementBoundaries_global,
328  int nElementBoundaries_element,
329  int nQuadraturePoints_elementBoundary,
330  int nQuadraturePoints_element,
331  int nSpace,
332  int* exteriorElementBoundaries,
333  int* elementBoundaryElements,
334  int* elementBoundaryLocalElementBoundaries,
335  int* isDOFBoundary,
336  int* inflowFlag,
337  double* n,
338  double* bc_u,
339  double* bc_f,
340  double* bc_df,
341  double* u,
342  double* f,
343  double* df,
344  double* df_element,
345  double* flux,
346  double* dflux)
347 {
348  int ebNE,ebN,eN_global,ebN_element,k,J;
349  double left_flux,right_flux,u_left,u_right,left_speed,right_speed,
350  maxSpeed_element,maxSpeed,tmp_left;
351  /*for now use outer normal at first quadrature point for element speed calculations*/
352 
353  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
354  {
355  ebN = exteriorElementBoundaries[ebNE];
356  eN_global = elementBoundaryElements[ebN*2+0];
357  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
358  /*first calculate maximum value for df/du on neighboring element and use this
359  in Rusanov (local lax-friedrichs) flux
360  h(a,b) = 0.5*(f(a)+f(b)) - 0.5*alpha*(b-a)
361  */
362  maxSpeed_element =0.0; maxSpeed=0.0;
363  for (k=0; k < nQuadraturePoints_element; k++)
364  {
365  tmp_left = 0.0;
366  /*evaluate df at interior elemnent point but compute its value dotted with normal for speed*/
367  for (J=0; J < nSpace; J++)
368  {
369  tmp_left +=
370  df_element[eN_global*nQuadraturePoints_element*nSpace+ k*nSpace + J]
371  *
372  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
373  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
374  0*nSpace+
375  J];
376  }
377  maxSpeed_element = fabs(tmp_left) > maxSpeed_element ? fabs(tmp_left) : maxSpeed_element;
378  }
379  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
380  {
381  left_speed =0.0;
382  right_speed=0.0;
383  left_flux=0.0;
384  right_flux=0.0;
385  for(J=0;J<nSpace;J++)
386  {
387  left_speed
388  +=
389  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
390  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
391  k*nSpace+
392  J]
393  *
394  df[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
395  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
396  k*nSpace+
397  J];
398  right_speed
399  +=
400  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
401  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
402  k*nSpace+
403  J]
404  *
405  bc_df[ebNE*nQuadraturePoints_elementBoundary*nSpace+
406  k*nSpace+
407  J];
408  left_flux
409  +=
410  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
411  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
412  k*nSpace+
413  J]
414  *
415  f[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
416  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
417  k*nSpace+
418  J];
419  right_flux
420  +=
421  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
422  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
423  k*nSpace+
424  J]
425  *
426  bc_f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
427  k*nSpace+
428  J];
429  }
430 
431  u_left = u[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
432  ebN_element*nQuadraturePoints_elementBoundary+
433  k];
434  u_right= bc_u[ebNE*nQuadraturePoints_elementBoundary+
435  k];
436  maxSpeed = fabs(left_speed) > maxSpeed_element ? fabs(left_speed) : maxSpeed_element;
437  maxSpeed = fabs(right_speed) > maxSpeed ? fabs(right_speed) : maxSpeed;
438  maxSpeed*= safetyFactor;
439  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.5*(left_flux + right_flux) - 0.5*maxSpeed*(u_right-u_left);
440  dflux[ebN*nQuadraturePoints_elementBoundary+k] = 0.5*left_speed + 0.5*maxSpeed;
441 
442  /*mwf debug
443  if (fabs(u_left-u_right) > 1.0e-2)
444  {
445  printf("Rusanov exterior ebN=%d eN=%d u_left=%g u_right=%g left_flux=%g right_flux=%g flux=%g\n\t",
446  ebN,eN_global,u_left,u_right,left_flux,right_flux,flux[ebN*nQuadraturePoints_elementBoundary+k]);
447  for (J=0; J < nSpace; J++)
448  {
449  printf("n[%d] = %g ",J,n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
450  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
451  k*nSpace+J]);
452  }
453  printf("\n");
454 
455  printf("maxSpeed_element= %g left_speed=%g right_speed=%g maxSpeed=%g\n",
456  maxSpeed_element,left_speed,right_speed,maxSpeed);
457  }
458  mwf end debug*/
459  }/*k*/
460  }/*ebnI*/
461 }
462 
463 void calculateGlobalExteriorNumericalAdvectiveFluxRusanov(double safetyFactor,
464  int nExteriorElementBoundaries_global,
465  int nQuadraturePoints_elementBoundary,
466  int nQuadraturePoints_element,
467  int nSpace,
468  int* exteriorElementBoundaries,
469  int* elementBoundaryElements,
470  int* elementBoundaryLocalElementBoundaries,
471  int* isDOFBoundary,
472  int* inflowFlag,
473  double* n,
474  double* bc_u,
475  double* bc_f,
476  double* bc_df,
477  double* u,
478  double* f,
479  double* df,
480  double* df_element,
481  double* flux,
482  double* dflux)
483 {
484  int ebNE,ebN,eN_global,k,J;
485  double left_flux,right_flux,u_left,u_right,left_speed,right_speed,
486  maxSpeed_element,maxSpeed,tmp_left;
487  /*for now use outer normal at first quadrature point for element speed calculations*/
488 
489  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
490  {
491  ebN = exteriorElementBoundaries[ebNE];
492  eN_global = elementBoundaryElements[ebN*2+0];
493  /*first calculate maximum value for df/du on neighboring element and use this
494  in Rusanov (local lax-friedrichs) flux
495  h(a,b) = 0.5*(f(a)+f(b)) - 0.5*alpha*(b-a)
496  */
497  maxSpeed_element =0.0; maxSpeed=0.0;
498  for (k=0; k < nQuadraturePoints_element; k++)
499  {
500  tmp_left = 0.0;
501  /*evaluate df at interior elemnent point but compute its value dotted with normal for speed*/
502  for (J=0; J < nSpace; J++)
503  {
504  tmp_left +=
505  df_element[eN_global*nQuadraturePoints_element*nSpace+ k*nSpace + J]
506  *
507  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
508  0*nSpace+
509  J];
510  }
511  maxSpeed_element = fabs(tmp_left) > maxSpeed_element ? fabs(tmp_left) : maxSpeed_element;
512  }
513  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
514  {
515  left_speed =0.0;
516  right_speed=0.0;
517  left_flux=0.0;
518  right_flux=0.0;
519  for(J=0;J<nSpace;J++)
520  {
521  left_speed
522  +=
523  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
524  k*nSpace+
525  J]
526  *
527  df[ebNE*nQuadraturePoints_elementBoundary*nSpace+
528  k*nSpace+
529  J];
530  right_speed
531  +=
532  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
533  k*nSpace+
534  J]
535  *
536  bc_df[ebNE*nQuadraturePoints_elementBoundary*nSpace+
537  k*nSpace+
538  J];
539  left_flux
540  +=
541  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
542  k*nSpace+
543  J]
544  *
545  f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
546  k*nSpace+
547  J];
548  right_flux
549  +=
550  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
551  k*nSpace+
552  J]
553  *
554  bc_f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
555  k*nSpace+
556  J];
557  }
558 
559  u_left = u[ebNE*nQuadraturePoints_elementBoundary+
560  k];
561  u_right= bc_u[ebNE*nQuadraturePoints_elementBoundary+
562  k];
563  maxSpeed = fabs(left_speed) > maxSpeed_element ? fabs(left_speed) : maxSpeed_element;
564  maxSpeed = fabs(right_speed) > maxSpeed ? fabs(right_speed) : maxSpeed;
565  maxSpeed*= safetyFactor;
566  flux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.5*(left_flux + right_flux) - 0.5*maxSpeed*(u_right-u_left);
567  dflux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.5*left_speed + 0.5*maxSpeed;
568 
569  /*mwf debug
570  if (fabs(u_left-u_right) > 1.0e-2)
571  {
572  printf("Rusanov exterior ebN=%d u_left=%g u_right=%g left_flux=%g right_flux=%g flux=%g\n\t",
573  ebNE,u_left,u_right,left_flux,right_flux,flux[ebNE*nQuadraturePoints_elementBoundary+k]);
574  for (J=0; J < nSpace; J++)
575  {
576  printf("n[%d] = %g ",J,n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
577  k*nSpace+J]);
578  }
579  printf("\n");
580 
581  printf("maxSpeed_element= %g left_speed=%g right_speed=%g maxSpeed=%g\n",
582  maxSpeed_element,left_speed,right_speed,maxSpeed);
583  }
584  mwf end debug*/
585  }/*k*/
586  }/*ebnE*/
587 }
591 void calculateInteriorNumericalAdvectiveFluxRusanovWithEigenvalueBound(double safetyFactor,
592  int nInteriorElementBoundaries_global,
593  int nElementBoundaries_element,
594  int nQuadraturePoints_elementBoundary,
595  int nQuadraturePoints_element,
596  int nSpace,
597  int* interiorElementBoundaries,
598  int* elementBoundaryElements,
599  int* elementBoundaryLocalElementBoundaries,
600  double* n,
601  double* u,
602  double* f,
603  double* lambda_bar_element,
604  double* flux)
605 {
606  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,J;
607  double left_flux,right_flux,u_left,u_right,
608  maxSpeed_left,maxSpeed_right,maxSpeed_element,maxSpeed,tmp_left,tmp_right;
609  /*for now use outer normal at first quadrature point for element speed calculations*/
610 
611  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
612  {
613  ebN = interiorElementBoundaries[ebNI];
614  left_eN_global = elementBoundaryElements[ebN*2+0];
615  right_eN_global = elementBoundaryElements[ebN*2+1];
616  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
617  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
618  /*first calculate maximum value for df/du on neighboring elements and use this
619  in Rusanov (local lax-friedrichs) flux
620  h(a,b) = 0.5*(f(a)+f(b)) - 0.5*alpha*(b-a)
621  */
622  maxSpeed_left =0.0; maxSpeed_right=0.0; maxSpeed=0.0;
623  for (k=0; k < nQuadraturePoints_element; k++)
624  {
625  tmp_left = lambda_bar_element[left_eN_global*nQuadraturePoints_element + k];
626  tmp_right= lambda_bar_element[right_eN_global*nQuadraturePoints_element + k];
627  maxSpeed_left = fabs(tmp_left) > maxSpeed_left ? fabs(tmp_left) : maxSpeed_left;
628  maxSpeed_right= fabs(tmp_right) > maxSpeed_right ? fabs(tmp_right) : maxSpeed_right;
629  }
630  maxSpeed_element = maxSpeed_right > maxSpeed_left ? maxSpeed_right : maxSpeed_left;
631  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
632  {
633  left_flux=0.0;
634  right_flux=0.0;
635  for(J=0;J<nSpace;J++)
636  {
637  left_flux
638  +=
639  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
640  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
641  k*nSpace+
642  J]
643  *
644  f[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
645  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
646  k*nSpace+
647  J];
648  right_flux
649  +=
650  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
651  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
652  k*nSpace+
653  J]
654  *
655  f[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
656  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
657  k*nSpace+
658  J];
659  }
660 
661  u_left = u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
662  left_ebN_element*nQuadraturePoints_elementBoundary+
663  k];
664  u_right= u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
665  right_ebN_element*nQuadraturePoints_elementBoundary+
666  k];
667 /* maxSpeed = fabs(left_speed) > maxSpeed_element ? fabs(left_speed) : maxSpeed_element; */
668 /* maxSpeed = fabs(right_speed) > maxSpeed ? fabs(right_speed) : maxSpeed; */
669  maxSpeed = maxSpeed_element;
670  maxSpeed*= safetyFactor;
671  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.5*(left_flux + right_flux) - 0.5*maxSpeed*(u_right-u_left);
672  /*mwf debug
673  if (fabs(u_left-u_right) > 1.0e-2)
674  {
675  printf("Rusanov ebN=%d eN_left=%d eN_right=%d u_left=%g u_right=%g left_flux=%g right_flux=%g flux=%g\n\t",
676  ebN,left_eN_global,right_eN_global,u_left,u_right,left_flux,right_flux,flux[ebN*nQuadraturePoints_elementBoundary+k]);
677  for (J=0; J < nSpace; J++)
678  {
679  printf("n[%d] = %g ",J,n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
680  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
681  k*nSpace+J]);
682  }
683  printf("\n");
684 
685  printf("maxSpeed_element= %g maxSpeed_left=%g maxSpeed_right=%g left_speed=%g right_speed=%g maxSpeed=%g\n",
686  maxSpeed_element,maxSpeed_left,maxSpeed_right,left_speed,right_speed,maxSpeed);
687  }
688  mwf end debug*/
689  }/*k*/
690  }/*ebnI*/
691 }
692 void calculateGlobalExteriorNumericalAdvectiveFluxRusanovWithEigenvalueBound(double safetyFactor,
693  int nExteriorElementBoundaries_global,
694  int nQuadraturePoints_elementBoundary,
695  int nQuadraturePoints_element,
696  int nSpace,
697  int* exteriorElementBoundaries,
698  int* elementBoundaryElements,
699  int* elementBoundaryLocalElementBoundaries,
700  int* isDOFBoundary,
701  int* inflowFlag,
702  double* n,
703  double* bc_u,
704  double* bc_f,
705  double* u,
706  double* f,
707  double* lambda_bar,
708  double* flux)
709 {
710  int ebNE,ebN,eN_global,k,J;
711  double left_flux,right_flux,u_left,u_right,
712  maxSpeed_element,maxSpeed,tmp_left;
713  /*for now use outer normal at first quadrature point for element speed calculations*/
714 
715  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
716  {
717  ebN = exteriorElementBoundaries[ebNE];
718  eN_global = elementBoundaryElements[ebN*2+0];
719  /*first calculate maximum value for df/du on neighboring element and use this
720  in Rusanov (local lax-friedrichs) flux
721  h(a,b) = 0.5*(f(a)+f(b)) - 0.5*alpha*(b-a)
722  */
723  maxSpeed_element =0.0; maxSpeed=0.0;
724  for (k=0; k < nQuadraturePoints_element; k++)
725  {
726  tmp_left = lambda_bar[eN_global*nQuadraturePoints_element + k];
727  maxSpeed_element = fabs(tmp_left) > maxSpeed_element ? fabs(tmp_left) : maxSpeed_element;
728  }
729  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
730  {
731  left_flux=0.0;
732  right_flux=0.0;
733  for(J=0;J<nSpace;J++)
734  {
735  left_flux
736  +=
737  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
738  k*nSpace+
739  J]
740  *
741  f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
742  k*nSpace+
743  J];
744  right_flux
745  +=
746  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
747  k*nSpace+
748  J]
749  *
750  bc_f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
751  k*nSpace+
752  J];
753  }
754 
755  u_left = u[ebNE*nQuadraturePoints_elementBoundary+
756  k];
757  u_right= bc_u[ebNE*nQuadraturePoints_elementBoundary+
758  k];
759 /* maxSpeed = fabs(left_speed) > maxSpeed_element ? fabs(left_speed) : maxSpeed_element; */
760 /* maxSpeed = fabs(right_speed) > maxSpeed ? fabs(right_speed) : maxSpeed; */
761  maxSpeed =maxSpeed_element;
762  maxSpeed*= safetyFactor;
763  flux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.5*(left_flux + right_flux) - 0.5*maxSpeed*(u_right-u_left);
764 
765  /*mwf debug
766  if (fabs(u_left-u_right) > 1.0e-2)
767  {
768  printf("Rusanov exterior ebN=%d u_left=%g u_right=%g left_flux=%g right_flux=%g flux=%g\n\t",
769  ebNE,u_left,u_right,left_flux,right_flux,flux[ebNE*nQuadraturePoints_elementBoundary+k]);
770  for (J=0; J < nSpace; J++)
771  {
772  printf("n[%d] = %g ",J,n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
773  k*nSpace+J]);
774  }
775  printf("\n");
776 
777  printf("maxSpeed_element= %g left_speed=%g right_speed=%g maxSpeed=%g\n",
778  maxSpeed_element,left_speed,right_speed,maxSpeed);
779  }
780  mwf end debug*/
781  }/*k*/
782  }/*ebnE*/
783 }
784 void calculateExteriorNumericalAdvectiveFluxRusanovWithEigenvalueBound(double safetyFactor,
785  int nExteriorElementBoundaries_global,
786  int nElementBoundaries_element,
787  int nQuadraturePoints_elementBoundary,
788  int nQuadraturePoints_element,
789  int nSpace,
790  int* exteriorElementBoundaries,
791  int* elementBoundaryElements,
792  int* elementBoundaryLocalElementBoundaries,
793  int* isDOFBoundary,
794  int* inflowFlag,
795  double* n,
796  double* bc_u,
797  double* bc_f,
798  double* u,
799  double* f,
800  double* lambda_bar,
801  double* flux)
802 {
803  int ebNE,ebN,eN_global,ebN_element,k,J;
804  double left_flux,right_flux,u_left,u_right,
805  maxSpeed_element,maxSpeed,tmp_left;
806  /*for now use outer normal at first quadrature point for element speed calculations*/
807 
808  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
809  {
810  ebN = exteriorElementBoundaries[ebNE];
811  eN_global = elementBoundaryElements[ebN*2+0];
812  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
813  /*first calculate maximum value for df/du on neighboring element and use this
814  in Rusanov (local lax-friedrichs) flux
815  h(a,b) = 0.5*(f(a)+f(b)) - 0.5*alpha*(b-a)
816  */
817  maxSpeed_element =0.0; maxSpeed=0.0;
818  for (k=0; k < nQuadraturePoints_element; k++)
819  {
820  tmp_left = lambda_bar[eN_global*nQuadraturePoints_element+k];
821  maxSpeed_element = fabs(tmp_left) > maxSpeed_element ? fabs(tmp_left) : maxSpeed_element;
822  }
823  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
824  {
825  left_flux=0.0;
826  right_flux=0.0;
827  for(J=0;J<nSpace;J++)
828  {
829  left_flux
830  +=
831  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
832  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
833  k*nSpace+
834  J]
835  *
836  f[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
837  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
838  k*nSpace+
839  J];
840  right_flux
841  +=
842  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
843  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
844  k*nSpace+
845  J]
846  *
847  bc_f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
848  k*nSpace+
849  J];
850  }
851 
852  u_left = u[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
853  ebN_element*nQuadraturePoints_elementBoundary+
854  k];
855  u_right= bc_u[ebNE*nQuadraturePoints_elementBoundary+
856  k];
857 /* maxSpeed = fabs(left_speed) > maxSpeed_element ? fabs(left_speed) : maxSpeed_element; */
858 /* maxSpeed = fabs(right_speed) > maxSpeed ? fabs(right_speed) : maxSpeed; */
859  maxSpeed = maxSpeed_element;
860  maxSpeed*= safetyFactor;
861  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.5*(left_flux + right_flux) - 0.5*maxSpeed*(u_right-u_left);
862 
863  /*mwf debug
864  if (fabs(u_left-u_right) > 1.0e-2)
865  {
866  printf("Rusanov exterior ebN=%d eN=%d u_left=%g u_right=%g left_flux=%g right_flux=%g flux=%g\n\t",
867  ebN,eN_global,u_left,u_right,left_flux,right_flux,flux[ebN*nQuadraturePoints_elementBoundary+k]);
868  for (J=0; J < nSpace; J++)
869  {
870  printf("n[%d] = %g ",J,n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
871  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
872  k*nSpace+J]);
873  }
874  printf("\n");
875 
876  printf("maxSpeed_element= %g left_speed=%g right_speed=%g maxSpeed=%g\n",
877  maxSpeed_element,left_speed,right_speed,maxSpeed);
878  }
879  mwf end debug*/
880  }/*k*/
881  }/*ebnI*/
882 }
883 
884 /************************************************************************
885  begin moving over exterior numerical flux routines and changing to index
886  boundary quadrature arrays as nExternalElementBoundaries * .
887  ************************************************************************/
891 void calculateInteriorNumericalDiffusiveFlux(int scale_penalty,
892  double penalty_floor,
893  int nInteriorElementBoundaries_global,
894  int nElementBoundaries_element,
895  int nQuadraturePoints_elementBoundary,
896  int nSpace,
897  int* interiorElementBoundaries,
898  int* elementBoundaryElements,
899  int* elementBoundaryLocalElementBoundaries,
900  double* n,
901  double* a,
902  double* grad_phi,
903  double* u,
904  double* penalty,
905  double* flux)
906 {
907  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,J,I,nSpace2=nSpace*nSpace;
908  double diffusiveVelocityComponent_I,max_a=0.0;
909  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
910  {
911  ebN = interiorElementBoundaries[ebNI];
912  left_eN_global = elementBoundaryElements[ebN*2+0];
913  right_eN_global = elementBoundaryElements[ebN*2+1];
914  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
915  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
916  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
917  {
918  max_a = 0.0;
919  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;
920  for(I=0;I<nSpace;I++)
921  {
922  diffusiveVelocityComponent_I=0.0;
923  for(J=0;J<nSpace;J++)
924  {
925  diffusiveVelocityComponent_I
926  -=
927  (a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
928  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
929  k*nSpace2+
930  I*nSpace+
931  J]
932  *
933  grad_phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
934  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
935  k*nSpace+J]
936  +
937  a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
938  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
939  k*nSpace2+
940  I*nSpace+
941  J]
942  *
943  grad_phi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
944  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
945  k*nSpace+J]);
946  max_a = fmax(max_a,a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
947  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
948  k*nSpace2+
949  I*nSpace+
950  J]);
951  max_a = fmax(max_a,a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
952  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
953  k*nSpace2+
954  I*nSpace+
955  J]);
956  }
957  flux[ebN*nQuadraturePoints_elementBoundary+
958  k]
959  +=
960  diffusiveVelocityComponent_I
961  *
962  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
963  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
964  k*nSpace+
965  I];
966  }
967  flux[ebN*nQuadraturePoints_elementBoundary+
968  k] *= 0.5;
970  max_a = fmax(max_a,penalty_floor);
971  double penalty_flux = penalty[ebN*nQuadraturePoints_elementBoundary+
972  k]
973  *
974  (u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
975  left_ebN_element*nQuadraturePoints_elementBoundary+
976  k]-
977  u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
978  right_ebN_element*nQuadraturePoints_elementBoundary+
979  k]);
980  if (scale_penalty) penalty_flux *= max_a;
981  flux[ebN*nQuadraturePoints_elementBoundary+
982  k]
983  += penalty_flux;
984  }
985  }
986 }
987 void calculateInteriorNumericalDiffusiveFlux_sd(int scale_penalty,
988  double penalty_floor,
989  int nInteriorElementBoundaries_global,
990  int nElementBoundaries_element,
991  int nQuadraturePoints_elementBoundary,
992  int nSpace,
993  int* rowptr,
994  int* colind,
995  int* interiorElementBoundaries,
996  int* elementBoundaryElements,
997  int* elementBoundaryLocalElementBoundaries,
998  double* n,
999  double* a,
1000  double* grad_phi,
1001  double* u,
1002  double* penalty,
1003  double* flux)
1004 {
1005  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,I,m,nnz=rowptr[nSpace];
1006  double diffusiveVelocityComponent_I,max_a=0.0;
1007  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
1008  {
1009  ebN = interiorElementBoundaries[ebNI];
1010  left_eN_global = elementBoundaryElements[ebN*2+0];
1011  right_eN_global = elementBoundaryElements[ebN*2+1];
1012  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
1013  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
1014  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
1015  {
1016  max_a = 0.0;
1017  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;
1018  for(I=0;I<nSpace;I++)
1019  {
1020  diffusiveVelocityComponent_I=0.0;
1021  for(m=rowptr[I];m<rowptr[I+1];m++)
1022  {
1023  diffusiveVelocityComponent_I
1024  -=
1025  (a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1026  left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1027  k*nnz+
1028  m]
1029  *
1030  grad_phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1031  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1032  k*nSpace+colind[m]]
1033  +
1034  a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1035  right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1036  k*nnz+
1037  m]
1038  *
1039  grad_phi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1040  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1041  k*nSpace+colind[m]]);
1042  max_a = fmax(max_a,a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1043  left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1044  k*nnz+
1045  m]);
1046  max_a = fmax(max_a,a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1047  right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1048  k*nnz+
1049  m]);
1050  }
1051  flux[ebN*nQuadraturePoints_elementBoundary+
1052  k]
1053  +=
1054  diffusiveVelocityComponent_I
1055  *
1056  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1057  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1058  k*nSpace+
1059  I];
1060  }
1061  flux[ebN*nQuadraturePoints_elementBoundary+
1062  k] *= 0.5;
1064  max_a = fmax(max_a,penalty_floor);
1065  double penalty_flux = penalty[ebN*nQuadraturePoints_elementBoundary+
1066  k]
1067  *
1068  (u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
1069  left_ebN_element*nQuadraturePoints_elementBoundary+
1070  k]-
1071  u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
1072  right_ebN_element*nQuadraturePoints_elementBoundary+
1073  k]);
1074  if (scale_penalty) penalty_flux *= max_a;
1075  /*mwf debug
1076  printf("calcIntNumDiffFlux_sd scale= %d k= %d max_a= %g penalty= %g \n",scale_penalty,k,max_a,penalty_flux);
1077  */
1078  flux[ebN*nQuadraturePoints_elementBoundary+
1079  k]
1080  += penalty_flux;
1081  }
1082  }
1083 }
1084 
1085 /*
1086  \brief Calculate the diffusive flux at interior element boundary quadrature points
1087 
1088 void calculateInteriorNumericalDiffusiveFlux(int nInteriorElementBoundaries_global,
1089  int nElementBoundaries_element,
1090  int nQuadraturePoints_elementBoundary,
1091  int nSpace,
1092  int* interiorElementBoundaries,
1093  int* elementBoundaryElements,
1094  int* elementBoundaryLocalElementBoundaries,
1095  double* n,
1096  double* a,
1097  double* grad_phi,
1098  double* u,
1099  double* penalty,
1100  double* flux)
1101 {
1102  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,J,I,nSpace2=nSpace*nSpace;
1103  double diffusiveVelocityComponent_I;
1104  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
1105  {
1106  ebN = interiorElementBoundaries[ebNI];
1107  left_eN_global = elementBoundaryElements[ebN*2+0];
1108  right_eN_global = elementBoundaryElements[ebN*2+1];
1109  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
1110  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
1111  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
1112  {
1113  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;
1114  for(I=0;I<nSpace;I++)
1115  {
1116  diffusiveVelocityComponent_I=0.0;
1117  for(J=0;J<nSpace;J++)
1118  {
1119  diffusiveVelocityComponent_I
1120  -=
1121  (a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1122  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1123  k*nSpace2+
1124  I*nSpace+
1125  J]
1126  *
1127  grad_phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1128  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1129  k*nSpace+J]
1130  +
1131  a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1132  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1133  k*nSpace2+
1134  I*nSpace+
1135  J]
1136  *
1137  grad_phi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1138  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1139  k*nSpace+J]);
1140  }
1141  flux[ebN*nQuadraturePoints_elementBoundary+
1142  k]
1143  +=
1144  diffusiveVelocityComponent_I
1145  *
1146  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1147  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1148  k*nSpace+
1149  I];
1150  }
1151  flux[ebN*nQuadraturePoints_elementBoundary+
1152  k] *= 0.5;
1153  // \todo make penalty in DG on phi instead of u
1154  flux[ebN*nQuadraturePoints_elementBoundary+
1155  k]
1156  +=
1157  penalty[ebN*nQuadraturePoints_elementBoundary+
1158  k]
1159  *
1160  (u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
1161  left_ebN_element*nQuadraturePoints_elementBoundary+
1162  k]-
1163  u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
1164  right_ebN_element*nQuadraturePoints_elementBoundary+
1165  k]);
1166  }
1167  }
1168 }
1169 void calculateInteriorNumericalDiffusiveFlux_sd(int nInteriorElementBoundaries_global,
1170  int nElementBoundaries_element,
1171  int nQuadraturePoints_elementBoundary,
1172  int nSpace,
1173  int* rowptr,
1174  int* colind,
1175  int* interiorElementBoundaries,
1176  int* elementBoundaryElements,
1177  int* elementBoundaryLocalElementBoundaries,
1178  double* n,
1179  double* a,
1180  double* grad_phi,
1181  double* u,
1182  double* penalty,
1183  double* flux)
1184 {
1185  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,I,m,nnz=rowptr[nSpace];
1186  double diffusiveVelocityComponent_I;
1187  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
1188  {
1189  ebN = interiorElementBoundaries[ebNI];
1190  left_eN_global = elementBoundaryElements[ebN*2+0];
1191  right_eN_global = elementBoundaryElements[ebN*2+1];
1192  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
1193  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
1194  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
1195  {
1196  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;
1197  for(I=0;I<nSpace;I++)
1198  {
1199  diffusiveVelocityComponent_I=0.0;
1200  for(m=rowptr[I];m<rowptr[I+1];m++)
1201  {
1202  diffusiveVelocityComponent_I
1203  -=
1204  (a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1205  left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1206  k*nnz+
1207  m]
1208  *
1209  grad_phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1210  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1211  k*nSpace+colind[m]]
1212  +
1213  a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1214  right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1215  k*nnz+
1216  m]
1217  *
1218  grad_phi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1219  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1220  k*nSpace+colind[m]]);
1221  }
1222  flux[ebN*nQuadraturePoints_elementBoundary+
1223  k]
1224  +=
1225  diffusiveVelocityComponent_I
1226  *
1227  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1228  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1229  k*nSpace+
1230  I];
1231  }
1232  flux[ebN*nQuadraturePoints_elementBoundary+
1233  k] *= 0.5;
1234  // \todo make penalty in DG on phi instead of u
1235  flux[ebN*nQuadraturePoints_elementBoundary+
1236  k]
1237  +=
1238  penalty[ebN*nQuadraturePoints_elementBoundary+
1239  k]
1240  *
1241  (u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
1242  left_ebN_element*nQuadraturePoints_elementBoundary+
1243  k]-
1244  u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
1245  right_ebN_element*nQuadraturePoints_elementBoundary+
1246  k]);
1247  }
1248  }
1249 }
1250 */
1251 
1255 void updateInteriorNumericalDiffusiveFluxJacobian(int scale_penalty,
1256  double penalty_floor,
1257  int nInteriorElementBoundaries_global,
1258  int nElementBoundaries_element,
1259  int nQuadraturePoints_elementBoundary,
1260  int nDOF_trial_element,
1261  int nSpace,
1262  int* l2g,
1263  int* interiorElementBoundaries,
1264  int* elementBoundaryElements,
1265  int* elementBoundaryLocalElementBoundaries,
1266  double* n,
1267  double* a,
1268  double* da,
1269  double* grad_phi,
1270  double* dphi,
1271  double* v,
1272  double* grad_v,
1273  double* penalty,
1274  double* fluxJacobian)
1275 {
1276  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,j,left_j_global,right_j_global,I,J,nSpace2=nSpace*nSpace;
1277  double leftJacobian,rightJacobian,diffusiveVelocityComponent_I_leftJacobian,diffusiveVelocityComponent_I_rightJacobian,diffusiveVelocityComponent_I_leftJacobian2,diffusiveVelocityComponent_I_rightJacobian2,max_a=0.0;
1278  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
1279  {
1280  ebN = interiorElementBoundaries[ebNI];
1281  left_eN_global = elementBoundaryElements[ebN*2+0];
1282  right_eN_global = elementBoundaryElements[ebN*2+1];
1283  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
1284  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
1285  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
1286  {
1287  max_a = 0.0;
1288  for(j=0;j<nDOF_trial_element;j++)
1289  {
1290  leftJacobian=0.0;
1291  rightJacobian=0.0;
1292  left_j_global = l2g[left_eN_global*nDOF_trial_element+j];
1293  right_j_global= l2g[right_eN_global*nDOF_trial_element+j];
1294  for(I=0;I<nSpace;I++)
1295  {
1296  diffusiveVelocityComponent_I_leftJacobian=0.0;
1297  diffusiveVelocityComponent_I_leftJacobian2=0.0;
1298  diffusiveVelocityComponent_I_rightJacobian=0.0;
1299  diffusiveVelocityComponent_I_rightJacobian2=0.0;
1300  for(J=0;J<nSpace;J++)
1301  {
1302  diffusiveVelocityComponent_I_leftJacobian
1303  -=
1304  da[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1305  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1306  k*nSpace2+
1307  I*nSpace+
1308  J]
1309  *
1310  grad_phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1311  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1312  k*nSpace+
1313  J];
1314  diffusiveVelocityComponent_I_rightJacobian
1315  -=
1316  da[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1317  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1318  k*nSpace2+
1319  I*nSpace+
1320  J]
1321  *
1322  grad_phi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1323  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1324  k*nSpace+
1325  J];
1326  diffusiveVelocityComponent_I_leftJacobian2
1327  -=
1328  a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1329  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1330  k*nSpace2+
1331  I*nSpace+
1332  J]
1333  *
1334  grad_v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1335  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1336  k*nDOF_trial_element*nSpace+
1337  j*nSpace+
1338  J];
1339  diffusiveVelocityComponent_I_rightJacobian2
1340  -=
1341  a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1342  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1343  k*nSpace2+
1344  I*nSpace+
1345  J]
1346  *
1347  grad_v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1348  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1349  k*nDOF_trial_element*nSpace+
1350  j*nSpace+
1351  J];
1352  max_a = fmax(max_a,a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1353  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1354  k*nSpace2+
1355  I*nSpace+
1356  J]);
1357  max_a = fmax(max_a,a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1358  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1359  k*nSpace2+
1360  I*nSpace+
1361  J]);
1362 
1363  }
1364  leftJacobian
1365  +=
1366  (diffusiveVelocityComponent_I_leftJacobian
1367  *
1368  v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1369  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1370  k*nDOF_trial_element+
1371  j]
1372  +
1373  diffusiveVelocityComponent_I_leftJacobian2*
1374  dphi[left_j_global])
1375  *
1376  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1377  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1378  k*nSpace+
1379  I];
1380  rightJacobian
1381  +=
1382  (diffusiveVelocityComponent_I_rightJacobian
1383  *
1384  v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1385  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1386  k*nDOF_trial_element+
1387  j]
1388  +
1389  diffusiveVelocityComponent_I_rightJacobian2*dphi[right_j_global])
1390  *
1391  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1392  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1393  k*nSpace+
1394  I];
1395  }
1396  leftJacobian *= 0.5;
1397  rightJacobian *= 0.5;
1398  max_a = fmax(max_a,penalty_floor);
1399  double penaltyJacobian_term = penalty[ebN*nQuadraturePoints_elementBoundary+
1400  k];
1401  if (scale_penalty) penaltyJacobian_term *= max_a;
1402  leftJacobian
1403  +=
1404  penaltyJacobian_term
1405  *
1406  v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1407  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1408  k*nDOF_trial_element+
1409  j];
1410  rightJacobian
1411  -=
1412  penaltyJacobian_term
1413  *
1414  v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1415  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1416  k*nDOF_trial_element+
1417  j];
1418  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1419  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1420  k*nDOF_trial_element+
1421  j] += leftJacobian;
1422  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1423  1*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1424  k*nDOF_trial_element+
1425  j] += rightJacobian;
1426  }
1427  }
1428  }
1429 }
1430 
1431 void updateInteriorNumericalDiffusiveFluxJacobian_sd(int scale_penalty,
1432  double penalty_floor,
1433  int nInteriorElementBoundaries_global,
1434  int nElementBoundaries_element,
1435  int nQuadraturePoints_elementBoundary,
1436  int nDOF_trial_element,
1437  int nSpace,
1438  int* rowptr,
1439  int* colind,
1440  int* l2g,
1441  int* interiorElementBoundaries,
1442  int* elementBoundaryElements,
1443  int* elementBoundaryLocalElementBoundaries,
1444  double* n,
1445  double* a,
1446  double* da,
1447  double* grad_phi,
1448  double* dphi,
1449  double* v,
1450  double* grad_v,
1451  double* penalty,
1452  double* fluxJacobian)
1453 {
1454  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,j,left_j_global,right_j_global,I,m,nnz=rowptr[nSpace];
1455  double leftJacobian,rightJacobian,diffusiveVelocityComponent_I_leftJacobian,diffusiveVelocityComponent_I_rightJacobian,diffusiveVelocityComponent_I_leftJacobian2,diffusiveVelocityComponent_I_rightJacobian2,max_a;
1456  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
1457  {
1458  ebN = interiorElementBoundaries[ebNI];
1459  left_eN_global = elementBoundaryElements[ebN*2+0];
1460  right_eN_global = elementBoundaryElements[ebN*2+1];
1461  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
1462  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
1463  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
1464  {
1465  max_a = 0.0;
1466  for(j=0;j<nDOF_trial_element;j++)
1467  {
1468  leftJacobian=0.0;
1469  rightJacobian=0.0;
1470  left_j_global = l2g[left_eN_global*nDOF_trial_element+j];
1471  right_j_global= l2g[right_eN_global*nDOF_trial_element+j];
1472  for(I=0;I<nSpace;I++)
1473  {
1474  diffusiveVelocityComponent_I_leftJacobian=0.0;
1475  diffusiveVelocityComponent_I_leftJacobian2=0.0;
1476  diffusiveVelocityComponent_I_rightJacobian=0.0;
1477  diffusiveVelocityComponent_I_rightJacobian2=0.0;
1478  for(m=rowptr[I];m<rowptr[I+1];m++)
1479  {
1480  diffusiveVelocityComponent_I_leftJacobian
1481  -=
1482  da[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1483  left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1484  k*nnz+
1485  m]
1486  *
1487  grad_phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1488  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1489  k*nSpace+
1490  colind[m]];
1491  diffusiveVelocityComponent_I_rightJacobian
1492  -=
1493  da[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1494  right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1495  k*nnz+
1496  m]
1497  *
1498  grad_phi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1499  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1500  k*nSpace+
1501  colind[m]];
1502  diffusiveVelocityComponent_I_leftJacobian2
1503  -=
1504  a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1505  left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1506  k*nnz+
1507  m]
1508  *
1509  grad_v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1510  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1511  k*nDOF_trial_element*nSpace+
1512  j*nSpace+
1513  colind[m]];
1514  diffusiveVelocityComponent_I_rightJacobian2
1515  -=
1516  a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1517  right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1518  k*nnz+
1519  m]
1520  *
1521  grad_v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1522  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1523  k*nDOF_trial_element*nSpace+
1524  j*nSpace+
1525  colind[m]];
1526  max_a = fmax(max_a,a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1527  left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1528  k*nnz+
1529  m]);
1530  max_a = fmax(max_a,a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1531  right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1532  k*nnz+
1533  m]);
1534 
1535  }
1536  leftJacobian
1537  +=
1538  (diffusiveVelocityComponent_I_leftJacobian
1539  *
1540  v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1541  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1542  k*nDOF_trial_element+
1543  j]
1544  +
1545  diffusiveVelocityComponent_I_leftJacobian2*
1546  dphi[left_j_global])
1547  *
1548  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1549  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1550  k*nSpace+
1551  I];
1552  rightJacobian
1553  +=
1554  (diffusiveVelocityComponent_I_rightJacobian
1555  *
1556  v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1557  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1558  k*nDOF_trial_element+
1559  j]
1560  +
1561  diffusiveVelocityComponent_I_rightJacobian2*dphi[right_j_global])
1562  *
1563  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1564  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1565  k*nSpace+
1566  I];
1567  }
1568  leftJacobian *= 0.5;
1569  rightJacobian *= 0.5;
1570  max_a = fmax(max_a,penalty_floor);
1571  double penaltyJacobian_term = penalty[ebN*nQuadraturePoints_elementBoundary+
1572  k];
1573  if (scale_penalty) penaltyJacobian_term *= max_a;
1574  leftJacobian
1575  +=
1576  penaltyJacobian_term
1577  *
1578  v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1579  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1580  k*nDOF_trial_element+
1581  j];
1582  rightJacobian
1583  -=
1584  penaltyJacobian_term
1585  *
1586  v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1587  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1588  k*nDOF_trial_element+
1589  j];
1590  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1591  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1592  k*nDOF_trial_element+
1593  j] += leftJacobian;
1594  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1595  1*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1596  k*nDOF_trial_element+
1597  j] += rightJacobian;
1598  }
1599  }
1600  }
1601 }
1602 
1603 /*
1604  \brief Calculate the diffusive flux Jacobian at interior element boundary quadrature points
1605 
1606 void updateInteriorNumericalDiffusiveFluxJacobian(int nInteriorElementBoundaries_global,
1607  int nElementBoundaries_element,
1608  int nQuadraturePoints_elementBoundary,
1609  int nDOF_trial_element,
1610  int nSpace,
1611  int* l2g,
1612  int* interiorElementBoundaries,
1613  int* elementBoundaryElements,
1614  int* elementBoundaryLocalElementBoundaries,
1615  double* n,
1616  double* a,
1617  double* da,
1618  double* grad_phi,
1619  double* dphi,
1620  double* v,
1621  double* grad_v,
1622  double* penalty,
1623  double* fluxJacobian)
1624 {
1625  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,j,left_j_global,right_j_global,I,J,nSpace2=nSpace*nSpace;
1626  double leftJacobian,rightJacobian,diffusiveVelocityComponent_I_leftJacobian,diffusiveVelocityComponent_I_rightJacobian,diffusiveVelocityComponent_I_leftJacobian2,diffusiveVelocityComponent_I_rightJacobian2;
1627  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
1628  {
1629  ebN = interiorElementBoundaries[ebNI];
1630  left_eN_global = elementBoundaryElements[ebN*2+0];
1631  right_eN_global = elementBoundaryElements[ebN*2+1];
1632  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
1633  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
1634  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
1635  {
1636  for(j=0;j<nDOF_trial_element;j++)
1637  {
1638  leftJacobian=0.0;
1639  rightJacobian=0.0;
1640  left_j_global = l2g[left_eN_global*nDOF_trial_element+j];
1641  right_j_global= l2g[right_eN_global*nDOF_trial_element+j];
1642  for(I=0;I<nSpace;I++)
1643  {
1644  diffusiveVelocityComponent_I_leftJacobian=0.0;
1645  diffusiveVelocityComponent_I_leftJacobian2=0.0;
1646  diffusiveVelocityComponent_I_rightJacobian=0.0;
1647  diffusiveVelocityComponent_I_rightJacobian2=0.0;
1648  for(J=0;J<nSpace;J++)
1649  {
1650  diffusiveVelocityComponent_I_leftJacobian
1651  -=
1652  da[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1653  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1654  k*nSpace2+
1655  I*nSpace+
1656  J]
1657  *
1658  grad_phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1659  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1660  k*nSpace+
1661  J];
1662  diffusiveVelocityComponent_I_rightJacobian
1663  -=
1664  da[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1665  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1666  k*nSpace2+
1667  I*nSpace+
1668  J]
1669  *
1670  grad_phi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1671  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1672  k*nSpace+
1673  J];
1674  diffusiveVelocityComponent_I_leftJacobian2
1675  -=
1676  a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1677  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1678  k*nSpace2+
1679  I*nSpace+
1680  J]
1681  *
1682  grad_v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1683  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1684  k*nDOF_trial_element*nSpace+
1685  j*nSpace+
1686  J];
1687  diffusiveVelocityComponent_I_rightJacobian2
1688  -=
1689  a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1690  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1691  k*nSpace2+
1692  I*nSpace+
1693  J]
1694  *
1695  grad_v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1696  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1697  k*nDOF_trial_element*nSpace+
1698  j*nSpace+
1699  J];
1700 
1701  }
1702  leftJacobian
1703  +=
1704  (diffusiveVelocityComponent_I_leftJacobian
1705  *
1706  v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1707  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1708  k*nDOF_trial_element+
1709  j]
1710  +
1711  diffusiveVelocityComponent_I_leftJacobian2*
1712  dphi[left_j_global])
1713  *
1714  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1715  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1716  k*nSpace+
1717  I];
1718  rightJacobian
1719  +=
1720  (diffusiveVelocityComponent_I_rightJacobian
1721  *
1722  v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1723  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1724  k*nDOF_trial_element+
1725  j]
1726  +
1727  diffusiveVelocityComponent_I_rightJacobian2*dphi[right_j_global])
1728  *
1729  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1730  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1731  k*nSpace+
1732  I];
1733  }
1734  leftJacobian *= 0.5;
1735  rightJacobian *= 0.5;
1736  leftJacobian
1737  +=
1738  penalty[ebN*nQuadraturePoints_elementBoundary+
1739  k]
1740  *
1741  v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1742  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1743  k*nDOF_trial_element+
1744  j];
1745  rightJacobian
1746  -=
1747  penalty[ebN*nQuadraturePoints_elementBoundary+
1748  k]
1749  *
1750  v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1751  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1752  k*nDOF_trial_element+
1753  j];
1754  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1755  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1756  k*nDOF_trial_element+
1757  j] += leftJacobian;
1758  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1759  1*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1760  k*nDOF_trial_element+
1761  j] += rightJacobian;
1762  }
1763  }
1764  }
1765 }
1766 
1767 void updateInteriorNumericalDiffusiveFluxJacobian_sd(int nInteriorElementBoundaries_global,
1768  int nElementBoundaries_element,
1769  int nQuadraturePoints_elementBoundary,
1770  int nDOF_trial_element,
1771  int nSpace,
1772  int* rowptr,
1773  int* colind,
1774  int* l2g,
1775  int* interiorElementBoundaries,
1776  int* elementBoundaryElements,
1777  int* elementBoundaryLocalElementBoundaries,
1778  double* n,
1779  double* a,
1780  double* da,
1781  double* grad_phi,
1782  double* dphi,
1783  double* v,
1784  double* grad_v,
1785  double* penalty,
1786  double* fluxJacobian)
1787 {
1788  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,j,left_j_global,right_j_global,I,m,nnz=rowptr[nSpace];
1789  double leftJacobian,rightJacobian,diffusiveVelocityComponent_I_leftJacobian,diffusiveVelocityComponent_I_rightJacobian,diffusiveVelocityComponent_I_leftJacobian2,diffusiveVelocityComponent_I_rightJacobian2;
1790  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
1791  {
1792  ebN = interiorElementBoundaries[ebNI];
1793  left_eN_global = elementBoundaryElements[ebN*2+0];
1794  right_eN_global = elementBoundaryElements[ebN*2+1];
1795  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
1796  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
1797  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
1798  {
1799  for(j=0;j<nDOF_trial_element;j++)
1800  {
1801  leftJacobian=0.0;
1802  rightJacobian=0.0;
1803  left_j_global = l2g[left_eN_global*nDOF_trial_element+j];
1804  right_j_global= l2g[right_eN_global*nDOF_trial_element+j];
1805  for(I=0;I<nSpace;I++)
1806  {
1807  diffusiveVelocityComponent_I_leftJacobian=0.0;
1808  diffusiveVelocityComponent_I_leftJacobian2=0.0;
1809  diffusiveVelocityComponent_I_rightJacobian=0.0;
1810  diffusiveVelocityComponent_I_rightJacobian2=0.0;
1811  for(m=rowptr[I];m<rowptr[I+1];m++)
1812  {
1813  diffusiveVelocityComponent_I_leftJacobian
1814  -=
1815  da[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1816  left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1817  k*nnz+
1818  m]
1819  *
1820  grad_phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1821  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1822  k*nSpace+
1823  colind[m]];
1824  diffusiveVelocityComponent_I_rightJacobian
1825  -=
1826  da[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1827  right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1828  k*nnz+
1829  m]
1830  *
1831  grad_phi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1832  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1833  k*nSpace+
1834  colind[m]];
1835  diffusiveVelocityComponent_I_leftJacobian2
1836  -=
1837  a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1838  left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1839  k*nnz+
1840  m]
1841  *
1842  grad_v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1843  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1844  k*nDOF_trial_element*nSpace+
1845  j*nSpace+
1846  colind[m]];
1847  diffusiveVelocityComponent_I_rightJacobian2
1848  -=
1849  a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
1850  right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
1851  k*nnz+
1852  m]
1853  *
1854  grad_v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1855  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
1856  k*nDOF_trial_element*nSpace+
1857  j*nSpace+
1858  colind[m]];
1859 
1860  }
1861  leftJacobian
1862  +=
1863  (diffusiveVelocityComponent_I_leftJacobian
1864  *
1865  v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1866  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1867  k*nDOF_trial_element+
1868  j]
1869  +
1870  diffusiveVelocityComponent_I_leftJacobian2*
1871  dphi[left_j_global])
1872  *
1873  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1874  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1875  k*nSpace+
1876  I];
1877  rightJacobian
1878  +=
1879  (diffusiveVelocityComponent_I_rightJacobian
1880  *
1881  v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1882  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1883  k*nDOF_trial_element+
1884  j]
1885  +
1886  diffusiveVelocityComponent_I_rightJacobian2*dphi[right_j_global])
1887  *
1888  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1889  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1890  k*nSpace+
1891  I];
1892  }
1893  leftJacobian *= 0.5;
1894  rightJacobian *= 0.5;
1895  leftJacobian
1896  +=
1897  penalty[ebN*nQuadraturePoints_elementBoundary+
1898  k]
1899  *
1900  v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1901  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1902  k*nDOF_trial_element+
1903  j];
1904  rightJacobian
1905  -=
1906  penalty[ebN*nQuadraturePoints_elementBoundary+
1907  k]
1908  *
1909  v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1910  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1911  k*nDOF_trial_element+
1912  j];
1913  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1914  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1915  k*nDOF_trial_element+
1916  j] += leftJacobian;
1917  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1918  1*nQuadraturePoints_elementBoundary*nDOF_trial_element+
1919  k*nDOF_trial_element+
1920  j] += rightJacobian;
1921  }
1922  }
1923  }
1924 }
1925 */
1926 
1930 void calculateExteriorNumericalDiffusiveFlux(int scale_penalty,
1931  double penalty_floor,
1932  int nExteriorElementBoundaries_global,
1933  int nElementBoundaries_element,
1934  int nQuadraturePoints_elementBoundary,
1935  int nSpace,
1936  int* exteriorElementBoundaries,
1937  int* elementBoundaryElements,
1938  int* elementBoundaryLocalElementBoundaries,
1939  int* isDOFBoundary,
1940  double* n,
1941  double* bc_a,
1942  double* bc_grad_phi,
1943  double* bc_u,
1944  double* a,
1945  double* grad_phi,
1946  double* u,
1947  double* penalty,
1948  double* flux)
1949 {
1950  int ebNE,ebN,eN_global,ebN_element,k,J,I,nSpace2=nSpace*nSpace;
1951  double diffusiveVelocityComponent_I,penaltyFlux,max_a=0.0;
1952  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
1953  {
1954  ebN = exteriorElementBoundaries[ebNE];
1955  eN_global = elementBoundaryElements[ebN*2+0];
1956  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
1957  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
1958  {
1959  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
1960  {
1961  max_a = 0.0;
1962  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;
1963  for(I=0;I<nSpace;I++)
1964  {
1965  diffusiveVelocityComponent_I=0.0;
1966  for(J=0;J<nSpace;J++)
1967  {
1968  diffusiveVelocityComponent_I
1969  -=
1970  a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1971  ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1972  k*nSpace2+
1973  I*nSpace+
1974  J]
1975  *
1976  grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1977  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1978  k*nSpace+J];
1979  max_a = fmax(max_a,a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
1980  ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
1981  k*nSpace2+
1982  I*nSpace+
1983  J]);
1984  }
1985  flux[ebN*nQuadraturePoints_elementBoundary+k]
1986  +=
1987  diffusiveVelocityComponent_I
1988  *
1989  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
1990  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
1991  k*nSpace+
1992  I];
1993  }
1994  max_a = fmax(penalty_floor,max_a);
1995  penaltyFlux = penalty[ebN*nQuadraturePoints_elementBoundary+
1996  k]
1997  *
1998  (u[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
1999  ebN_element*nQuadraturePoints_elementBoundary+
2000  k]
2001  -
2002  bc_u[ebNE*nQuadraturePoints_elementBoundary+
2003  k]);
2004  if (scale_penalty) penaltyFlux *= max_a;
2005  flux[ebN*nQuadraturePoints_elementBoundary+k] += penaltyFlux;
2006  }
2007  }
2008  }
2009 }
2010 void calculateExteriorNumericalDiffusiveFlux_sd(int scale_penalty,
2011  double penalty_floor,
2012  int nExteriorElementBoundaries_global,
2013  int nElementBoundaries_element,
2014  int nQuadraturePoints_elementBoundary,
2015  int nSpace,
2016  int* rowptr,
2017  int* colind,
2018  int* exteriorElementBoundaries,
2019  int* elementBoundaryElements,
2020  int* elementBoundaryLocalElementBoundaries,
2021  int* isDOFBoundary,
2022  double* n,
2023  double* bc_a,
2024  double* bc_grad_phi,
2025  double* bc_u,
2026  double* a,
2027  double* grad_phi,
2028  double* u,
2029  double* penalty,
2030  double* flux)
2031 {
2032  int ebNE,ebN,eN_global,ebN_element,k,I,m,nnz=rowptr[nSpace];
2033  double diffusiveVelocityComponent_I,penaltyFlux,max_a=0.0;
2034  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2035  {
2036  ebN = exteriorElementBoundaries[ebNE];
2037  eN_global = elementBoundaryElements[ebN*2+0];
2038  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
2039  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2040  {
2041  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;//cek initializing to zero, hack, need to warn user if diffusion with no Dirichlet or Neumann condition
2042  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
2043  {
2044  max_a = 0.0;
2045  for(I=0;I<nSpace;I++)
2046  {
2047  diffusiveVelocityComponent_I=0.0;
2048  for(m=rowptr[I];m<rowptr[I+1];m++)
2049  {
2050  diffusiveVelocityComponent_I
2051  -=
2052  a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
2053  ebN_element*nQuadraturePoints_elementBoundary*nnz+
2054  k*nnz+
2055  m]
2056  *
2057  grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2058  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2059  k*nSpace+colind[m]];
2060  max_a = fmax(max_a,a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
2061  ebN_element*nQuadraturePoints_elementBoundary*nnz+
2062  k*nnz+
2063  m]);
2064  }
2065  flux[ebN*nQuadraturePoints_elementBoundary+k]
2066  +=
2067  diffusiveVelocityComponent_I
2068  *
2069  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2070  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2071  k*nSpace+
2072  I];
2073  }
2074  max_a = fmax(penalty_floor,max_a);
2075  penaltyFlux = penalty[ebN*nQuadraturePoints_elementBoundary+
2076  k]
2077  *
2078  (u[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
2079  ebN_element*nQuadraturePoints_elementBoundary+
2080  k]
2081  -
2082  bc_u[ebNE*nQuadraturePoints_elementBoundary+
2083  k]);
2084  if (scale_penalty) penaltyFlux *= max_a;
2085  flux[ebN*nQuadraturePoints_elementBoundary+k] += penaltyFlux;
2086  }
2087  }
2088  }
2089 }
2093 void calculateGlobalExteriorNumericalDiffusiveFlux(int scale_penalty,
2094  double penalty_floor,
2095  int nExteriorElementBoundaries_global,
2096  int nQuadraturePoints_elementBoundary,
2097  int nSpace,
2098  int* exteriorElementBoundaries,
2099  int* elementBoundaryElements,
2100  int* elementBoundaryLocalElementBoundaries,
2101  int* isDOFBoundary,
2102  double* n,
2103  double* bc_a,
2104  double* bc_grad_phi,
2105  double* bc_u,
2106  double* a,
2107  double* grad_phi,
2108  double* u,
2109  double* penalty,
2110  double* flux)
2111 {
2112  int ebNE,k,J,I,nSpace2=nSpace*nSpace;
2113  double diffusiveVelocityComponent_I,penaltyFlux,max_a=0.0;
2114  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2115  {
2116  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2117  {
2118  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
2119  {
2120  flux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.0;
2121  max_a=0.0;
2122  for(I=0;I<nSpace;I++)
2123  {
2124  diffusiveVelocityComponent_I=0.0;
2125  for(J=0;J<nSpace;J++)
2126  {
2127  diffusiveVelocityComponent_I
2128  -=
2129  a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
2130  k*nSpace2+
2131  I*nSpace+
2132  J]
2133  *
2134  grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
2135  k*nSpace+J];
2136  max_a = fmax(max_a,a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
2137  k*nSpace2+
2138  I*nSpace+
2139  J]);
2140  }
2141  flux[ebNE*nQuadraturePoints_elementBoundary+k]
2142  +=
2143  diffusiveVelocityComponent_I
2144  *
2145  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
2146  k*nSpace+
2147  I];
2148  }
2149  max_a = fmax(max_a,penalty_floor);
2150  penaltyFlux = penalty[ebNE*nQuadraturePoints_elementBoundary+
2151  k]
2152  *
2153  (u[ebNE*nQuadraturePoints_elementBoundary+
2154  k]
2155  -
2156  bc_u[ebNE*nQuadraturePoints_elementBoundary+
2157  k]);
2158  if (scale_penalty) penaltyFlux *= max_a;
2159  flux[ebNE*nQuadraturePoints_elementBoundary+k] += penaltyFlux;
2160  }
2161  }
2162  }
2163 }
2164 
2165 void calculateGlobalExteriorNumericalDiffusiveFlux_sd(int scale_penalty,
2166  double penalty_floor,
2167  int nExteriorElementBoundaries_global,
2168  int nQuadraturePoints_elementBoundary,
2169  int nSpace,
2170  int* rowptr,
2171  int* colind,
2172  int* exteriorElementBoundaries,
2173  int* elementBoundaryElements,
2174  int* elementBoundaryLocalElementBoundaries,
2175  int* isDOFBoundary,
2176  double* n,
2177  double* bc_a,
2178  double* bc_grad_phi,
2179  double* bc_u,
2180  double* a,
2181  double* grad_phi,
2182  double* u,
2183  double* penalty,
2184  double* flux)
2185 {
2186  int ebNE,k,I,m,nnz=rowptr[nSpace];
2187  double diffusiveVelocityComponent_I,penaltyFlux,max_a;
2188  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2189  {
2190  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2191  {
2192  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
2193  {
2194  flux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.0;
2195  max_a=0.0;
2196  for(I=0;I<nSpace;I++)
2197  {
2198  diffusiveVelocityComponent_I=0.0;
2199  for(m=rowptr[I];m<rowptr[I+1];m++)
2200  {
2201  diffusiveVelocityComponent_I
2202  -=
2203  a[ebNE*nQuadraturePoints_elementBoundary*nnz+
2204  k*nnz+
2205  m]
2206  *
2207  grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
2208  k*nSpace+colind[m]];
2209  max_a = fmax(max_a,a[ebNE*nQuadraturePoints_elementBoundary*nnz+
2210  k*nnz+
2211  m]);
2212  }
2213  flux[ebNE*nQuadraturePoints_elementBoundary+k]
2214  +=
2215  diffusiveVelocityComponent_I
2216  *
2217  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
2218  k*nSpace+
2219  I];
2220  }
2221  max_a = fmax(penalty_floor,max_a);
2222  penaltyFlux = penalty[ebNE*nQuadraturePoints_elementBoundary+
2223  k]
2224  *
2225  (u[ebNE*nQuadraturePoints_elementBoundary+
2226  k]
2227  -
2228  bc_u[ebNE*nQuadraturePoints_elementBoundary+
2229  k]);
2230 
2231  if (scale_penalty) penaltyFlux *= max_a;
2232  flux[ebNE*nQuadraturePoints_elementBoundary+k] += penaltyFlux;
2233  }
2234  }
2235  }
2236 }
2237 
2238 
2239 /*
2240  \brief Calculate the diffusive flux at exterior element boundary quadrature points
2241 
2242 void calculateExteriorNumericalDiffusiveFlux(int nExteriorElementBoundaries_global,
2243  int nElementBoundaries_element,
2244  int nQuadraturePoints_elementBoundary,
2245  int nSpace,
2246  int* exteriorElementBoundaries,
2247  int* elementBoundaryElements,
2248  int* elementBoundaryLocalElementBoundaries,
2249  int* isDOFBoundary,
2250  double* n,
2251  double* bc_a,
2252  double* bc_grad_phi,
2253  double* bc_u,
2254  double* a,
2255  double* grad_phi,
2256  double* u,
2257  double* penalty,
2258  double* flux)
2259 {
2260  int ebNE,ebN,eN_global,ebN_element,k,J,I,nSpace2=nSpace*nSpace;
2261  double diffusiveVelocityComponent_I,penaltyFlux;
2262  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2263  {
2264  ebN = exteriorElementBoundaries[ebNE];
2265  eN_global = elementBoundaryElements[ebN*2+0];
2266  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
2267  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2268  {
2269  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
2270  {
2271  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;
2272  for(I=0;I<nSpace;I++)
2273  {
2274  diffusiveVelocityComponent_I=0.0;
2275  for(J=0;J<nSpace;J++)
2276  {
2277  diffusiveVelocityComponent_I
2278  -=
2279  a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
2280  ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
2281  k*nSpace2+
2282  I*nSpace+
2283  J]
2284  *
2285  grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2286  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2287  k*nSpace+J];
2288  }
2289  flux[ebN*nQuadraturePoints_elementBoundary+k]
2290  +=
2291  diffusiveVelocityComponent_I
2292  *
2293  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2294  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2295  k*nSpace+
2296  I];
2297  }
2298  penaltyFlux = penalty[ebN*nQuadraturePoints_elementBoundary+
2299  k]
2300  *
2301  (u[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
2302  ebN_element*nQuadraturePoints_elementBoundary+
2303  k]
2304  -
2305  bc_u[ebNE*nQuadraturePoints_elementBoundary+
2306  k]);
2307  flux[ebN*nQuadraturePoints_elementBoundary+k] += penaltyFlux;
2308  }
2309  }
2310  }
2311 }
2312 void calculateExteriorNumericalDiffusiveFlux_sd(int nExteriorElementBoundaries_global,
2313  int nElementBoundaries_element,
2314  int nQuadraturePoints_elementBoundary,
2315  int nSpace,
2316  int* rowptr,
2317  int* colind,
2318  int* exteriorElementBoundaries,
2319  int* elementBoundaryElements,
2320  int* elementBoundaryLocalElementBoundaries,
2321  int* isDOFBoundary,
2322  double* n,
2323  double* bc_a,
2324  double* bc_grad_phi,
2325  double* bc_u,
2326  double* a,
2327  double* grad_phi,
2328  double* u,
2329  double* penalty,
2330  double* flux)
2331 {
2332  int ebNE,ebN,eN_global,ebN_element,k,I,m,nnz=rowptr[nSpace];
2333  double diffusiveVelocityComponent_I,penaltyFlux;
2334  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2335  {
2336  ebN = exteriorElementBoundaries[ebNE];
2337  eN_global = elementBoundaryElements[ebN*2+0];
2338  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
2339  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2340  {
2341  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;//cek initializing to zero, hack, need to warn user if diffusion with no Dirichlet or Neumann condition
2342  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
2343  {
2344  for(I=0;I<nSpace;I++)
2345  {
2346  diffusiveVelocityComponent_I=0.0;
2347  for(m=rowptr[I];m<rowptr[I+1];m++)
2348  {
2349  diffusiveVelocityComponent_I
2350  -=
2351  a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
2352  ebN_element*nQuadraturePoints_elementBoundary*nnz+
2353  k*nnz+
2354  m]
2355  *
2356  grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2357  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2358  k*nSpace+colind[m]];
2359  }
2360  flux[ebN*nQuadraturePoints_elementBoundary+k]
2361  +=
2362  diffusiveVelocityComponent_I
2363  *
2364  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2365  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2366  k*nSpace+
2367  I];
2368  }
2369  penaltyFlux = penalty[ebN*nQuadraturePoints_elementBoundary+
2370  k]
2371  *
2372  (u[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
2373  ebN_element*nQuadraturePoints_elementBoundary+
2374  k]
2375  -
2376  bc_u[ebNE*nQuadraturePoints_elementBoundary+
2377  k]);
2378  flux[ebN*nQuadraturePoints_elementBoundary+k] += penaltyFlux;
2379  }
2380  }
2381  }
2382 } */
2383 /*
2384  \brief Calculate the diffusive flux at exterior element boundary quadrature points
2385 
2386 void calculateGlobalExteriorNumericalDiffusiveFlux(int nExteriorElementBoundaries_global,
2387  int nQuadraturePoints_elementBoundary,
2388  int nSpace,
2389  int* exteriorElementBoundaries,
2390  int* elementBoundaryElements,
2391  int* elementBoundaryLocalElementBoundaries,
2392  int* isDOFBoundary,
2393  double* n,
2394  double* bc_a,
2395  double* bc_grad_phi,
2396  double* bc_u,
2397  double* a,
2398  double* grad_phi,
2399  double* u,
2400  double* penalty,
2401  double* flux)
2402 {
2403  int ebNE,k,J,I,nSpace2=nSpace*nSpace;
2404  double diffusiveVelocityComponent_I,penaltyFlux,max_a;
2405  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2406  {
2407  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2408  {
2409  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
2410  {
2411  flux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.0;
2412  max_a=0.0;
2413  for(I=0;I<nSpace;I++)
2414  {
2415  diffusiveVelocityComponent_I=0.0;
2416  for(J=0;J<nSpace;J++)
2417  {
2418  diffusiveVelocityComponent_I
2419  -=
2420  a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
2421  k*nSpace2+
2422  I*nSpace+
2423  J]
2424  *
2425  grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
2426  k*nSpace+J];
2427  max_a = fmax(max_a,a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
2428  k*nSpace2+
2429  I*nSpace+
2430  J]);
2431  }
2432  flux[ebNE*nQuadraturePoints_elementBoundary+k]
2433  +=
2434  diffusiveVelocityComponent_I
2435  *
2436  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
2437  k*nSpace+
2438  I];
2439  }
2440  penaltyFlux = penalty[ebNE*nQuadraturePoints_elementBoundary+
2441  k]
2442  *
2443  (u[ebNE*nQuadraturePoints_elementBoundary+
2444  k]
2445  -
2446  bc_u[ebNE*nQuadraturePoints_elementBoundary+
2447  k]);
2448  flux[ebNE*nQuadraturePoints_elementBoundary+k] += penaltyFlux;
2449  }
2450  }
2451  }
2452 }
2453 
2454 void calculateGlobalExteriorNumericalDiffusiveFlux_sd(int nExteriorElementBoundaries_global,
2455  int nQuadraturePoints_elementBoundary,
2456  int nSpace,
2457  int* rowptr,
2458  int* colind,
2459  int* exteriorElementBoundaries,
2460  int* elementBoundaryElements,
2461  int* elementBoundaryLocalElementBoundaries,
2462  int* isDOFBoundary,
2463  double* n,
2464  double* bc_a,
2465  double* bc_grad_phi,
2466  double* bc_u,
2467  double* a,
2468  double* grad_phi,
2469  double* u,
2470  double* penalty,
2471  double* flux)
2472 {
2473  int ebNE,k,I,m,nnz=rowptr[nSpace];
2474  double diffusiveVelocityComponent_I,penaltyFlux,max_a;
2475  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2476  {
2477  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2478  {
2479  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
2480  {
2481  flux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.0;
2482  max_a=0.0;
2483  for(I=0;I<nSpace;I++)
2484  {
2485  diffusiveVelocityComponent_I=0.0;
2486  for(m=rowptr[I];m<rowptr[I+1];m++)
2487  {
2488  diffusiveVelocityComponent_I
2489  -=
2490  a[ebNE*nQuadraturePoints_elementBoundary*nnz+
2491  k*nnz+
2492  m]
2493  *
2494  grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
2495  k*nSpace+colind[m]];
2496  max_a = fmax(max_a,a[ebNE*nQuadraturePoints_elementBoundary*nnz+
2497  k*nnz+
2498  m]);
2499  }
2500  flux[ebNE*nQuadraturePoints_elementBoundary+k]
2501  +=
2502  diffusiveVelocityComponent_I
2503  *
2504  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
2505  k*nSpace+
2506  I];
2507  }
2508  penaltyFlux = penalty[ebNE*nQuadraturePoints_elementBoundary+
2509  k]
2510  *
2511  (u[ebNE*nQuadraturePoints_elementBoundary+
2512  k]
2513  -
2514  bc_u[ebNE*nQuadraturePoints_elementBoundary+
2515  k]);
2516  flux[ebNE*nQuadraturePoints_elementBoundary+k] += penaltyFlux;
2517  }
2518  }
2519  }
2520 }
2521 */
2522 
2523 void calculateExteriorNumericalDiffusiveFlux_free(int nExteriorElementBoundaries_global,
2524  int nElementBoundaries_element,
2525  int nQuadraturePoints_elementBoundary,
2526  int nSpace,
2527  int* exteriorElementBoundaries,
2528  int* elementBoundaryElements,
2529  int* elementBoundaryLocalElementBoundaries,
2530  int* isDOFBoundary,
2531  double* n,
2532  double* bc_a,
2533  double* bc_grad_phi,
2534  double* bc_u,
2535  double* a,
2536  double* grad_phi,
2537  double* u,
2538  double* penalty,
2539  double* flux)
2540 {
2541  int ebNE,ebN,eN_global,ebN_element,k,J,I,nSpace2=nSpace*nSpace;
2542  double diffusiveVelocityComponent_I;
2543  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2544  {
2545  ebN = exteriorElementBoundaries[ebNE];
2546  eN_global = elementBoundaryElements[ebN*2+0];
2547  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
2548  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2549  {
2550  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;
2551  for(I=0;I<nSpace;I++)
2552  {
2553  diffusiveVelocityComponent_I=0.0;
2554  for(J=0;J<nSpace;J++)
2555  {
2556  diffusiveVelocityComponent_I
2557  -=
2558  a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
2559  ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
2560  k*nSpace2+
2561  I*nSpace+
2562  J]
2563  *
2564  grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2565  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2566  k*nSpace+J];
2567  }
2568  flux[ebN*nQuadraturePoints_elementBoundary+k]
2569  +=
2570  diffusiveVelocityComponent_I
2571  *
2572  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2573  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2574  k*nSpace+
2575  I];
2576  }
2577  }
2578  }
2579 }
2580 void calculateExteriorNumericalDiffusiveFlux_free_sd(int nExteriorElementBoundaries_global,
2581  int nElementBoundaries_element,
2582  int nQuadraturePoints_elementBoundary,
2583  int nSpace,
2584  int* rowptr,
2585  int* colind,
2586  int* exteriorElementBoundaries,
2587  int* elementBoundaryElements,
2588  int* elementBoundaryLocalElementBoundaries,
2589  int* isDOFBoundary,
2590  double* n,
2591  double* bc_a,
2592  double* bc_grad_phi,
2593  double* bc_u,
2594  double* a,
2595  double* grad_phi,
2596  double* u,
2597  double* penalty,
2598  double* flux)
2599 {
2600  int ebNE,ebN,eN_global,ebN_element,k,I,m,nnz=rowptr[nSpace];
2601  double diffusiveVelocityComponent_I;
2602  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2603  {
2604  ebN = exteriorElementBoundaries[ebNE];
2605  eN_global = elementBoundaryElements[ebN*2+0];
2606  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
2607  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2608  {
2609  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;
2610  for(I=0;I<nSpace;I++)
2611  {
2612  diffusiveVelocityComponent_I=0.0;
2613  for(m=rowptr[I];m<rowptr[I+1];m++)
2614  {
2615  diffusiveVelocityComponent_I
2616  -=
2617  a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
2618  ebN_element*nQuadraturePoints_elementBoundary*nnz+
2619  k*nnz+
2620  m]
2621  *
2622  grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2623  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2624  k*nSpace+colind[m]];
2625  }
2626  flux[ebN*nQuadraturePoints_elementBoundary+k]
2627  +=
2628  diffusiveVelocityComponent_I
2629  *
2630  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2631  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2632  k*nSpace+
2633  I];
2634  }
2635  }
2636  }
2637 }
2638 void calculateGlobalExteriorNumericalDiffusiveFlux_free(int nExteriorElementBoundaries_global,
2639  int nQuadraturePoints_elementBoundary,
2640  int nSpace,
2641  int* exteriorElementBoundaries,
2642  int* elementBoundaryElements,
2643  int* elementBoundaryLocalElementBoundaries,
2644  int* isDOFBoundary,
2645  double* n,
2646  double* bc_a,
2647  double* bc_grad_phi,
2648  double* bc_u,
2649  double* a,
2650  double* grad_phi,
2651  double* u,
2652  double* penalty,
2653  double* flux)
2654 {
2655  int ebNE,k,J,I,nSpace2=nSpace*nSpace;
2656  double diffusiveVelocityComponent_I;
2657  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2658  {
2659  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2660  {
2661  flux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.0;
2662  for(I=0;I<nSpace;I++)
2663  {
2664  diffusiveVelocityComponent_I=0.0;
2665  for(J=0;J<nSpace;J++)
2666  {
2667  diffusiveVelocityComponent_I
2668  -=
2669  a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
2670  k*nSpace2+
2671  I*nSpace+
2672  J]
2673  *
2674  grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
2675  k*nSpace+J];
2676  }
2677  flux[ebNE*nQuadraturePoints_elementBoundary+k]
2678  +=
2679  diffusiveVelocityComponent_I
2680  *
2681  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
2682  k*nSpace+
2683  I];
2684  }
2685  }
2686  }
2687 }
2688 void calculateGlobalExteriorNumericalDiffusiveFlux_free_sd(int nExteriorElementBoundaries_global,
2689  int nQuadraturePoints_elementBoundary,
2690  int nSpace,
2691  int* rowptr,
2692  int* colind,
2693  int* exteriorElementBoundaries,
2694  int* elementBoundaryElements,
2695  int* elementBoundaryLocalElementBoundaries,
2696  int* isDOFBoundary,
2697  double* n,
2698  double* bc_a,
2699  double* bc_grad_phi,
2700  double* bc_u,
2701  double* a,
2702  double* grad_phi,
2703  double* u,
2704  double* penalty,
2705  double* flux)
2706 {
2707  int ebNE,k,I,m,nnz=rowptr[nSpace];
2708  double diffusiveVelocityComponent_I;
2709  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2710  {
2711  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2712  {
2713  flux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.0;
2714  for(I=0;I<nSpace;I++)
2715  {
2716  diffusiveVelocityComponent_I=0.0;
2717  for(m=rowptr[I];m<rowptr[I+1];m++)
2718  {
2719  diffusiveVelocityComponent_I
2720  -=
2721  a[ebNE*nQuadraturePoints_elementBoundary*nnz+
2722  k*nnz+
2723  m]
2724  *
2725  grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
2726  k*nSpace+colind[m]];
2727  }
2728  flux[ebNE*nQuadraturePoints_elementBoundary+k]
2729  +=
2730  diffusiveVelocityComponent_I
2731  *
2732  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
2733  k*nSpace+
2734  I];
2735  }
2736  }
2737  }
2738 }
2739 
2743 void updateExteriorNumericalDiffusiveFluxJacobian(int scale_penalty,
2744  double penalty_floor,
2745  int nExteriorElementBoundaries_global,
2746  int nElementBoundaries_element,
2747  int nQuadraturePoints_elementBoundary,
2748  int nDOF_trial_element,
2749  int nSpace,
2750  int* l2g,
2751  int* exteriorElementBoundaries,
2752  int* elementBoundaryElements,
2753  int* elementBoundaryLocalElementBoundaries,
2754  int* isDOFBoundary,
2755  double* n,
2756  double* a,
2757  double* da,
2758  double* grad_phi,
2759  double* dphi,
2760  double* v,
2761  double* grad_v,
2762  double* penalty,
2763  double* fluxJacobian)
2764 {
2765  int ebNE,ebN,eN_global,ebN_element,k,j,j_global,I,J,nSpace2=nSpace*nSpace;
2766  double Jacobian,diffusiveVelocityComponent_I_Jacobian,diffusiveVelocityComponent_I_Jacobian2,max_a=0.0;
2767  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2768  {
2769  ebN = exteriorElementBoundaries[ebNE];
2770  eN_global = elementBoundaryElements[ebN*2+0];
2771  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
2772  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2773  {
2774  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
2775  {
2776  max_a = 0.0;
2777  for(j=0;j<nDOF_trial_element;j++)
2778  {
2779  Jacobian=0.0;
2780  j_global = l2g[eN_global*nDOF_trial_element+j];
2781  for(I=0;I<nSpace;I++)
2782  {
2783  diffusiveVelocityComponent_I_Jacobian=0.0;
2784  diffusiveVelocityComponent_I_Jacobian2=0.0;
2785  for(J=0;J<nSpace;J++)
2786  {
2787  diffusiveVelocityComponent_I_Jacobian
2788  -=
2789  da[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
2790  ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
2791  k*nSpace2+
2792  I*nSpace+
2793  J]
2794  *
2795  grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2796  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2797  k*nSpace+
2798  J];
2799  diffusiveVelocityComponent_I_Jacobian2
2800  -=
2801  a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
2802  ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
2803  k*nSpace2+
2804  I*nSpace+
2805  J]
2806  *
2807  grad_v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
2808  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
2809  k*nDOF_trial_element*nSpace+
2810  j*nSpace+
2811  J];
2812  max_a = fmax(max_a,a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
2813  ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
2814  k*nSpace2+
2815  I*nSpace+
2816  J]);
2817  }
2818  Jacobian
2819  +=
2820  (diffusiveVelocityComponent_I_Jacobian
2821  *
2822  v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
2823  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
2824  k*nDOF_trial_element+
2825  j]
2826  +
2827  diffusiveVelocityComponent_I_Jacobian2*
2828  dphi[j_global])
2829  *
2830  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2831  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2832  k*nSpace+
2833  I];
2834  }
2835  max_a = fmax(penalty_floor,max_a);
2836  double penaltyJacobian = penalty[ebN*nQuadraturePoints_elementBoundary+
2837  k]
2838  *
2839  v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
2840  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
2841  k*nDOF_trial_element+
2842  j];
2843  if (scale_penalty) penaltyJacobian *= max_a;
2844  Jacobian += penaltyJacobian;
2845  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
2846  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
2847  k*nDOF_trial_element+
2848  j]
2849  += Jacobian;
2850  }
2851  }
2852  }
2853  }
2854 }
2855 
2856 void updateExteriorNumericalDiffusiveFluxJacobian_sd(int scale_penalty,
2857  double penalty_floor,
2858  int nExteriorElementBoundaries_global,
2859  int nElementBoundaries_element,
2860  int nQuadraturePoints_elementBoundary,
2861  int nDOF_trial_element,
2862  int nSpace,
2863  int* rowptr,
2864  int* colind,
2865  int* l2g,
2866  int* exteriorElementBoundaries,
2867  int* elementBoundaryElements,
2868  int* elementBoundaryLocalElementBoundaries,
2869  int* isDOFBoundary,
2870  double* n,
2871  double* a,
2872  double* da,
2873  double* grad_phi,
2874  double* dphi,
2875  double* v,
2876  double* grad_v,
2877  double* penalty,
2878  double* fluxJacobian)
2879 {
2880  int ebNE,ebN,eN_global,ebN_element,k,j,j_global,I,m,nnz=rowptr[nSpace];
2881  double Jacobian,diffusiveVelocityComponent_I_Jacobian,diffusiveVelocityComponent_I_Jacobian2,max_a=0.0;
2882  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2883  {
2884  ebN = exteriorElementBoundaries[ebNE];
2885  eN_global = elementBoundaryElements[ebN*2+0];
2886  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
2887  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
2888  {
2889  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
2890  {
2891  max_a=0.0;
2892  for(j=0;j<nDOF_trial_element;j++)
2893  {
2894  Jacobian=0.0;
2895  j_global = l2g[eN_global*nDOF_trial_element+j];
2896  for(I=0;I<nSpace;I++)
2897  {
2898  diffusiveVelocityComponent_I_Jacobian=0.0;
2899  diffusiveVelocityComponent_I_Jacobian2=0.0;
2900  for(m=rowptr[I];m<rowptr[I+1];m++)
2901  {
2902  diffusiveVelocityComponent_I_Jacobian
2903  -=
2904  da[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
2905  ebN_element*nQuadraturePoints_elementBoundary*nnz+
2906  k*nnz+
2907  m]
2908  *
2909  grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2910  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2911  k*nSpace+
2912  colind[m]];
2913  diffusiveVelocityComponent_I_Jacobian2
2914  -=
2915  a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
2916  ebN_element*nQuadraturePoints_elementBoundary*nnz+
2917  k*nnz+
2918  m]
2919  *
2920  grad_v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
2921  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
2922  k*nDOF_trial_element*nSpace+
2923  j*nSpace+
2924  colind[m]];
2925  max_a = fmax(max_a,a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
2926  ebN_element*nQuadraturePoints_elementBoundary*nnz+
2927  k*nnz+
2928  m]);
2929  }
2930  Jacobian
2931  +=
2932  (diffusiveVelocityComponent_I_Jacobian
2933  *
2934  v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
2935  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
2936  k*nDOF_trial_element+
2937  j]
2938  +
2939  diffusiveVelocityComponent_I_Jacobian2*
2940  dphi[j_global])
2941  *
2942  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
2943  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
2944  k*nSpace+
2945  I];
2946  }
2947  max_a = fmax(penalty_floor,max_a);
2948  double penaltyJacobian = penalty[ebN*nQuadraturePoints_elementBoundary+
2949  k]
2950  *
2951  v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
2952  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
2953  k*nDOF_trial_element+
2954  j];
2955 
2956  if (scale_penalty) penaltyJacobian *= max_a;
2957 
2958  Jacobian += penaltyJacobian;
2959 
2960  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
2961  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
2962  k*nDOF_trial_element+
2963  j]
2964  += Jacobian;
2965  }
2966  }
2967  }
2968  }
2969 }
2973 void updateGlobalExteriorNumericalDiffusiveFluxJacobian(int scale_penalty,
2974  double penalty_floor,
2975  int nExteriorElementBoundaries_global,
2976  int nQuadraturePoints_elementBoundary,
2977  int nDOF_trial_element,
2978  int nSpace,
2979  int* l2g,
2980  int* exteriorElementBoundaries,
2981  int* elementBoundaryElements,
2982  int* elementBoundaryLocalElementBoundaries,
2983  int* isDOFBoundary,
2984  double* n,
2985  double* a,
2986  double* da,
2987  double* grad_phi,
2988  double* dphi,
2989  double* v,
2990  double* grad_v,
2991  double* penalty,
2992  double* fluxJacobian)
2993 {
2994  int ebNE,ebN,eN_global,k,j,j_global,I,J,nSpace2=nSpace*nSpace;
2995  double Jacobian,diffusiveVelocityComponent_I_Jacobian,diffusiveVelocityComponent_I_Jacobian2,max_a;
2996  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
2997  {
2998  ebN = exteriorElementBoundaries[ebNE];
2999  eN_global = elementBoundaryElements[ebN*2+0];
3000  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
3001  {
3002  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] >= 1)
3003  {
3004  for(j=0;j<nDOF_trial_element;j++)
3005  {
3006  Jacobian=0.0;
3007  j_global = l2g[eN_global*nDOF_trial_element+j];
3008  max_a=0.0;
3009  for(I=0;I<nSpace;I++)
3010  {
3011  diffusiveVelocityComponent_I_Jacobian=0.0;
3012  diffusiveVelocityComponent_I_Jacobian2=0.0;
3013  for(J=0;J<nSpace;J++)
3014  {
3015  diffusiveVelocityComponent_I_Jacobian
3016  -=
3017  da[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
3018  k*nSpace2+
3019  I*nSpace+
3020  J]
3021  *
3022  grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
3023  k*nSpace+
3024  J];
3025  diffusiveVelocityComponent_I_Jacobian2
3026  -=
3027  a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
3028  k*nSpace2+
3029  I*nSpace+
3030  J]
3031  *
3032  grad_v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3033  k*nDOF_trial_element*nSpace+
3034  j*nSpace+
3035  J];
3036  max_a = fmax(max_a,a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
3037  k*nSpace2+
3038  I*nSpace+
3039  J]);
3040 
3041  }
3042  Jacobian
3043  +=
3044  (diffusiveVelocityComponent_I_Jacobian
3045  *
3046  v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3047  k*nDOF_trial_element+
3048  j]
3049  +
3050  diffusiveVelocityComponent_I_Jacobian2*
3051  dphi[j_global])
3052  *
3053  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
3054  k*nSpace+
3055  I];
3056  }
3057  max_a = fmax(penalty_floor,max_a);
3058  double penaltyJacobian = penalty[ebNE*nQuadraturePoints_elementBoundary+
3059  k]
3060  *
3061  v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3062  k*nDOF_trial_element+
3063  j];
3064  if (scale_penalty) penaltyJacobian *= max_a;
3065 
3066  Jacobian += penaltyJacobian;
3067 
3068  fluxJacobian[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3069  k*nDOF_trial_element+
3070  j]
3071  += Jacobian;
3072  }
3073  }
3074  }
3075  }
3076 }
3077 void updateGlobalExteriorNumericalDiffusiveFluxJacobian_sd(int scale_penalty,
3078  double penalty_floor,
3079  int nExteriorElementBoundaries_global,
3080  int nQuadraturePoints_elementBoundary,
3081  int nDOF_trial_element,
3082  int nSpace,
3083  int* rowptr,
3084  int* colind,
3085  int* l2g,
3086  int* exteriorElementBoundaries,
3087  int* elementBoundaryElements,
3088  int* elementBoundaryLocalElementBoundaries,
3089  int* isDOFBoundary,
3090  double* n,
3091  double* a,
3092  double* da,
3093  double* grad_phi,
3094  double* dphi,
3095  double* v,
3096  double* grad_v,
3097  double* penalty,
3098  double* fluxJacobian)
3099 {
3100  int ebNE,ebN,eN_global,k,j,j_global,I,m,nnz=rowptr[nSpace];
3101  double Jacobian,diffusiveVelocityComponent_I_Jacobian,diffusiveVelocityComponent_I_Jacobian2,max_a;
3102  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
3103  {
3104  ebN = exteriorElementBoundaries[ebNE];
3105  eN_global = elementBoundaryElements[ebN*2+0];
3106  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
3107  {
3108  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] >= 1)
3109  {
3110  for(j=0;j<nDOF_trial_element;j++)
3111  {
3112  Jacobian=0.0;
3113  j_global = l2g[eN_global*nDOF_trial_element+j];
3114  max_a=0.0;
3115  for(I=0;I<nSpace;I++)
3116  {
3117  diffusiveVelocityComponent_I_Jacobian=0.0;
3118  diffusiveVelocityComponent_I_Jacobian2=0.0;
3119  for(m=rowptr[I];m<rowptr[I+1];m++)
3120  {
3121  diffusiveVelocityComponent_I_Jacobian
3122  -=
3123  da[ebNE*nQuadraturePoints_elementBoundary*nnz+
3124  k*nnz+
3125  m]
3126  *
3127  grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
3128  k*nSpace+
3129  colind[m]];
3130  diffusiveVelocityComponent_I_Jacobian2
3131  -=
3132  a[ebNE*nQuadraturePoints_elementBoundary*nnz+
3133  k*nnz+
3134  m]
3135  *
3136  grad_v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3137  k*nDOF_trial_element*nSpace+
3138  j*nSpace+
3139  colind[m]];
3140  max_a = fmax(max_a,a[ebNE*nQuadraturePoints_elementBoundary*nnz+
3141  k*nnz+
3142  m]);
3143 
3144  }
3145  Jacobian
3146  +=
3147  (diffusiveVelocityComponent_I_Jacobian
3148  *
3149  v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3150  k*nDOF_trial_element+
3151  j]
3152  +
3153  diffusiveVelocityComponent_I_Jacobian2*
3154  dphi[j_global])
3155  *
3156  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
3157  k*nSpace+
3158  I];
3159  }
3160  max_a = fmax(penalty_floor,max_a);
3161 
3162  double penaltyJacobian = penalty[ebNE*nQuadraturePoints_elementBoundary+
3163  k]
3164  *
3165  v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3166  k*nDOF_trial_element+
3167  j];
3168  if (scale_penalty) penaltyJacobian *= max_a;
3169 
3170  Jacobian += penaltyJacobian;
3171 
3172  fluxJacobian[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3173  k*nDOF_trial_element+
3174  j]
3175  += Jacobian;
3176  }
3177  }
3178  }
3179  }
3180 }
3181 
3182 /*
3183  \brief Update the diffusive flux Jacobian at exterior element boundary quadrature points
3184 
3185 void updateExteriorNumericalDiffusiveFluxJacobian(int nExteriorElementBoundaries_global,
3186  int nElementBoundaries_element,
3187  int nQuadraturePoints_elementBoundary,
3188  int nDOF_trial_element,
3189  int nSpace,
3190  int* l2g,
3191  int* exteriorElementBoundaries,
3192  int* elementBoundaryElements,
3193  int* elementBoundaryLocalElementBoundaries,
3194  int* isDOFBoundary,
3195  double* n,
3196  double* a,
3197  double* da,
3198  double* grad_phi,
3199  double* dphi,
3200  double* v,
3201  double* grad_v,
3202  double* penalty,
3203  double* fluxJacobian)
3204 {
3205  int ebNE,ebN,eN_global,ebN_element,k,j,j_global,I,J,nSpace2=nSpace*nSpace;
3206  double Jacobian,diffusiveVelocityComponent_I_Jacobian,diffusiveVelocityComponent_I_Jacobian2;
3207  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
3208  {
3209  ebN = exteriorElementBoundaries[ebNE];
3210  eN_global = elementBoundaryElements[ebN*2+0];
3211  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
3212  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
3213  {
3214  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
3215  {
3216  for(j=0;j<nDOF_trial_element;j++)
3217  {
3218  Jacobian=0.0;
3219  j_global = l2g[eN_global*nDOF_trial_element+j];
3220  for(I=0;I<nSpace;I++)
3221  {
3222  diffusiveVelocityComponent_I_Jacobian=0.0;
3223  diffusiveVelocityComponent_I_Jacobian2=0.0;
3224  for(J=0;J<nSpace;J++)
3225  {
3226  diffusiveVelocityComponent_I_Jacobian
3227  -=
3228  da[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
3229  ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
3230  k*nSpace2+
3231  I*nSpace+
3232  J]
3233  *
3234  grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3235  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3236  k*nSpace+
3237  J];
3238  diffusiveVelocityComponent_I_Jacobian2
3239  -=
3240  a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
3241  ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
3242  k*nSpace2+
3243  I*nSpace+
3244  J]
3245  *
3246  grad_v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3247  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3248  k*nDOF_trial_element*nSpace+
3249  j*nSpace+
3250  J];
3251  }
3252  Jacobian
3253  +=
3254  (diffusiveVelocityComponent_I_Jacobian
3255  *
3256  v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3257  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3258  k*nDOF_trial_element+
3259  j]
3260  +
3261  diffusiveVelocityComponent_I_Jacobian2*
3262  dphi[j_global])
3263  *
3264  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3265  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3266  k*nSpace+
3267  I];
3268  }
3269  Jacobian
3270  +=
3271  penalty[ebN*nQuadraturePoints_elementBoundary+
3272  k]
3273  *
3274  v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3275  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3276  k*nDOF_trial_element+
3277  j];
3278  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3279  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3280  k*nDOF_trial_element+
3281  j]
3282  += Jacobian;
3283  }
3284  }
3285  }
3286  }
3287 }
3288 void updateExteriorNumericalDiffusiveFluxJacobian_sd(int nExteriorElementBoundaries_global,
3289  int nElementBoundaries_element,
3290  int nQuadraturePoints_elementBoundary,
3291  int nDOF_trial_element,
3292  int nSpace,
3293  int* rowptr,
3294  int* colind,
3295  int* l2g,
3296  int* exteriorElementBoundaries,
3297  int* elementBoundaryElements,
3298  int* elementBoundaryLocalElementBoundaries,
3299  int* isDOFBoundary,
3300  double* n,
3301  double* a,
3302  double* da,
3303  double* grad_phi,
3304  double* dphi,
3305  double* v,
3306  double* grad_v,
3307  double* penalty,
3308  double* fluxJacobian)
3309 {
3310  int ebNE,ebN,eN_global,ebN_element,k,j,j_global,I,m,nnz=rowptr[nSpace];
3311  double Jacobian,diffusiveVelocityComponent_I_Jacobian,diffusiveVelocityComponent_I_Jacobian2;
3312  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
3313  {
3314  ebN = exteriorElementBoundaries[ebNE];
3315  eN_global = elementBoundaryElements[ebN*2+0];
3316  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
3317  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
3318  {
3319  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
3320  {
3321  for(j=0;j<nDOF_trial_element;j++)
3322  {
3323  Jacobian=0.0;
3324  j_global = l2g[eN_global*nDOF_trial_element+j];
3325  for(I=0;I<nSpace;I++)
3326  {
3327  diffusiveVelocityComponent_I_Jacobian=0.0;
3328  diffusiveVelocityComponent_I_Jacobian2=0.0;
3329  for(m=rowptr[I];m<rowptr[I+1];m++)
3330  {
3331  diffusiveVelocityComponent_I_Jacobian
3332  -=
3333  da[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
3334  ebN_element*nQuadraturePoints_elementBoundary*nnz+
3335  k*nnz+
3336  m]
3337  *
3338  grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3339  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3340  k*nSpace+
3341  colind[m]];
3342  diffusiveVelocityComponent_I_Jacobian2
3343  -=
3344  a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
3345  ebN_element*nQuadraturePoints_elementBoundary*nnz+
3346  k*nnz+
3347  m]
3348  *
3349  grad_v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3350  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3351  k*nDOF_trial_element*nSpace+
3352  j*nSpace+
3353  colind[m]];
3354  }
3355  Jacobian
3356  +=
3357  (diffusiveVelocityComponent_I_Jacobian
3358  *
3359  v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3360  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3361  k*nDOF_trial_element+
3362  j]
3363  +
3364  diffusiveVelocityComponent_I_Jacobian2*
3365  dphi[j_global])
3366  *
3367  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3368  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3369  k*nSpace+
3370  I];
3371  }
3372  Jacobian
3373  +=
3374  penalty[ebN*nQuadraturePoints_elementBoundary+
3375  k]
3376  *
3377  v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3378  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3379  k*nDOF_trial_element+
3380  j];
3381  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3382  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3383  k*nDOF_trial_element+
3384  j]
3385  += Jacobian;
3386  }
3387  }
3388  }
3389  }
3390 } */
3391 /*
3392  \brief Update the diffusive flux Jacobian at exterior element boundary quadrature points
3393 
3394 void updateGlobalExteriorNumericalDiffusiveFluxJacobian(int nExteriorElementBoundaries_global,
3395  int nQuadraturePoints_elementBoundary,
3396  int nDOF_trial_element,
3397  int nSpace,
3398  int* l2g,
3399  int* exteriorElementBoundaries,
3400  int* elementBoundaryElements,
3401  int* elementBoundaryLocalElementBoundaries,
3402  int* isDOFBoundary,
3403  double* n,
3404  double* a,
3405  double* da,
3406  double* grad_phi,
3407  double* dphi,
3408  double* v,
3409  double* grad_v,
3410  double* penalty,
3411  double* fluxJacobian)
3412 {
3413  int ebNE,ebN,eN_global,k,j,j_global,I,J,nSpace2=nSpace*nSpace;
3414  double Jacobian,diffusiveVelocityComponent_I_Jacobian,diffusiveVelocityComponent_I_Jacobian2,max_a;
3415  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
3416  {
3417  ebN = exteriorElementBoundaries[ebNE];
3418  eN_global = elementBoundaryElements[ebN*2+0];
3419  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
3420  {
3421  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] >= 1)
3422  {
3423  for(j=0;j<nDOF_trial_element;j++)
3424  {
3425  Jacobian=0.0;
3426  j_global = l2g[eN_global*nDOF_trial_element+j];
3427  max_a=0.0;
3428  for(I=0;I<nSpace;I++)
3429  {
3430  diffusiveVelocityComponent_I_Jacobian=0.0;
3431  diffusiveVelocityComponent_I_Jacobian2=0.0;
3432  for(J=0;J<nSpace;J++)
3433  {
3434  diffusiveVelocityComponent_I_Jacobian
3435  -=
3436  da[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
3437  k*nSpace2+
3438  I*nSpace+
3439  J]
3440  *
3441  grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
3442  k*nSpace+
3443  J];
3444  diffusiveVelocityComponent_I_Jacobian2
3445  -=
3446  a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
3447  k*nSpace2+
3448  I*nSpace+
3449  J]
3450  *
3451  grad_v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3452  k*nDOF_trial_element*nSpace+
3453  j*nSpace+
3454  J];
3455  max_a = fmax(max_a,a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
3456  k*nSpace2+
3457  I*nSpace+
3458  J]);
3459 
3460  }
3461  Jacobian
3462  +=
3463  (diffusiveVelocityComponent_I_Jacobian
3464  *
3465  v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3466  k*nDOF_trial_element+
3467  j]
3468  +
3469  diffusiveVelocityComponent_I_Jacobian2*
3470  dphi[j_global])
3471  *
3472  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
3473  k*nSpace+
3474  I];
3475  }
3476  Jacobian
3477  +=
3478  penalty[ebNE*nQuadraturePoints_elementBoundary+
3479  k]
3480  *
3481  v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3482  k*nDOF_trial_element+
3483  j];
3484  fluxJacobian[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3485  k*nDOF_trial_element+
3486  j]
3487  += Jacobian;
3488  }
3489  }
3490  }
3491  }
3492 }
3493 void updateGlobalExteriorNumericalDiffusiveFluxJacobian_sd(int nExteriorElementBoundaries_global,
3494  int nQuadraturePoints_elementBoundary,
3495  int nDOF_trial_element,
3496  int nSpace,
3497  int* rowptr,
3498  int* colind,
3499  int* l2g,
3500  int* exteriorElementBoundaries,
3501  int* elementBoundaryElements,
3502  int* elementBoundaryLocalElementBoundaries,
3503  int* isDOFBoundary,
3504  double* n,
3505  double* a,
3506  double* da,
3507  double* grad_phi,
3508  double* dphi,
3509  double* v,
3510  double* grad_v,
3511  double* penalty,
3512  double* fluxJacobian)
3513 {
3514  int ebNE,ebN,eN_global,k,j,j_global,I,m,nnz=rowptr[nSpace];
3515  double Jacobian,diffusiveVelocityComponent_I_Jacobian,diffusiveVelocityComponent_I_Jacobian2,max_a;
3516  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
3517  {
3518  ebN = exteriorElementBoundaries[ebNE];
3519  eN_global = elementBoundaryElements[ebN*2+0];
3520  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
3521  {
3522  if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] >= 1)
3523  {
3524  for(j=0;j<nDOF_trial_element;j++)
3525  {
3526  Jacobian=0.0;
3527  j_global = l2g[eN_global*nDOF_trial_element+j];
3528  max_a=0.0;
3529  for(I=0;I<nSpace;I++)
3530  {
3531  diffusiveVelocityComponent_I_Jacobian=0.0;
3532  diffusiveVelocityComponent_I_Jacobian2=0.0;
3533  for(m=rowptr[I];m<rowptr[I+1];m++)
3534  {
3535  diffusiveVelocityComponent_I_Jacobian
3536  -=
3537  da[ebNE*nQuadraturePoints_elementBoundary*nnz+
3538  k*nnz+
3539  m]
3540  *
3541  grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
3542  k*nSpace+
3543  colind[m]];
3544  diffusiveVelocityComponent_I_Jacobian2
3545  -=
3546  a[ebNE*nQuadraturePoints_elementBoundary*nnz+
3547  k*nnz+
3548  m]
3549  *
3550  grad_v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3551  k*nDOF_trial_element*nSpace+
3552  j*nSpace+
3553  colind[m]];
3554  max_a = fmax(max_a,a[ebNE*nQuadraturePoints_elementBoundary*nnz+
3555  k*nnz+
3556  I*nSpace+
3557  m]);
3558 
3559  }
3560  Jacobian
3561  +=
3562  (diffusiveVelocityComponent_I_Jacobian
3563  *
3564  v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3565  k*nDOF_trial_element+
3566  j]
3567  +
3568  diffusiveVelocityComponent_I_Jacobian2*
3569  dphi[j_global])
3570  *
3571  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
3572  k*nSpace+
3573  I];
3574  }
3575  Jacobian
3576  +=
3577  penalty[ebNE*nQuadraturePoints_elementBoundary+
3578  k]
3579  *
3580  v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3581  k*nDOF_trial_element+
3582  j];
3583  fluxJacobian[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3584  k*nDOF_trial_element+
3585  j]
3586  += Jacobian;
3587  }
3588  }
3589  }
3590  }
3591 }*/
3592 
3593 void updateExteriorNumericalDiffusiveFluxJacobian_free(int nExteriorElementBoundaries_global,
3594  int nElementBoundaries_element,
3595  int nQuadraturePoints_elementBoundary,
3596  int nDOF_trial_element,
3597  int nSpace,
3598  int* l2g,
3599  int* exteriorElementBoundaries,
3600  int* elementBoundaryElements,
3601  int* elementBoundaryLocalElementBoundaries,
3602  int* isDOFBoundary,
3603  double* n,
3604  double* a,
3605  double* da,
3606  double* grad_phi,
3607  double* dphi,
3608  double* v,
3609  double* grad_v,
3610  double* penalty,
3611  double* fluxJacobian)
3612 {
3613  int ebNE,ebN,eN_global,ebN_element,k,j,j_global,I,J,nSpace2=nSpace*nSpace;
3614  double diffusiveVelocityComponent_I_Jacobian,diffusiveVelocityComponent_I_Jacobian2;
3615  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
3616  {
3617  ebN = exteriorElementBoundaries[ebNE];
3618  eN_global = elementBoundaryElements[ebN*2+0];
3619  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
3620  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
3621  {
3622  for(j=0;j<nDOF_trial_element;j++)
3623  {
3624  j_global = l2g[eN_global*nDOF_trial_element+j];
3625  for(I=0;I<nSpace;I++)
3626  {
3627  diffusiveVelocityComponent_I_Jacobian=0.0;
3628  diffusiveVelocityComponent_I_Jacobian2=0.0;
3629  for(J=0;J<nSpace;J++)
3630  {
3631  diffusiveVelocityComponent_I_Jacobian
3632  -=
3633  da[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
3634  ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
3635  k*nSpace2+
3636  I*nSpace+
3637  J]
3638  *
3639  grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3640  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3641  k*nSpace+
3642  J];
3643  diffusiveVelocityComponent_I_Jacobian2
3644  -=
3645  a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
3646  ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
3647  k*nSpace2+
3648  I*nSpace+
3649  J]
3650  *
3651  grad_v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3652  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3653  k*nDOF_trial_element*nSpace+
3654  j*nSpace+
3655  J];
3656  }
3657  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3658  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3659  k*nDOF_trial_element+
3660  j]+=
3661  (diffusiveVelocityComponent_I_Jacobian
3662  *
3663  v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3664  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3665  k*nDOF_trial_element+
3666  j]
3667  +
3668  diffusiveVelocityComponent_I_Jacobian2*
3669  dphi[j_global])
3670  *
3671  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3672  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3673  k*nSpace+
3674  I];
3675  }
3676  }
3677  }
3678  }
3679 }
3680 void updateExteriorNumericalDiffusiveFluxJacobian_free_sd(int nExteriorElementBoundaries_global,
3681  int nElementBoundaries_element,
3682  int nQuadraturePoints_elementBoundary,
3683  int nDOF_trial_element,
3684  int nSpace,
3685  int* rowptr,
3686  int* colind,
3687  int* l2g,
3688  int* exteriorElementBoundaries,
3689  int* elementBoundaryElements,
3690  int* elementBoundaryLocalElementBoundaries,
3691  int* isDOFBoundary,
3692  double* n,
3693  double* a,
3694  double* da,
3695  double* grad_phi,
3696  double* dphi,
3697  double* v,
3698  double* grad_v,
3699  double* penalty,
3700  double* fluxJacobian)
3701 {
3702  int ebNE,ebN,eN_global,ebN_element,k,j,j_global,I,m,nnz=rowptr[nSpace];
3703  double diffusiveVelocityComponent_I_Jacobian,diffusiveVelocityComponent_I_Jacobian2;
3704  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
3705  {
3706  ebN = exteriorElementBoundaries[ebNE];
3707  eN_global = elementBoundaryElements[ebN*2+0];
3708  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
3709  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
3710  {
3711  for(j=0;j<nDOF_trial_element;j++)
3712  {
3713  j_global = l2g[eN_global*nDOF_trial_element+j];
3714  for(I=0;I<nSpace;I++)
3715  {
3716  diffusiveVelocityComponent_I_Jacobian=0.0;
3717  diffusiveVelocityComponent_I_Jacobian2=0.0;
3718  for(m=rowptr[I];m<rowptr[I+1];m++)
3719  {
3720  diffusiveVelocityComponent_I_Jacobian
3721  -=
3722  da[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
3723  ebN_element*nQuadraturePoints_elementBoundary*nnz+
3724  k*nnz+
3725  m]
3726  *
3727  grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3728  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3729  k*nSpace+
3730  colind[m]];
3731  diffusiveVelocityComponent_I_Jacobian2
3732  -=
3733  a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
3734  ebN_element*nQuadraturePoints_elementBoundary*nnz+
3735  k*nnz+
3736  m]
3737  *
3738  grad_v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3739  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3740  k*nDOF_trial_element*nSpace+
3741  j*nSpace+
3742  colind[m]];
3743  }
3744  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3745  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3746  k*nDOF_trial_element+
3747  j]+=
3748  (diffusiveVelocityComponent_I_Jacobian
3749  *
3750  v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3751  ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3752  k*nDOF_trial_element+
3753  j]
3754  +
3755  diffusiveVelocityComponent_I_Jacobian2*
3756  dphi[j_global])
3757  *
3758  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3759  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3760  k*nSpace+
3761  I];
3762  }
3763  }
3764  }
3765  }
3766 }
3767 
3768 void updateGlobalExteriorNumericalDiffusiveFluxJacobian_free(int nExteriorElementBoundaries_global,
3769  int nQuadraturePoints_elementBoundary,
3770  int nDOF_trial_element,
3771  int nSpace,
3772  int* l2g,
3773  int* exteriorElementBoundaries,
3774  int* elementBoundaryElements,
3775  int* elementBoundaryLocalElementBoundaries,
3776  int* isDOFBoundary,
3777  double* n,
3778  double* a,
3779  double* da,
3780  double* grad_phi,
3781  double* dphi,
3782  double* v,
3783  double* grad_v,
3784  double* penalty,
3785  double* fluxJacobian)
3786 {
3787  int ebNE,ebN,eN_global,k,j,j_global,I,J,nSpace2=nSpace*nSpace;
3788  double diffusiveVelocityComponent_I_Jacobian,diffusiveVelocityComponent_I_Jacobian2;
3789  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
3790  {
3791  ebN = exteriorElementBoundaries[ebNE];
3792  eN_global = elementBoundaryElements[ebN*2+0];
3793  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
3794  {
3795  for(j=0;j<nDOF_trial_element;j++)
3796  {
3797  j_global = l2g[eN_global*nDOF_trial_element+j];
3798  for(I=0;I<nSpace;I++)
3799  {
3800  diffusiveVelocityComponent_I_Jacobian=0.0;
3801  diffusiveVelocityComponent_I_Jacobian2=0.0;
3802  for(J=0;J<nSpace;J++)
3803  {
3804  diffusiveVelocityComponent_I_Jacobian
3805  -=
3806  da[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
3807  k*nSpace2+
3808  I*nSpace+
3809  J]
3810  *
3811  grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
3812  k*nSpace+
3813  J];
3814  diffusiveVelocityComponent_I_Jacobian2
3815  -=
3816  a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
3817  k*nSpace2+
3818  I*nSpace+
3819  J]
3820  *
3821  grad_v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3822  k*nDOF_trial_element*nSpace+
3823  j*nSpace+
3824  J];
3825  }
3826  fluxJacobian[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3827  k*nDOF_trial_element+
3828  j]+=
3829  (diffusiveVelocityComponent_I_Jacobian
3830  *
3831  v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3832  k*nDOF_trial_element+
3833  j]
3834  +
3835  diffusiveVelocityComponent_I_Jacobian2*
3836  dphi[j_global])
3837  *
3838  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
3839  k*nSpace+
3840  I];
3841  }
3842  }
3843  }
3844  }
3845 }
3846 void updateGlobalExteriorNumericalDiffusiveFluxJacobian_free_sd(int nExteriorElementBoundaries_global,
3847  int nQuadraturePoints_elementBoundary,
3848  int nDOF_trial_element,
3849  int nSpace,
3850  int* rowptr,
3851  int* colind,
3852  int* l2g,
3853  int* exteriorElementBoundaries,
3854  int* elementBoundaryElements,
3855  int* elementBoundaryLocalElementBoundaries,
3856  int* isDOFBoundary,
3857  double* n,
3858  double* a,
3859  double* da,
3860  double* grad_phi,
3861  double* dphi,
3862  double* v,
3863  double* grad_v,
3864  double* penalty,
3865  double* fluxJacobian)
3866 {
3867  int ebNE,ebN,eN_global,k,j,j_global,I,m,nnz=rowptr[nSpace];
3868  double diffusiveVelocityComponent_I_Jacobian,diffusiveVelocityComponent_I_Jacobian2;
3869  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
3870  {
3871  ebN = exteriorElementBoundaries[ebNE];
3872  eN_global = elementBoundaryElements[ebN*2+0];
3873  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
3874  {
3875  for(j=0;j<nDOF_trial_element;j++)
3876  {
3877  j_global = l2g[eN_global*nDOF_trial_element+j];
3878  for(I=0;I<nSpace;I++)
3879  {
3880  diffusiveVelocityComponent_I_Jacobian=0.0;
3881  diffusiveVelocityComponent_I_Jacobian2=0.0;
3882  for(m=rowptr[I];m<rowptr[I+1];m++)
3883  {
3884  diffusiveVelocityComponent_I_Jacobian
3885  -=
3886  da[ebNE*nQuadraturePoints_elementBoundary*nnz+
3887  k*nnz+
3888  m]
3889  *
3890  grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
3891  k*nSpace+
3892  colind[m]];
3893  diffusiveVelocityComponent_I_Jacobian2
3894  -=
3895  a[ebNE*nQuadraturePoints_elementBoundary*nnz+
3896  k*nnz+
3897  m]
3898  *
3899  grad_v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
3900  k*nDOF_trial_element*nSpace+
3901  j*nSpace+
3902  colind[m]];
3903  }
3904  fluxJacobian[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3905  k*nDOF_trial_element+
3906  j]+=
3907  (diffusiveVelocityComponent_I_Jacobian
3908  *
3909  v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
3910  k*nDOF_trial_element+
3911  j]
3912  +
3913  diffusiveVelocityComponent_I_Jacobian2*
3914  dphi[j_global])
3915  *
3916  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
3917  k*nSpace+
3918  I];
3919  }
3920  }
3921  }
3922  }
3923 }
3927 void calculateInteriorNumericalAdvectiveFlux(int nInteriorElementBoundaries_global,
3928  int nElementBoundaries_element,
3929  int nQuadraturePoints_elementBoundary,
3930  int nSpace,
3931  int* interiorElementBoundaries,
3932  int* elementBoundaryElements,
3933  int* elementBoundaryLocalElementBoundaries,
3934  double* n,
3935  double* u,
3936  double* f,
3937  double* df,
3938  double* flux,
3939  double* dflux_left,
3940  double* dflux_right)
3941 {
3942  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,J;
3943  double left_speed,right_speed,left_flux,right_flux,shock_speed,flux_jump,u_jump;
3944  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
3945  {
3946  ebN = interiorElementBoundaries[ebNI];
3947  left_eN_global = elementBoundaryElements[ebN*2+0];
3948  right_eN_global = elementBoundaryElements[ebN*2+1];
3949  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
3950  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
3951  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
3952  {
3953  left_speed=0.0;
3954  right_speed=0.0;
3955  left_flux=0.0;
3956  right_flux=0.0;
3957  /*mwf add default shock speed is zero*/
3958  shock_speed=0.0;
3959  for(J=0;J<nSpace;J++)
3960  {
3961  left_speed
3962  +=
3963  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3964  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3965  k*nSpace+
3966  J]
3967  *
3968  df[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3969  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3970  k*nSpace+
3971  J];
3972  right_speed
3973  +=
3974  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3975  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3976  k*nSpace+
3977  J]
3978  *
3979  df[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3980  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3981  k*nSpace+
3982  J];
3983  left_flux
3984  +=
3985  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3986  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3987  k*nSpace+
3988  J]
3989  *
3990  f[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3991  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3992  k*nSpace+
3993  J];
3994  right_flux
3995  +=
3996  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
3997  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
3998  k*nSpace+
3999  J]
4000  *
4001  f[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4002  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4003  k*nSpace+
4004  J];
4005  }
4006  flux_jump = (right_flux - left_flux);
4007  u_jump = (u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
4008  right_ebN_element*nQuadraturePoints_elementBoundary+
4009  k]
4010  -
4011  u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
4012  left_ebN_element*nQuadraturePoints_elementBoundary+
4013  k]);
4014  if (fabs(u_jump) > fabs(flux_jump*1.0e-16))
4015  shock_speed = flux_jump/u_jump;
4016  if (left_speed >= 0.0 && right_speed >= 0.0)
4017  {
4018  flux[ebN*nQuadraturePoints_elementBoundary+
4019  k] = left_flux;
4020  dflux_left[ebN*nQuadraturePoints_elementBoundary+
4021  k] = left_speed;
4022  dflux_right[ebN*nQuadraturePoints_elementBoundary+
4023  k] = 0.0;
4024  }
4025  else if (left_speed <= 0.0 && right_speed <= 0.0)
4026  {
4027  flux[ebN*nQuadraturePoints_elementBoundary+
4028  k] = right_flux;
4029  dflux_left[ebN*nQuadraturePoints_elementBoundary+
4030  k] = 0.0;
4031  dflux_right[ebN*nQuadraturePoints_elementBoundary+
4032  k] = right_speed;
4033  }
4034  else if (left_speed >= 0.0 && right_speed <= 0.0)
4035  {
4036  if (shock_speed >= 0.0)
4037  {
4038  flux[ebN*nQuadraturePoints_elementBoundary+
4039  k] = left_flux;
4040  dflux_left[ebN*nQuadraturePoints_elementBoundary+
4041  k] = left_speed;
4042  dflux_right[ebN*nQuadraturePoints_elementBoundary+
4043  k] = 0.0;
4044  }
4045  else
4046  {
4047  flux[ebN*nQuadraturePoints_elementBoundary+
4048  k] = right_flux;
4049  dflux_left[ebN*nQuadraturePoints_elementBoundary+
4050  k] = 0.0;
4051  dflux_right[ebN*nQuadraturePoints_elementBoundary+
4052  k] = right_speed;
4053  }
4054  }
4055  else
4056  {
4057  /*transonic rarefaction*/
4058  printf("Transonic rarefaction detected in interior. This numerical flux treats transonic rarefactions incorrectly. left_speed= %12.5e right_speed= %12.5e \n",left_speed,right_speed);
4059  for (J=0; J < nSpace; J++)
4060  {
4061  printf("n_l[%d]=%g df_l[%d]=%g df_r[%d]=%g \n",J,
4062  n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4063  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4064  k*nSpace+
4065  J],
4066  J,
4067  df[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4068  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4069  k*nSpace+
4070  J],
4071  J,
4072  df[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4073  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4074  k*nSpace+
4075  J]);
4076 
4077  }
4078  flux[ebN*nQuadraturePoints_elementBoundary+
4079  k] = 0.5*(left_flux + right_flux);
4080  dflux_left[ebN*nQuadraturePoints_elementBoundary+
4081  k] = 0.5*left_speed;
4082  dflux_right[ebN*nQuadraturePoints_elementBoundary+
4083  k] = 0.5*right_speed;
4084  }
4085  }
4086  }
4087 }
4088 
4092 void updateInteriorNumericalAdvectiveFluxJacobian(int nInteriorElementBoundaries_global,
4093  int nElementBoundaries_element,
4094  int nQuadraturePoints_elementBoundary,
4095  int nDOF_trial_element,
4096  int* interiorElementBoundaries,
4097  int* elementBoundaryElements,
4098  int* elementBoundaryLocalElementBoundaries,
4099  double* dflux_left,
4100  double* dflux_right,
4101  double* v,
4102  double* fluxJacobian)
4103 {
4104  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,j;
4105  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
4106  {
4107  ebN = interiorElementBoundaries[ebNI];
4108  left_eN_global = elementBoundaryElements[ebN*2+0];
4109  right_eN_global = elementBoundaryElements[ebN*2+1];
4110  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4111  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
4112  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4113  for(j=0;j<nDOF_trial_element;j++)
4114  {
4115  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4116  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4117  k*nDOF_trial_element+
4118  j]
4119  +=
4120  dflux_left[ebN*nQuadraturePoints_elementBoundary+
4121  k]
4122  *
4123  v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4124  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4125  k*nDOF_trial_element+
4126  j];
4127  fluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4128  1*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4129  k*nDOF_trial_element+
4130  j]
4131  +=
4132  dflux_right[ebN*nQuadraturePoints_elementBoundary+
4133  k]
4134  *
4135  v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4136  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4137  k*nDOF_trial_element+
4138  j];
4139  }
4140  }
4141 }
4145 void updateInteriorTwoSidedNumericalFluxJacobian(int nInteriorElementBoundaries_global,
4146  int nElementBoundaries_element,
4147  int nQuadraturePoints_elementBoundary,
4148  int nDOF_trial_element,
4149  int* interiorElementBoundaries,
4150  int* elementBoundaryElements,
4151  int* elementBoundaryLocalElementBoundaries,
4152  double* dflux_left,
4153  double* dflux_right,
4154  double* v,
4155  double* fluxJacobian_2sided)
4156 {
4157  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,j;
4158  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
4159  {
4160  ebN = interiorElementBoundaries[ebNI];
4161  left_eN_global = elementBoundaryElements[ebN*2+0];
4162  right_eN_global = elementBoundaryElements[ebN*2+1];
4163  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4164  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
4165  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4166  for(j=0;j<nDOF_trial_element;j++)
4167  {
4168  /*left neighbour flux first*/
4169  fluxJacobian_2sided[ebN*2*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4170  0*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+/*left flux*/
4171  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+/*left neig. dep*/
4172  k*nDOF_trial_element+
4173  j]
4174  +=
4175  dflux_left[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
4176  left_ebN_element*nQuadraturePoints_elementBoundary+
4177  k]
4178  *
4179  v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4180  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4181  k*nDOF_trial_element+
4182  j];
4183  fluxJacobian_2sided[ebN*2*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4184  0*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+/*left flux*/
4185  1*nQuadraturePoints_elementBoundary*nDOF_trial_element+/*right neig. dep*/
4186  k*nDOF_trial_element+
4187  j]
4188  +=
4189  dflux_right[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
4190  left_ebN_element*nQuadraturePoints_elementBoundary+
4191  k]
4192  *
4193  v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4194  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4195  k*nDOF_trial_element+
4196  j];
4197  /*right neighbour flux*/
4198  fluxJacobian_2sided[ebN*2*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4199  1*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+/*right flux*/
4200  0*nQuadraturePoints_elementBoundary*nDOF_trial_element+/*left neig. dep*/
4201  k*nDOF_trial_element+
4202  j]
4203  +=
4204  dflux_left[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
4205  right_ebN_element*nQuadraturePoints_elementBoundary+
4206  k]
4207  *
4208  v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4209  left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4210  k*nDOF_trial_element+
4211  j];
4212  fluxJacobian_2sided[ebN*2*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4213  1*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+/*right flux*/
4214  1*nQuadraturePoints_elementBoundary*nDOF_trial_element+/*right neig. dep*/
4215  k*nDOF_trial_element+
4216  j]
4217  +=
4218  dflux_right[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
4219  right_ebN_element*nQuadraturePoints_elementBoundary+
4220  k]
4221  *
4222  v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4223  right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4224  k*nDOF_trial_element+
4225  j];
4226  }
4227  }
4228 }
4229 
4233 void calculateInteriorNumericalAdvectiveFlux_average(int nInteriorElementBoundaries_global,
4234  int nElementBoundaries_element,
4235  int nQuadraturePoints_elementBoundary,
4236  int nSpace,
4237  int* interiorElementBoundaries,
4238  int* elementBoundaryElements,
4239  int* elementBoundaryLocalElementBoundaries,
4240  double* n,
4241  double* u,
4242  double* f,
4243  double* df,
4244  double* flux,
4245  double* dflux_left,
4246  double* dflux_right)
4247 {
4248  int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,J;
4249  for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
4250  {
4251  ebN = interiorElementBoundaries[ebNI];
4252  left_eN_global = elementBoundaryElements[ebN*2+0];
4253  right_eN_global = elementBoundaryElements[ebN*2+1];
4254  left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4255  right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
4256  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4257  {
4258  flux[ebN*nQuadraturePoints_elementBoundary+
4259  k] =0.0;
4260  dflux_left[ebN*nQuadraturePoints_elementBoundary+
4261  k] = 0.0;
4262  dflux_right[ebN*nQuadraturePoints_elementBoundary+
4263  k] = 0.0;
4264  for(J=0;J<nSpace;J++)
4265  {
4266  flux[ebN*nQuadraturePoints_elementBoundary+
4267  k] += n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4268  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4269  k*nSpace+
4270  J]
4271  *
4272  (f[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4273  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4274  k*nSpace+
4275  J]
4276  +
4277  f[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4278  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4279  k*nSpace+
4280  J]);
4281  dflux_left[ebN*nQuadraturePoints_elementBoundary+
4282  k] += n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4283  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4284  k*nSpace+
4285  J]
4286  *
4287  df[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4288  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4289  k*nSpace+
4290  J];
4291  dflux_right[ebN*nQuadraturePoints_elementBoundary+
4292  k] += n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4293  left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4294  k*nSpace+
4295  J]
4296  *
4297  df[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4298  right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4299  k*nSpace+
4300  J];
4301  }
4302  flux[ebN*nQuadraturePoints_elementBoundary+
4303  k] *= 0.5;
4304  dflux_left[ebN*nQuadraturePoints_elementBoundary+
4305  k] *= 0.5;
4306  dflux_right[ebN*nQuadraturePoints_elementBoundary+
4307  k] *= 0.5;
4308  }
4309  }
4310 }
4311 
4315 void calculateExteriorNumericalAdvectiveFlux_NoBC(int nExteriorElementBoundaries_global,
4316  int nElementBoundaries_element,
4317  int nQuadraturePoints_elementBoundary,
4318  int nSpace,
4319  int* exteriorElementBoundaries,
4320  int* elementBoundaryElements,
4321  int* elementBoundaryLocalElementBoundaries,
4322  int* inflowFlag,
4323  double* n,
4324  double* f,
4325  double* df,
4326  double* flux,
4327  double* dflux_left)
4328 {
4329  int ebNE,ebN,eN_global,ebN_element,k,J;
4330  memset(inflowFlag,0,sizeof(int)*nExteriorElementBoundaries_global*nQuadraturePoints_elementBoundary);
4331  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4332  {
4333  ebN = exteriorElementBoundaries[ebNE];
4334  eN_global = elementBoundaryElements[ebN*2+0];
4335  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4336  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4337  {
4338  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;
4339  dflux_left[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;
4340  inflowFlag[ebNE*nQuadraturePoints_elementBoundary+k]=0;
4341  for(J=0;J<nSpace;J++)
4342  {
4343  flux[ebN*nQuadraturePoints_elementBoundary+k]
4344  +=
4345  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4346  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4347  k*nSpace+
4348  J]
4349  *
4350  f[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4351  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4352  k*nSpace+
4353  J];
4354  dflux_left[ebN*nQuadraturePoints_elementBoundary+k]
4355  +=
4356  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4357  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4358  k*nSpace+
4359  J]
4360  *
4361  df[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4362  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4363  k*nSpace+
4364  J];
4365  }
4366  if(dflux_left[ebN*nQuadraturePoints_elementBoundary+k] < 0.0)
4367  {
4368  /* cek debug, setting inflow flow to zero */
4369  inflowFlag[ebNE*nQuadraturePoints_elementBoundary+k] = 1;
4370  flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;
4371  dflux_left[ebN*nQuadraturePoints_elementBoundary+k] = 0.0;
4372  }
4373  }
4374  }
4375 }
4379 void calculateGlobalExteriorNumericalAdvectiveFlux_NoBC(int nExteriorElementBoundaries_global,
4380  int nQuadraturePoints_elementBoundary,
4381  int nSpace,
4382  int* exteriorElementBoundaries,
4383  int* elementBoundaryElements,
4384  int* elementBoundaryLocalElementBoundaries,
4385  int* inflowFlag,
4386  double* n,
4387  double* f,
4388  double* df,
4389  double* flux,
4390  double* dflux_left)
4391 {
4392  int ebNE,ebN,eN_global,ebN_element,k,J;
4393  memset(inflowFlag,0,sizeof(int)*nExteriorElementBoundaries_global*nQuadraturePoints_elementBoundary);
4394  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4395  {
4396  ebN = exteriorElementBoundaries[ebNE];
4397  eN_global = elementBoundaryElements[ebN*2+0];
4398  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4399  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4400  {
4401  flux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.0;
4402  dflux_left[ebNE*nQuadraturePoints_elementBoundary+k] = 0.0;
4403  inflowFlag[ebNE*nQuadraturePoints_elementBoundary+k]=0;
4404  for(J=0;J<nSpace;J++)
4405  {
4406  flux[ebNE*nQuadraturePoints_elementBoundary+k]
4407  +=
4408  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4409  k*nSpace+
4410  J]
4411  *
4412  f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4413  k*nSpace+
4414  J];
4415  dflux_left[ebNE*nQuadraturePoints_elementBoundary+k]
4416  +=
4417  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4418  k*nSpace+
4419  J]
4420  *
4421  df[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4422  k*nSpace+
4423  J];
4424  }
4425  if(dflux_left[ebNE*nQuadraturePoints_elementBoundary+k] < 0.0)
4426  {
4427  /* cek debug, setting inflow flow to zero */
4428  inflowFlag[ebNE*nQuadraturePoints_elementBoundary+k] = 1;
4429  flux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.0;
4430  dflux_left[ebNE*nQuadraturePoints_elementBoundary+k] = 0.0;
4431  }
4432  }
4433  }
4434 }
4435 
4439 void calculateExteriorNumericalAdvectiveFlux(int nExteriorElementBoundaries_global,
4440  int nElementBoundaries_element,
4441  int nQuadraturePoints_elementBoundary,
4442  int nSpace,
4443  int* exteriorElementBoundaries,
4444  int* elementBoundaryElements,
4445  int* elementBoundaryLocalElementBoundaries,
4446  int *isDOFBoundary,
4447  int *inflowFlag,
4448  double* n,
4449  double* bc_u,
4450  double* bc_f,
4451  double* bc_df,
4452  double* u,
4453  double* f,
4454  double* df,
4455  double* flux,
4456  double* dflux)
4457 {
4458  int ebNE,ebN,eN_global,ebN_element,k,J;
4459  double left_speed,right_speed,left_flux,right_flux,shock_speed,flux_jump,u_jump;
4460  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4461  {
4462  ebN = exteriorElementBoundaries[ebNE];
4463  eN_global = elementBoundaryElements[ebN*2+0];
4464  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4465  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4466  {
4467  left_speed=0.0;
4468  right_speed=0.0;
4469  left_flux=0.0;
4470  right_flux=0.0;
4471  /*mwf add default shock speed is zero*/
4472  shock_speed=0.0;
4473  for(J=0;J<nSpace;J++)
4474  {
4475  left_speed
4476  +=
4477  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4478  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4479  k*nSpace+
4480  J]
4481  *
4482  df[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4483  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4484  k*nSpace+
4485  J];
4486  right_speed
4487  +=
4488  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4489  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4490  k*nSpace+
4491  J]
4492  *
4493  bc_df[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4494  k*nSpace+
4495  J];
4496  left_flux
4497  +=
4498  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4499  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4500  k*nSpace+
4501  J]
4502  *
4503  f[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4504  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4505  k*nSpace+
4506  J];
4507  right_flux
4508  +=
4509  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4510  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4511  k*nSpace+
4512  J]
4513  *
4514  bc_f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4515  k*nSpace+
4516  J];
4517  }
4518  flux_jump = (right_flux - left_flux);
4519  u_jump = (bc_u[ebNE*nQuadraturePoints_elementBoundary+
4520  k]
4521  -
4522  u[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
4523  ebN_element*nQuadraturePoints_elementBoundary+
4524  k]);
4525  if (fabs(u_jump) > fabs(flux_jump*1.0e-16))
4526  shock_speed = flux_jump/u_jump;
4527  if (left_speed >= 0.0 && right_speed >= 0.0)
4528  {
4529  flux[ebN*nQuadraturePoints_elementBoundary+
4530  k] = left_flux;
4531  dflux[ebN*nQuadraturePoints_elementBoundary+
4532  k] = left_speed;
4533  }
4534  else if (left_speed <= 0.0 && right_speed <= 0.0)
4535  {
4536  flux[ebN*nQuadraturePoints_elementBoundary+
4537  k] = right_flux;
4538  if (isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
4539  dflux[ebN*nQuadraturePoints_elementBoundary+
4540  k] = 0.0;
4541  else
4542  dflux[ebN*nQuadraturePoints_elementBoundary+
4543  k] = right_speed;
4544  }
4545  else if (left_speed >= 0.0 && right_speed <= 0.0)
4546  {
4547  if (shock_speed >= 0.0)
4548  {
4549  flux[ebN*nQuadraturePoints_elementBoundary+
4550  k] = left_flux;
4551  dflux[ebN*nQuadraturePoints_elementBoundary+
4552  k] = left_speed;
4553  }
4554  else
4555  {
4556  flux[ebN*nQuadraturePoints_elementBoundary+
4557  k] = right_flux;
4558  if (isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
4559  dflux[ebN*nQuadraturePoints_elementBoundary+
4560  k] = 0.0;
4561  else
4562  dflux[ebN*nQuadraturePoints_elementBoundary+
4563  k] = right_speed;
4564  }
4565  }
4566  else
4567  {
4568  /*transonic rarefaction*/
4569  printf("Transonic rarefaction detected on exterior. This numerical flux treats transonic rarefactions incorrectly. left_speed= %12.5e right_speed= %12.5e \n",left_speed,right_speed);
4570  for (J=0; J < nSpace; J++)
4571  {
4572  printf("n_l[%d]=%g df_l[%d]=%g df_r[%d]=%g \n",J,
4573  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4574  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4575  k*nSpace+
4576  J],
4577  J,
4578  df[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4579  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4580  k*nSpace+
4581  J],
4582  J,
4583  bc_df[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4584  k*nSpace+
4585  J]);
4586 
4587  }
4588  flux[ebN*nQuadraturePoints_elementBoundary+
4589  k] = 0.5*(left_flux + right_flux);
4590  if (isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
4591  dflux[ebN*nQuadraturePoints_elementBoundary+
4592  k] = 0.5*left_speed;
4593  else
4594  dflux[ebN*nQuadraturePoints_elementBoundary+
4595  k] = 0.5*(left_speed+right_speed);
4596  }
4597 /* printf("exterior flux %d %d %12.5e \n",ebN,k,flux[ebN*nQuadraturePoints_elementBoundary+k]); */
4598  /*mwf debug
4599  printf("in exterior diagonal eN=%d u_left=%g left_flux=%g left_speed=%g bc_u=%g right_flux=%g right_speed=%g shock_speed=%g\n",
4600  eN_global,u[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
4601  ebN_element*nQuadraturePoints_elementBoundary+
4602  k],
4603  left_flux,
4604  left_speed,
4605  bc_u[ebNE*nQuadraturePoints_elementBoundary+
4606  k],
4607  right_flux,
4608  right_speed,
4609  shock_speed);
4610  printf("\tflux = %g n=[",flux[ebN*nQuadraturePoints_elementBoundary+k]);
4611  for (J=0; J < nSpace; J++)
4612  printf(" %g ",n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4613  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4614  k*nSpace+
4615  J]);
4616  printf("]\n");
4617  mwf end debug */
4618 /* if(dflux[ebN*nQuadraturePoints_elementBoundary+k] < 0.0) */
4619 /* { */
4620 /* /\* cek debug, setting inflow flow to zero *\/ */
4621 /* inflowFlag[ebNE*nQuadraturePoints_elementBoundary+k] = 1; */
4622 /* flux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0; */
4623 /* dflux[ebN*nQuadraturePoints_elementBoundary+k] = 0.0; */
4624 /* } */
4625  }
4626  }
4627 }
4628 
4632 void calculateGlobalExteriorNumericalAdvectiveFlux(int nExteriorElementBoundaries_global,
4633  int nQuadraturePoints_elementBoundary,
4634  int nSpace,
4635  int* exteriorElementBoundaries,
4636  int* elementBoundaryElements,
4637  int* elementBoundaryLocalElementBoundaries,
4638  int *isDOFBoundary,
4639  int *inflowFlag,
4640  double* n,
4641  double* bc_u,
4642  double* bc_f,
4643  double* bc_df,
4644  double* u,
4645  double* f,
4646  double* df,
4647  double* flux,
4648  double* dflux)
4649 {
4650  int ebNE,ebN,eN_global,k,J;
4651  double left_speed,right_speed,left_flux,right_flux,shock_speed,flux_jump,u_jump;
4652  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4653  {
4654  ebN = exteriorElementBoundaries[ebNE];
4655  eN_global = elementBoundaryElements[ebN*2+0];
4656  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4657  {
4658  left_speed=0.0;
4659  right_speed=0.0;
4660  left_flux=0.0;
4661  right_flux=0.0;
4662  shock_speed=0.0;
4663  for(J=0;J<nSpace;J++)
4664  {
4665  left_speed
4666  +=
4667  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4668  k*nSpace+
4669  J]
4670  *
4671  df[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4672  k*nSpace+
4673  J];
4674  right_speed
4675  +=
4676  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4677  k*nSpace+
4678  J]
4679  *
4680  bc_df[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4681  k*nSpace+
4682  J];
4683  left_flux
4684  +=
4685  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4686  k*nSpace+
4687  J]
4688  *
4689  f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4690  k*nSpace+
4691  J];
4692  right_flux
4693  +=
4694  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4695  k*nSpace+
4696  J]
4697  *
4698  bc_f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4699  k*nSpace+
4700  J];
4701  }
4702  flux_jump = (right_flux - left_flux);
4703  u_jump = (bc_u[ebNE*nQuadraturePoints_elementBoundary+
4704  k]
4705  -
4706  u[ebNE*nQuadraturePoints_elementBoundary+
4707  k]);
4708  if (fabs(u_jump) > fabs(flux_jump*1.0e-16))
4709  shock_speed = flux_jump/u_jump;
4710  if (left_speed >= 0.0 && right_speed >= 0.0)
4711  {
4712  flux[ebNE*nQuadraturePoints_elementBoundary+
4713  k] = left_flux;
4714  dflux[ebNE*nQuadraturePoints_elementBoundary+
4715  k] = left_speed;
4716  }
4717  else if (left_speed <= 0.0 && right_speed <= 0.0)
4718  {
4719  flux[ebNE*nQuadraturePoints_elementBoundary+
4720  k] = right_flux;
4721  if (isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
4722  dflux[ebNE*nQuadraturePoints_elementBoundary+
4723  k] = 0.0;
4724  else
4725  dflux[ebNE*nQuadraturePoints_elementBoundary+
4726  k] = right_speed;
4727  }
4728  else if (left_speed >= 0.0 && right_speed <= 0.0)
4729  {
4730  if (shock_speed >= 0.0)
4731  {
4732  flux[ebNE*nQuadraturePoints_elementBoundary+
4733  k] = left_flux;
4734  dflux[ebNE*nQuadraturePoints_elementBoundary+
4735  k] = left_speed;
4736  }
4737  else
4738  {
4739  flux[ebNE*nQuadraturePoints_elementBoundary+
4740  k] = right_flux;
4741  if (isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
4742  dflux[ebNE*nQuadraturePoints_elementBoundary+
4743  k] = 0.0;
4744  else
4745  dflux[ebNE*nQuadraturePoints_elementBoundary+
4746  k] = right_speed;
4747  }
4748  }
4749  else
4750  {
4751  /*transonic rarefaction*/
4752  printf("Transonic rarefaction detected on exterior. This numerical flux treats transonic rarefactions incorrectly. left_speed= %12.5e right_speed= %12.5e \n",left_speed,right_speed);
4753  for (J=0; J < nSpace; J++)
4754  {
4755  printf("n_l[%d]=%g df_l[%d]=%g df_r[%d]=%g \n",J,
4756  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4757  k*nSpace+
4758  J],
4759  J,
4760  df[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4761  k*nSpace+
4762  J],
4763  J,
4764  bc_df[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4765  k*nSpace+
4766  J]);
4767 
4768  }
4769  flux[ebNE*nQuadraturePoints_elementBoundary+
4770  k] = 0.5*(left_flux + right_flux);
4771  if (isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
4772  dflux[ebNE*nQuadraturePoints_elementBoundary+
4773  k] = 0.5*left_speed;
4774  else
4775  dflux[ebNE*nQuadraturePoints_elementBoundary+
4776  k] = 0.5*(left_speed+right_speed);
4777  }
4778 /* printf("exterior flux %d %d %12.5e \n",ebNE,k,flux[ebNE*nQuadraturePoints_elementBoundary+k]); */
4779 /* if(dflux[ebN*nQuadraturePoints_elementBoundary+k] < 0.0) */
4780 /* { */
4781 /* /\* cek debug, setting inflow flow to zero *\/ */
4782 /* inflowFlag[ebNE*nQuadraturePoints_elementBoundary+k] = 1; */
4783 /* flux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.0; */
4784 /* dflux[ebNE*nQuadraturePoints_elementBoundary+k] = 0.0; */
4785 /* } */
4786  }
4787  }
4788 }
4789 void calculateExteriorNumericalAdvectiveFlux_free(int nExteriorElementBoundaries_global,
4790  int nElementBoundaries_element,
4791  int nQuadraturePoints_elementBoundary,
4792  int nSpace,
4793  int* exteriorElementBoundaries,
4794  int* elementBoundaryElements,
4795  int* elementBoundaryLocalElementBoundaries,
4796  int *isDOFBoundary,
4797  int *inflowFlag,
4798  double* n,
4799  double* bc_u,
4800  double* bc_f,
4801  double* bc_df,
4802  double* u,
4803  double* f,
4804  double* df,
4805  double* flux,
4806  double* dflux)
4807 {
4808  int ebNE,ebN,eN_global,ebN_element,k,J;
4809  double left_speed,right_speed,left_flux,right_flux,shock_speed;
4810  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4811  {
4812  ebN = exteriorElementBoundaries[ebNE];
4813  eN_global = elementBoundaryElements[ebN*2+0];
4814  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4815  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4816  {
4817  left_speed=0.0;
4818  right_speed=0.0;
4819  left_flux=0.0;
4820  right_flux=0.0;
4821  /*mwf add default shock speed is zero*/
4822  shock_speed=0.0;
4823  for(J=0;J<nSpace;J++)
4824  {
4825  left_speed
4826  +=
4827  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4828  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4829  k*nSpace+
4830  J]
4831  *
4832  df[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4833  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4834  k*nSpace+
4835  J];
4836  left_flux
4837  +=
4838  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4839  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4840  k*nSpace+
4841  J]
4842  *
4843  f[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4844  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4845  k*nSpace+
4846  J];
4847  }
4848  flux[ebN*nQuadraturePoints_elementBoundary+
4849  k] = left_flux;
4850  dflux[ebN*nQuadraturePoints_elementBoundary+
4851  k] = left_speed;
4852  }
4853  }
4854 }
4855 
4856 void calculateGlobalExteriorNumericalAdvectiveFlux_free(int nExteriorElementBoundaries_global,
4857  int nQuadraturePoints_elementBoundary,
4858  int nSpace,
4859  int* exteriorElementBoundaries,
4860  int* elementBoundaryElements,
4861  int* elementBoundaryLocalElementBoundaries,
4862  int *isDOFBoundary,
4863  int *inflowFlag,
4864  double* n,
4865  double* bc_u,
4866  double* bc_f,
4867  double* bc_df,
4868  double* u,
4869  double* f,
4870  double* df,
4871  double* flux,
4872  double* dflux)
4873 {
4874  int ebNE,ebN,eN_global,k,J;
4875  double left_speed,right_speed,left_flux,right_flux,shock_speed;
4876  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4877  {
4878  ebN = exteriorElementBoundaries[ebNE];
4879  eN_global = elementBoundaryElements[ebN*2+0];
4880  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4881  {
4882  left_speed=0.0;
4883  right_speed=0.0;
4884  left_flux=0.0;
4885  right_flux=0.0;
4886  shock_speed=0.0;
4887  for(J=0;J<nSpace;J++)
4888  {
4889  left_speed
4890  +=
4891  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4892  k*nSpace+
4893  J]
4894  *
4895  df[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4896  k*nSpace+
4897  J];
4898  left_flux
4899  +=
4900  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4901  k*nSpace+
4902  J]
4903  *
4904  f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
4905  k*nSpace+
4906  J];
4907  }
4908  flux[ebNE*nQuadraturePoints_elementBoundary+
4909  k] = left_flux;
4910  dflux[ebNE*nQuadraturePoints_elementBoundary+
4911  k] = left_speed;
4912  }
4913  }
4914 }
4918 void calculateExteriorNumericalAdvectiveFluxStokesP2D(int nExteriorElementBoundaries_global,
4919  int nElementBoundaries_element,
4920  int nQuadraturePoints_elementBoundary,
4921  int nSpace,
4922  int* exteriorElementBoundaries,
4923  int* elementBoundaryElements,
4924  int* elementBoundaryLocalElementBoundaries,
4925  int *isDOFBoundary_p,
4926  int *isDOFBoundary_u,
4927  int *isDOFBoundary_v,
4928  double* n,
4929  double* bc_f,
4930  double* bc_fpu,
4931  double* bc_fpv,
4932  double* f,
4933  double* fpu,
4934  double* fpv,
4935  double* df_du,
4936  double* df_dv,
4937  double* dfpu_dp,
4938  double* dfpv_dp,
4939  double* flux,
4940  double* fluxpu,
4941  double* fluxpv,
4942  double* dflux_du,
4943  double* dflux_dv,
4944  double* dfluxpu_dp,
4945  double* dfluxpv_dp)
4946 {
4947  int ebNE,ebN,eN_global,ebN_element,k;
4948  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4949  {
4950  ebN = exteriorElementBoundaries[ebNE];
4951  eN_global = elementBoundaryElements[ebN*2+0];
4952  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4953  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4954  {
4955  fluxpu[ebN*nQuadraturePoints_elementBoundary+
4956  k] = 0.0;
4957  fluxpv[ebN*nQuadraturePoints_elementBoundary+
4958  k] = 0.0;
4959  flux[ebN*nQuadraturePoints_elementBoundary+
4960  k] = 0.0;
4961 
4962  //u and v momentum fluxes due to pressure
4963  if (isDOFBoundary_p[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
4964  {
4965  dfluxpu_dp[ebN*nQuadraturePoints_elementBoundary+
4966  k]
4967  =
4968  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4969  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4970  k*nSpace+
4971  0]
4972  *
4973  dfpu_dp[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4974  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4975  k*nSpace+
4976  0];
4977  fluxpu[ebN*nQuadraturePoints_elementBoundary+
4978  k]+=
4979  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4980  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4981  k*nSpace+
4982  0]
4983  *
4984  fpu[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4985  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4986  k*nSpace+
4987  0];
4988  dfluxpv_dp[ebN*nQuadraturePoints_elementBoundary+
4989  k]
4990  =
4991  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4992  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4993  k*nSpace+
4994  1]
4995  *
4996  dfpv_dp[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
4997  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
4998  k*nSpace+
4999  1];
5000  fluxpv[ebN*nQuadraturePoints_elementBoundary+
5001  k]+=
5002  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5003  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5004  k*nSpace+
5005  1]
5006  *
5007  fpv[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5008  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5009  k*nSpace+
5010  1];
5011  }
5012  else
5013  {
5014  fluxpu[ebN*nQuadraturePoints_elementBoundary+
5015  k]+=
5016  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5017  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5018  k*nSpace+
5019  0]
5020  *
5021  bc_fpu[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5022  k*nSpace+
5023  0];
5024  fluxpv[ebN*nQuadraturePoints_elementBoundary+
5025  k]+=
5026  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5027  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5028  k*nSpace+
5029  1]
5030  *
5031  bc_fpv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5032  k*nSpace+
5033  1];
5034  }
5035  //mass flux
5036  if (isDOFBoundary_u[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
5037  {
5038  dflux_du[ebN*nQuadraturePoints_elementBoundary+
5039  k]
5040  =
5041  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5042  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5043  k*nSpace+
5044  0]
5045  *
5046  df_du[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5047  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5048  k*nSpace+
5049  0];
5050  flux[ebN*nQuadraturePoints_elementBoundary+
5051  k]+=
5052  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5053  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5054  k*nSpace+
5055  0]
5056  *
5057  f[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5058  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5059  k*nSpace+
5060  0];
5061  }
5062  else
5063  {
5064  flux[ebN*nQuadraturePoints_elementBoundary+
5065  k]+=
5066  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5067  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5068  k*nSpace+
5069  0]
5070  *
5071  bc_f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5072  k*nSpace+
5073  0];
5074  }
5075  if (isDOFBoundary_v[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
5076  {
5077  dflux_dv[ebN*nQuadraturePoints_elementBoundary+
5078  k]
5079  =
5080  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5081  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5082  k*nSpace+
5083  1]
5084  *
5085  df_dv[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5086  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5087  k*nSpace+
5088  1];
5089  flux[ebN*nQuadraturePoints_elementBoundary+
5090  k]+=
5091  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5092  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5093  k*nSpace+
5094  1]
5095  *
5096  f[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5097  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5098  k*nSpace+
5099  1];
5100  }
5101  else
5102  {
5103  flux[ebN*nQuadraturePoints_elementBoundary+
5104  k]+=
5105  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5106  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5107  k*nSpace+
5108  1]
5109  *
5110  bc_f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5111  k*nSpace+
5112  1];
5113  }
5114  }
5115  }
5116 }
5117 void calculateExteriorNumericalAdvectiveFluxNavierStokes2D(int nExteriorElementBoundaries_global,
5118  int nElementBoundaries_element,
5119  int nQuadraturePoints_elementBoundary,
5120  int nSpace,
5121  int* exteriorElementBoundaries,
5122  int* elementBoundaryElements,
5123  int* elementBoundaryLocalElementBoundaries,
5124  int *isDOFBoundary_p,
5125  int *isDOFBoundary_u,
5126  int *isDOFBoundary_v,
5127  double* n,
5128  double* bc_p,
5129  double* bc_f_mass,
5130  double* bc_f_umom,
5131  double* bc_f_vmom,
5132  double* p,
5133  double* f_mass,
5134  double* f_umom,
5135  double* f_vmom,
5136  double* df_mass_du,
5137  double* df_mass_dv,
5138  double* df_umom_du,
5139  double* df_umom_dv,
5140  double* df_vmom_du,
5141  double* df_vmom_dv,
5142  double* flux_mass,
5143  double* flux_umom,
5144  double* flux_vmom,
5145  double* dflux_mass_du,
5146  double* dflux_mass_dv,
5147  double* dflux_umom_dp,
5148  double* dflux_umom_du,
5149  double* dflux_umom_dv,
5150  double* dflux_vmom_dp,
5151  double* dflux_vmom_du,
5152  double* dflux_vmom_dv)
5153 {
5154  int ebNE,ebN,eN_global,ebN_element,k;
5155  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
5156  {
5157  ebN = exteriorElementBoundaries[ebNE];
5158  eN_global = elementBoundaryElements[ebN*2+0];
5159  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
5160  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5161  {
5162  flux_umom[ebN*nQuadraturePoints_elementBoundary+
5163  k] = 0.0;
5164  flux_vmom[ebN*nQuadraturePoints_elementBoundary+
5165  k] = 0.0;
5166  flux_mass[ebN*nQuadraturePoints_elementBoundary+
5167  k] = 0.0;
5168  if (isDOFBoundary_u[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
5169  {
5170  dflux_mass_du[ebN*nQuadraturePoints_elementBoundary+
5171  k]
5172  =
5173  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5174  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5175  k*nSpace+
5176  0]
5177  *
5178  df_mass_du[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5179  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5180  k*nSpace+
5181  0];
5182  flux_mass[ebN*nQuadraturePoints_elementBoundary+
5183  k]+=
5184  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5185  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5186  k*nSpace+
5187  0]
5188  *
5189  f_mass[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5190  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5191  k*nSpace+
5192  0];
5193  dflux_umom_du[ebN*nQuadraturePoints_elementBoundary+
5194  k]
5195  =
5196  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5197  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5198  k*nSpace+
5199  0]
5200  *
5201  df_umom_du[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5202  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5203  k*nSpace+
5204  0];
5205  flux_umom[ebN*nQuadraturePoints_elementBoundary+
5206  k]
5207  +=
5208  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5209  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5210  k*nSpace+
5211  0]
5212  *
5213  f_umom[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5214  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5215  k*nSpace+
5216  0];
5217  dflux_vmom_du[ebN*nQuadraturePoints_elementBoundary+
5218  k]
5219  =
5220  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5221  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5222  k*nSpace+
5223  0]
5224  *
5225  df_vmom_du[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5226  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5227  k*nSpace+
5228  0];
5229  flux_vmom[ebN*nQuadraturePoints_elementBoundary+
5230  k]
5231  +=
5232  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5233  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5234  k*nSpace+
5235  0]
5236  *
5237  f_vmom[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5238  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5239  k*nSpace+
5240  0];
5241  }
5242  else
5243  {
5244  flux_mass[ebN*nQuadraturePoints_elementBoundary+
5245  k]
5246  +=
5247  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5248  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5249  k*nSpace+
5250  0]
5251  *
5252  bc_f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5253  k*nSpace+
5254  0];
5255  flux_umom[ebN*nQuadraturePoints_elementBoundary+
5256  k]
5257  +=
5258  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5259  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5260  k*nSpace+
5261  0]
5262  *
5263  bc_f_umom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5264  k*nSpace+
5265  0];
5266  flux_vmom[ebN*nQuadraturePoints_elementBoundary+
5267  k]
5268  +=
5269  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5270  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5271  k*nSpace+
5272  0]
5273  *
5274  bc_f_vmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5275  k*nSpace+
5276  0];
5277  }
5278  if (isDOFBoundary_p[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
5279  {
5280  dflux_umom_dp[ebN*nQuadraturePoints_elementBoundary+
5281  k]
5282  =
5283  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5284  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5285  k*nSpace+
5286  0];
5287  flux_umom[ebN*nQuadraturePoints_elementBoundary+
5288  k]
5289  +=
5290  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5291  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5292  k*nSpace+
5293  0]
5294  *
5295  (p[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
5296  ebN_element*nQuadraturePoints_elementBoundary+
5297  k]
5298  -
5299  bc_p[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
5300  ebN_element*nQuadraturePoints_elementBoundary+
5301  k]);
5302  dflux_vmom_dp[ebN*nQuadraturePoints_elementBoundary+
5303  k]
5304  =
5305  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5306  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5307  k*nSpace+
5308  1];
5309  flux_vmom[ebN*nQuadraturePoints_elementBoundary+
5310  k]+=
5311  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
5312  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
5313  k*nSpace+
5314  1]
5315  *
5316  (p[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
5317  ebN_element*nQuadraturePoints_elementBoundary+
5318  k]
5319  -
5320  bc_p[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
5321  ebN_element*nQuadraturePoints_elementBoundary+
5322  k]);
5323  }
5324  }
5325  }
5326 }
5327 
5328 void calculateGlobalExteriorNumericalAdvectiveFluxNavierStokes2D(int nExteriorElementBoundaries_global,
5329  int nQuadraturePoints_elementBoundary,
5330  int nSpace,
5331  int* exteriorElementBoundaries,
5332  int* elementBoundaryElements,
5333  int* elementBoundaryLocalElementBoundaries,
5334  int *isDOFBoundary_p,
5335  int *isDOFBoundary_u,
5336  int *isDOFBoundary_v,
5337  double* n,
5338  double* bc_p,
5339  double* bc_f_mass,
5340  double* bc_f_umom,
5341  double* bc_f_vmom,
5342  double* p,
5343  double* oneByRho,
5344  double* f_mass,
5345  double* f_umom,
5346  double* f_vmom,
5347  double* df_mass_du,
5348  double* df_mass_dv,
5349  double* df_umom_dp,
5350  double* df_umom_du,
5351  double* df_umom_dv,
5352  double* df_vmom_dp,
5353  double* df_vmom_du,
5354  double* df_vmom_dv,
5355  double* flux_mass,
5356  double* flux_umom,
5357  double* flux_vmom,
5358  double* dflux_mass_dp,
5359  double* dflux_mass_du,
5360  double* dflux_mass_dv,
5361  double* dflux_umom_dp,
5362  double* dflux_umom_du,
5363  double* dflux_umom_dv,
5364  double* dflux_vmom_dp,
5365  double* dflux_vmom_du,
5366  double* dflux_vmom_dv,
5367  double* velocity)
5368 {
5369  int ebNE,k;
5370  double flowDirection;
5371  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
5372  {
5373  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5374  {
5375  flux_mass[ebNE*nQuadraturePoints_elementBoundary+
5376  k] = 0.0;
5377  dflux_mass_du[ebNE*nQuadraturePoints_elementBoundary+
5378  k] = 0.0;
5379  dflux_mass_dv[ebNE*nQuadraturePoints_elementBoundary+
5380  k] = 0.0;
5381 
5382  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
5383  k] = 0.0;
5384  dflux_umom_dp[ebNE*nQuadraturePoints_elementBoundary+
5385  k] = 0.0;
5386  dflux_umom_du[ebNE*nQuadraturePoints_elementBoundary+
5387  k] = 0.0;
5388  dflux_umom_dv[ebNE*nQuadraturePoints_elementBoundary+
5389  k] = 0.0;
5390 
5391  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
5392  k] = 0.0;
5393  dflux_vmom_dp[ebNE*nQuadraturePoints_elementBoundary+
5394  k] = 0.0;
5395  dflux_vmom_du[ebNE*nQuadraturePoints_elementBoundary+
5396  k] = 0.0;
5397  dflux_vmom_dv[ebNE*nQuadraturePoints_elementBoundary+
5398  k] = 0.0;
5399 
5400  flowDirection=n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5401  k*nSpace+
5402  0]
5403  *
5404  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5405  k*nSpace+
5406  0]
5407  +
5408  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5409  k*nSpace+
5410  1]
5411  *
5412  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5413  k*nSpace+
5414  1];
5415  if (isDOFBoundary_u[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
5416  {
5417  flux_mass[ebNE*nQuadraturePoints_elementBoundary+
5418  k]
5419  +=
5420  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5421  k*nSpace+
5422  0]
5423  *
5424  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5425  k*nSpace+
5426  0];
5427  velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5428  k*nSpace+
5429  0]
5430  =
5431  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5432  k*nSpace+
5433  0];
5434  dflux_mass_du[ebNE*nQuadraturePoints_elementBoundary+
5435  k]
5436  +=
5437  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5438  k*nSpace+
5439  0]
5440  *
5441  df_mass_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5442  k*nSpace+
5443  0];
5444  if (flowDirection >= 0.0)
5445  {
5446  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
5447  k]
5448  +=
5449  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5450  k*nSpace+
5451  0]
5452  *
5453  f_umom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5454  k*nSpace+
5455  0];
5456  dflux_umom_du[ebNE*nQuadraturePoints_elementBoundary+
5457  k]
5458  +=
5459  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5460  k*nSpace+
5461  0]
5462  *
5463  df_umom_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5464  k*nSpace+
5465  0];
5466  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
5467  k]
5468  +=
5469  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5470  k*nSpace+
5471  0]
5472  *
5473  f_vmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5474  k*nSpace+
5475  0];
5476  dflux_vmom_du[ebNE*nQuadraturePoints_elementBoundary+
5477  k]
5478  +=
5479  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5480  k*nSpace+
5481  0]
5482  *
5483  df_vmom_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5484  k*nSpace+
5485  0];
5486  dflux_vmom_dv[ebNE*nQuadraturePoints_elementBoundary+
5487  k]
5488  +=
5489  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5490  k*nSpace+
5491  0]
5492  *
5493  df_vmom_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5494  k*nSpace+
5495  0];
5496  }
5497  }
5498  else
5499  {
5500  flux_mass[ebNE*nQuadraturePoints_elementBoundary+
5501  k]
5502  +=
5503  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5504  k*nSpace+
5505  0]
5506  *
5507  bc_f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5508  k*nSpace+
5509  0];
5510  velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5511  k*nSpace+
5512  0]
5513  =
5514  bc_f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5515  k*nSpace+
5516  0];
5517  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
5518  k]
5519  +=
5520  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5521  k*nSpace+
5522  0]
5523  *
5524  bc_f_umom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5525  k*nSpace+
5526  0];
5527  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
5528  k]
5529  +=
5530  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5531  k*nSpace+
5532  0]
5533  *
5534  bc_f_vmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5535  k*nSpace+
5536  0];
5537  if (isDOFBoundary_v[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
5538  dflux_vmom_dv[ebNE*nQuadraturePoints_elementBoundary+
5539  k]
5540  +=
5541  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5542  k*nSpace+
5543  0]
5544  *
5545  df_vmom_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5546  k*nSpace+
5547  0];
5548  }
5549  if (isDOFBoundary_v[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
5550  {
5551  flux_mass[ebNE*nQuadraturePoints_elementBoundary+
5552  k]
5553  +=
5554  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5555  k*nSpace+
5556  1]
5557  *
5558  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5559  k*nSpace+
5560  1];
5561  velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5562  k*nSpace+
5563  1]
5564  =
5565  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5566  k*nSpace+
5567  1];
5568  dflux_mass_dv[ebNE*nQuadraturePoints_elementBoundary+
5569  k]
5570  +=
5571  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5572  k*nSpace+
5573  1]
5574  *
5575  df_mass_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5576  k*nSpace+
5577  1];
5578  if (flowDirection >= 0.0)
5579  {
5580  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
5581  k]
5582  +=
5583  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5584  k*nSpace+
5585  1]
5586  *
5587  f_umom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5588  k*nSpace+
5589  1];
5590  dflux_umom_du[ebNE*nQuadraturePoints_elementBoundary+
5591  k]
5592  +=
5593  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5594  k*nSpace+
5595  1]
5596  *
5597  df_umom_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5598  k*nSpace+
5599  1];
5600  dflux_umom_dv[ebNE*nQuadraturePoints_elementBoundary+
5601  k]
5602  +=
5603  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5604  k*nSpace+
5605  1]
5606  *
5607  df_umom_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5608  k*nSpace+
5609  1];
5610  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
5611  k]
5612  +=
5613  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5614  k*nSpace+
5615  1]
5616  *
5617  f_vmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5618  k*nSpace+
5619  1];
5620  dflux_vmom_dv[ebNE*nQuadraturePoints_elementBoundary+
5621  k]
5622  += n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5623  k*nSpace+
5624  1]
5625  *
5626  df_vmom_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5627  k*nSpace+
5628  1];
5629  }
5630  }
5631  else
5632  {
5633  flux_mass[ebNE*nQuadraturePoints_elementBoundary+
5634  k]
5635  +=
5636  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5637  k*nSpace+
5638  1]
5639  *
5640  bc_f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5641  k*nSpace+
5642  1];
5643  velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5644  k*nSpace+
5645  1]
5646  =
5647  bc_f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5648  k*nSpace+
5649  1];
5650 
5651  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
5652  k]
5653  +=
5654  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5655  k*nSpace+
5656  1]
5657  *
5658  bc_f_umom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5659  k*nSpace+
5660  1];
5661  if (isDOFBoundary_u[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
5662  dflux_umom_du[ebNE*nQuadraturePoints_elementBoundary+
5663  k]
5664  +=
5665  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5666  k*nSpace+
5667  1]
5668  *
5669  df_umom_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5670  k*nSpace+
5671  1];
5672  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
5673  k]
5674  +=
5675  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5676  k*nSpace+
5677  1]
5678  *
5679  bc_f_vmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5680  k*nSpace+
5681  1];
5682  }
5683  if (isDOFBoundary_p[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
5684  {
5685  /* flux_mass[ebNE*nQuadraturePoints_elementBoundary+ */
5686  /* k] */
5687  /* += */
5688  /* oneByRho[ebNE*nQuadraturePoints_elementBoundary+ */
5689  /* k]*(bc_p[ebNE*nQuadraturePoints_elementBoundary+ */
5690  /* k] */
5691  /* - */
5692  /* p[ebNE*nQuadraturePoints_elementBoundary+ */
5693  /* k]); */
5694  /* dflux_mass_dp[ebNE*nQuadraturePoints_elementBoundary+ */
5695  /* k] */
5696  /* = -oneByRho[ebNE*nQuadraturePoints_elementBoundary+ */
5697  /* k]; */
5698  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
5699  k]
5700  +=
5701  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5702  k*nSpace+
5703  0]
5704  *
5705  (bc_p[ebNE*nQuadraturePoints_elementBoundary+
5706  k]
5707  -
5708  p[ebNE*nQuadraturePoints_elementBoundary+
5709  k]);
5710  dflux_umom_dp[ebNE*nQuadraturePoints_elementBoundary+
5711  k]
5712  = -n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5713  k*nSpace+
5714  0];
5715  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
5716  k]
5717  += n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5718  k*nSpace+
5719  1]
5720  *
5721  (bc_p[ebNE*nQuadraturePoints_elementBoundary+
5722  k]
5723  -
5724  p[ebNE*nQuadraturePoints_elementBoundary+
5725  k]);
5726  dflux_vmom_dp[ebNE*nQuadraturePoints_elementBoundary+
5727  k]
5728  = -n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5729  k*nSpace+
5730  1];
5731  }
5732  }
5733  }
5734 }
5735 void calculateGlobalExteriorNumericalAdvectiveFluxNavierStokes3D(int nExteriorElementBoundaries_global,
5736  int nQuadraturePoints_elementBoundary,
5737  int nSpace,
5738  int* exteriorElementBoundaries,
5739  int* elementBoundaryElements,
5740  int* elementBoundaryLocalElementBoundaries,
5741  int *isDOFBoundary_p,
5742  int *isDOFBoundary_u,
5743  int *isDOFBoundary_v,
5744  int *isDOFBoundary_w,
5745  double* n,
5746  double* bc_p,
5747  double* bc_f_mass,
5748  double* bc_f_umom,
5749  double* bc_f_vmom,
5750  double* bc_f_wmom,
5751  double* p,
5752  double* f_mass,
5753  double* f_umom,
5754  double* f_vmom,
5755  double* f_wmom,
5756  double* df_mass_du,
5757  double* df_mass_dv,
5758  double* df_mass_dw,
5759  double* df_umom_dp,
5760  double* df_umom_du,
5761  double* df_umom_dv,
5762  double* df_umom_dw,
5763  double* df_vmom_dp,
5764  double* df_vmom_du,
5765  double* df_vmom_dv,
5766  double* df_vmom_dw,
5767  double* df_wmom_dp,
5768  double* df_wmom_du,
5769  double* df_wmom_dv,
5770  double* df_wmom_dw,
5771  double* flux_mass,
5772  double* flux_umom,
5773  double* flux_vmom,
5774  double* flux_wmom,
5775  double* dflux_mass_du,
5776  double* dflux_mass_dv,
5777  double* dflux_mass_dw,
5778  double* dflux_umom_dp,
5779  double* dflux_umom_du,
5780  double* dflux_umom_dv,
5781  double* dflux_umom_dw,
5782  double* dflux_vmom_dp,
5783  double* dflux_vmom_du,
5784  double* dflux_vmom_dv,
5785  double* dflux_vmom_dw,
5786  double* dflux_wmom_dp,
5787  double* dflux_wmom_du,
5788  double* dflux_wmom_dv,
5789  double* dflux_wmom_dw,
5790  double* velocity)
5791 {
5792  int ebNE,k;
5793  double flowDirection;
5794  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
5795  {
5796  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5797  {
5798  flux_mass[ebNE*nQuadraturePoints_elementBoundary+
5799  k] = 0.0;
5800  dflux_mass_du[ebNE*nQuadraturePoints_elementBoundary+
5801  k] = 0.0;
5802  dflux_mass_dv[ebNE*nQuadraturePoints_elementBoundary+
5803  k] = 0.0;
5804  dflux_mass_dw[ebNE*nQuadraturePoints_elementBoundary+
5805  k] = 0.0;
5806 
5807  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
5808  k] = 0.0;
5809  dflux_umom_dp[ebNE*nQuadraturePoints_elementBoundary+
5810  k] = 0.0;
5811  dflux_umom_du[ebNE*nQuadraturePoints_elementBoundary+
5812  k] = 0.0;
5813  dflux_umom_dv[ebNE*nQuadraturePoints_elementBoundary+
5814  k] = 0.0;
5815  dflux_umom_dw[ebNE*nQuadraturePoints_elementBoundary+
5816  k] = 0.0;
5817 
5818  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
5819  k] = 0.0;
5820  dflux_vmom_dp[ebNE*nQuadraturePoints_elementBoundary+
5821  k] = 0.0;
5822  dflux_vmom_du[ebNE*nQuadraturePoints_elementBoundary+
5823  k] = 0.0;
5824  dflux_vmom_dv[ebNE*nQuadraturePoints_elementBoundary+
5825  k] = 0.0;
5826  dflux_vmom_dw[ebNE*nQuadraturePoints_elementBoundary+
5827  k] = 0.0;
5828 
5829  flux_wmom[ebNE*nQuadraturePoints_elementBoundary+
5830  k] = 0.0;
5831  dflux_wmom_dp[ebNE*nQuadraturePoints_elementBoundary+
5832  k] = 0.0;
5833  dflux_wmom_du[ebNE*nQuadraturePoints_elementBoundary+
5834  k] = 0.0;
5835  dflux_wmom_dv[ebNE*nQuadraturePoints_elementBoundary+
5836  k] = 0.0;
5837  dflux_wmom_dw[ebNE*nQuadraturePoints_elementBoundary+
5838  k] = 0.0;
5839 
5840  flowDirection=n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5841  k*nSpace+
5842  0]
5843  *
5844  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5845  k*nSpace+
5846  0]
5847  +
5848  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5849  k*nSpace+
5850  1]
5851  *
5852  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5853  k*nSpace+
5854  1]+
5855  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5856  k*nSpace+
5857  2]
5858  *
5859  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5860  k*nSpace+
5861  2];
5862  if (isDOFBoundary_u[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
5863  {
5864  flux_mass[ebNE*nQuadraturePoints_elementBoundary+
5865  k]
5866  +=
5867  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5868  k*nSpace+
5869  0]
5870  *
5871  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5872  k*nSpace+
5873  0];
5874  velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5875  k*nSpace+
5876  0]
5877  =
5878  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5879  k*nSpace+
5880  0];
5881  dflux_mass_du[ebNE*nQuadraturePoints_elementBoundary+
5882  k]
5883  +=
5884  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5885  k*nSpace+
5886  0]
5887  *
5888  df_mass_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5889  k*nSpace+
5890  0];
5891  if (flowDirection >= 0.0)
5892  {
5893  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
5894  k]
5895  +=
5896  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5897  k*nSpace+
5898  0]
5899  *
5900  f_umom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5901  k*nSpace+
5902  0];
5903  dflux_umom_du[ebNE*nQuadraturePoints_elementBoundary+
5904  k]
5905  +=
5906  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5907  k*nSpace+
5908  0]
5909  *
5910  df_umom_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5911  k*nSpace+
5912  0];
5913  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
5914  k]
5915  +=
5916  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5917  k*nSpace+
5918  0]
5919  *
5920  f_vmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5921  k*nSpace+
5922  0];
5923  dflux_vmom_du[ebNE*nQuadraturePoints_elementBoundary+
5924  k]
5925  +=
5926  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5927  k*nSpace+
5928  0]
5929  *
5930  df_vmom_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5931  k*nSpace+
5932  0];
5933  dflux_vmom_dv[ebNE*nQuadraturePoints_elementBoundary+
5934  k]
5935  +=
5936  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5937  k*nSpace+
5938  0]
5939  *
5940  df_vmom_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5941  k*nSpace+
5942  0];
5943  flux_wmom[ebNE*nQuadraturePoints_elementBoundary+
5944  k]
5945  +=
5946  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5947  k*nSpace+
5948  0]
5949  *
5950  f_wmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5951  k*nSpace+
5952  0];
5953  dflux_wmom_du[ebNE*nQuadraturePoints_elementBoundary+
5954  k]
5955  +=
5956  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5957  k*nSpace+
5958  0]
5959  *
5960  df_wmom_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5961  k*nSpace+
5962  0];
5963  dflux_wmom_dw[ebNE*nQuadraturePoints_elementBoundary+
5964  k]
5965  +=
5966  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5967  k*nSpace+
5968  0]
5969  *
5970  df_wmom_dw[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5971  k*nSpace+
5972  0];
5973  }
5974  }
5975  else
5976  {
5977  flux_mass[ebNE*nQuadraturePoints_elementBoundary+
5978  k]
5979  +=
5980  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5981  k*nSpace+
5982  0]
5983  *
5984  bc_f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5985  k*nSpace+
5986  0];
5987  velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5988  k*nSpace+
5989  0]
5990  =
5991  bc_f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5992  k*nSpace+
5993  0];
5994  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
5995  k]
5996  +=
5997  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
5998  k*nSpace+
5999  0]
6000  *
6001  bc_f_umom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6002  k*nSpace+
6003  0];
6004  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
6005  k]
6006  +=
6007  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6008  k*nSpace+
6009  0]
6010  *
6011  bc_f_vmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6012  k*nSpace+
6013  0];
6014  if (isDOFBoundary_v[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6015  dflux_vmom_dv[ebNE*nQuadraturePoints_elementBoundary+
6016  k]
6017  +=
6018  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6019  k*nSpace+
6020  0]
6021  *
6022  df_vmom_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6023  k*nSpace+
6024  0];
6025  flux_wmom[ebNE*nQuadraturePoints_elementBoundary+
6026  k]
6027  +=
6028  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6029  k*nSpace+
6030  0]
6031  *
6032  bc_f_wmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6033  k*nSpace+
6034  0];
6035  if (isDOFBoundary_w[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6036  dflux_wmom_dw[ebNE*nQuadraturePoints_elementBoundary+
6037  k]
6038  +=
6039  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6040  k*nSpace+
6041  0]
6042  *
6043  df_wmom_dw[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6044  k*nSpace+
6045  0];
6046  }
6047  if (isDOFBoundary_v[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6048  {
6049  flux_mass[ebNE*nQuadraturePoints_elementBoundary+
6050  k]
6051  +=
6052  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6053  k*nSpace+
6054  1]
6055  *
6056  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6057  k*nSpace+
6058  1];
6059  velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6060  k*nSpace+
6061  1]
6062  =
6063  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6064  k*nSpace+
6065  1];
6066  dflux_mass_dv[ebNE*nQuadraturePoints_elementBoundary+
6067  k]
6068  +=
6069  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6070  k*nSpace+
6071  1]
6072  *
6073  df_mass_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6074  k*nSpace+
6075  1];
6076  if (flowDirection >= 0.0)
6077  {
6078  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
6079  k]
6080  +=
6081  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6082  k*nSpace+
6083  1]
6084  *
6085  f_umom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6086  k*nSpace+
6087  1];
6088  dflux_umom_du[ebNE*nQuadraturePoints_elementBoundary+
6089  k]
6090  +=
6091  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6092  k*nSpace+
6093  1]
6094  *
6095  df_umom_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6096  k*nSpace+
6097  1];
6098  dflux_umom_dv[ebNE*nQuadraturePoints_elementBoundary+
6099  k]
6100  +=
6101  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6102  k*nSpace+
6103  1]
6104  *
6105  df_umom_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6106  k*nSpace+
6107  1];
6108  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
6109  k]
6110  +=
6111  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6112  k*nSpace+
6113  1]
6114  *
6115  f_vmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6116  k*nSpace+
6117  1];
6118  dflux_vmom_dv[ebNE*nQuadraturePoints_elementBoundary+
6119  k]
6120  += n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6121  k*nSpace+
6122  1]
6123  *
6124  df_vmom_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6125  k*nSpace+
6126  1];
6127  flux_wmom[ebNE*nQuadraturePoints_elementBoundary+
6128  k]
6129  +=
6130  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6131  k*nSpace+
6132  1]
6133  *
6134  f_wmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6135  k*nSpace+
6136  1];
6137  dflux_wmom_dw[ebNE*nQuadraturePoints_elementBoundary+
6138  k]
6139  +=
6140  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6141  k*nSpace+
6142  1]
6143  *
6144  df_wmom_dw[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6145  k*nSpace+
6146  1];
6147  dflux_wmom_dv[ebNE*nQuadraturePoints_elementBoundary+
6148  k]
6149  +=
6150  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6151  k*nSpace+
6152  1]
6153  *
6154  df_wmom_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6155  k*nSpace+
6156  1];
6157  }
6158  }
6159  else
6160  {
6161  flux_mass[ebNE*nQuadraturePoints_elementBoundary+
6162  k]
6163  +=
6164  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6165  k*nSpace+
6166  1]
6167  *
6168  bc_f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6169  k*nSpace+
6170  1];
6171  velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6172  k*nSpace+
6173  1]
6174  =
6175  bc_f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6176  k*nSpace+
6177  1];
6178  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
6179  k]
6180  +=
6181  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6182  k*nSpace+
6183  1]
6184  *
6185  bc_f_umom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6186  k*nSpace+
6187  1];
6188  if (isDOFBoundary_u[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6189  dflux_umom_du[ebNE*nQuadraturePoints_elementBoundary+
6190  k]
6191  +=
6192  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6193  k*nSpace+
6194  1]
6195  *
6196  df_umom_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6197  k*nSpace+
6198  1];
6199  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
6200  k]
6201  +=
6202  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6203  k*nSpace+
6204  1]
6205  *
6206  bc_f_vmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6207  k*nSpace+
6208  1];
6209  flux_wmom[ebNE*nQuadraturePoints_elementBoundary+
6210  k]
6211  +=
6212  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6213  k*nSpace+
6214  1]
6215  *
6216  bc_f_wmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6217  k*nSpace+
6218  1];
6219  if (isDOFBoundary_w[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6220  dflux_wmom_dw[ebNE*nQuadraturePoints_elementBoundary+
6221  k]
6222  +=
6223  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6224  k*nSpace+
6225  1]
6226  *
6227  df_wmom_dw[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6228  k*nSpace+
6229  1];
6230  }
6231  if (isDOFBoundary_w[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6232  {
6233  flux_mass[ebNE*nQuadraturePoints_elementBoundary+
6234  k]
6235  +=
6236  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6237  k*nSpace+
6238  2]
6239  *
6240  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6241  k*nSpace+
6242  2];
6243  velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6244  k*nSpace+
6245  2]
6246  =
6247  f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6248  k*nSpace+
6249  2];
6250  dflux_mass_dw[ebNE*nQuadraturePoints_elementBoundary+
6251  k]
6252  +=
6253  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6254  k*nSpace+
6255  2]
6256  *
6257  df_mass_dw[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6258  k*nSpace+
6259  2];
6260  if (flowDirection >= 0.0)
6261  {
6262  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
6263  k]
6264  +=
6265  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6266  k*nSpace+
6267  2]
6268  *
6269  f_umom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6270  k*nSpace+
6271  2];
6272  dflux_umom_du[ebNE*nQuadraturePoints_elementBoundary+
6273  k]
6274  +=
6275  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6276  k*nSpace+
6277  2]
6278  *
6279  df_umom_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6280  k*nSpace+
6281  2];
6282  dflux_umom_dw[ebNE*nQuadraturePoints_elementBoundary+
6283  k]
6284  +=
6285  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6286  k*nSpace+
6287  2]
6288  *
6289  df_umom_dw[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6290  k*nSpace+
6291  2];
6292  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
6293  k]
6294  +=
6295  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6296  k*nSpace+
6297  2]
6298  *
6299  f_vmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6300  k*nSpace+
6301  2];
6302  dflux_vmom_dv[ebNE*nQuadraturePoints_elementBoundary+
6303  k]
6304  += n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6305  k*nSpace+
6306  2]
6307  *
6308  df_vmom_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6309  k*nSpace+
6310  2];
6311  dflux_vmom_dw[ebNE*nQuadraturePoints_elementBoundary+
6312  k]
6313  += n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6314  k*nSpace+
6315  2]
6316  *
6317  df_vmom_dw[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6318  k*nSpace+
6319  2];
6320  flux_wmom[ebNE*nQuadraturePoints_elementBoundary+
6321  k]
6322  +=
6323  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6324  k*nSpace+
6325  2]
6326  *
6327  f_wmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6328  k*nSpace+
6329  2];
6330  dflux_wmom_dw[ebNE*nQuadraturePoints_elementBoundary+
6331  k]
6332  +=
6333  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6334  k*nSpace+
6335  2]
6336  *
6337  df_wmom_dw[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6338  k*nSpace+
6339  2];
6340  }
6341  }
6342  else
6343  {
6344  flux_mass[ebNE*nQuadraturePoints_elementBoundary+
6345  k]
6346  +=
6347  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6348  k*nSpace+
6349  2]
6350  *
6351  bc_f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6352  k*nSpace+
6353  2];
6354  velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6355  k*nSpace+
6356  2]
6357  =
6358  bc_f_mass[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6359  k*nSpace+
6360  2];
6361  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
6362  k]
6363  +=
6364  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6365  k*nSpace+
6366  2]
6367  *
6368  bc_f_umom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6369  k*nSpace+
6370  2];
6371  if (isDOFBoundary_u[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6372  dflux_umom_du[ebNE*nQuadraturePoints_elementBoundary+
6373  k]
6374  +=
6375  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6376  k*nSpace+
6377  2]
6378  *
6379  df_umom_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6380  k*nSpace+
6381  2];
6382  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
6383  k]
6384  +=
6385  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6386  k*nSpace+
6387  2]
6388  *
6389  bc_f_vmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6390  k*nSpace+
6391  2];
6392  if (isDOFBoundary_v[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6393  dflux_vmom_dv[ebNE*nQuadraturePoints_elementBoundary+
6394  k]
6395  +=
6396  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6397  k*nSpace+
6398  2]
6399  *
6400  df_vmom_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6401  k*nSpace+
6402  2];
6403  flux_wmom[ebNE*nQuadraturePoints_elementBoundary+
6404  k]
6405  +=
6406  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6407  k*nSpace+
6408  2]
6409  *
6410  bc_f_wmom[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6411  k*nSpace+
6412  2];
6413  }
6414  if (isDOFBoundary_p[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
6415  {
6416  flux_umom[ebNE*nQuadraturePoints_elementBoundary+
6417  k]
6418  +=
6419  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6420  k*nSpace+
6421  0]
6422  *
6423  (bc_p[ebNE*nQuadraturePoints_elementBoundary+
6424  k]
6425  -
6426  p[ebNE*nQuadraturePoints_elementBoundary+
6427  k]);
6428  dflux_umom_dp[ebNE*nQuadraturePoints_elementBoundary+
6429  k]
6430  = -n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6431  k*nSpace+
6432  0];
6433  flux_vmom[ebNE*nQuadraturePoints_elementBoundary+
6434  k]
6435  += n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6436  k*nSpace+
6437  1]
6438  *
6439  (bc_p[ebNE*nQuadraturePoints_elementBoundary+
6440  k]
6441  -
6442  p[ebNE*nQuadraturePoints_elementBoundary+
6443  k]);
6444  dflux_vmom_dp[ebNE*nQuadraturePoints_elementBoundary+
6445  k]
6446  = -n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6447  k*nSpace+
6448  1];
6449  flux_wmom[ebNE*nQuadraturePoints_elementBoundary+
6450  k]
6451  += n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6452  k*nSpace+
6453  2]
6454  *
6455  (bc_p[ebNE*nQuadraturePoints_elementBoundary+
6456  k]
6457  -
6458  p[ebNE*nQuadraturePoints_elementBoundary+
6459  k]);
6460  dflux_wmom_dp[ebNE*nQuadraturePoints_elementBoundary+
6461  k]
6462  = -n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6463  k*nSpace+
6464  2];
6465  }
6466  }
6467  }
6468 }
6472 void calculateGlobalExteriorNumericalAdvectiveFluxStokesP2D(int nExteriorElementBoundaries_global,
6473  int nQuadraturePoints_elementBoundary,
6474  int nSpace,
6475  int* exteriorElementBoundaries,
6476  int* elementBoundaryElements,
6477  int* elementBoundaryLocalElementBoundaries,
6478  int *isDOFBoundary_p,
6479  int *isDOFBoundary_u,
6480  int *isDOFBoundary_v,
6481  double* n,
6482  double* bc_f,
6483  double* bc_fpu,
6484  double* bc_fpv,
6485  double* f,
6486  double* fpu,
6487  double* fpv,
6488  double* df_du,
6489  double* df_dv,
6490  double* dfpu_dp,
6491  double* dfpv_dp,
6492  double* flux,
6493  double* fluxpu,
6494  double* fluxpv,
6495  double* dflux_du,
6496  double* dflux_dv,
6497  double* dfluxpu_dp,
6498  double* dfluxpv_dp)
6499 {
6500  int ebNE,k;
6501  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
6502  {
6503  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
6504  {
6505  fluxpu[ebNE*nQuadraturePoints_elementBoundary+
6506  k] = 0.0;
6507  fluxpv[ebNE*nQuadraturePoints_elementBoundary+
6508  k] = 0.0;
6509  flux[ebNE*nQuadraturePoints_elementBoundary+
6510  k] = 0.0;
6511 
6512  //u and v momentum fluxes due to pressure
6513  if (isDOFBoundary_p[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6514  {
6515  dfluxpu_dp[ebNE*nQuadraturePoints_elementBoundary+
6516  k]
6517  =
6518  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6519  k*nSpace+
6520  0]
6521  *
6522  dfpu_dp[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6523  k*nSpace+
6524  0];
6525  fluxpu[ebNE*nQuadraturePoints_elementBoundary+
6526  k]+=
6527  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6528  k*nSpace+
6529  0]
6530  *
6531  fpu[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6532  k*nSpace+
6533  0];
6534  dfluxpv_dp[ebNE*nQuadraturePoints_elementBoundary+
6535  k]
6536  =
6537  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6538  k*nSpace+
6539  1]
6540  *
6541  dfpv_dp[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6542  k*nSpace+
6543  1];
6544  fluxpv[ebNE*nQuadraturePoints_elementBoundary+
6545  k]+=
6546  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6547  k*nSpace+
6548  1]
6549  *
6550  fpv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6551  k*nSpace+
6552  1];
6553  }
6554  else
6555  {
6556  fluxpu[ebNE*nQuadraturePoints_elementBoundary+
6557  k]+=
6558  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6559  k*nSpace+
6560  0]
6561  *
6562  bc_fpu[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6563  k*nSpace+
6564  0];
6565  fluxpv[ebNE*nQuadraturePoints_elementBoundary+
6566  k]+=
6567  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6568  k*nSpace+
6569  1]
6570  *
6571  bc_fpv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6572  k*nSpace+
6573  1];
6574  }
6575  //mass flux
6576  if (isDOFBoundary_u[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6577  {
6578  dflux_du[ebNE*nQuadraturePoints_elementBoundary+
6579  k]
6580  =
6581  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6582  k*nSpace+
6583  0]
6584  *
6585  df_du[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6586  k*nSpace+
6587  0];
6588  flux[ebNE*nQuadraturePoints_elementBoundary+
6589  k]+=
6590  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6591  k*nSpace+
6592  0]
6593  *
6594  f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6595  k*nSpace+
6596  0];
6597  }
6598  else
6599  {
6600  flux[ebNE*nQuadraturePoints_elementBoundary+
6601  k]+=
6602  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6603  k*nSpace+
6604  0]
6605  *
6606  bc_f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6607  k*nSpace+
6608  0];
6609  }
6610  if (isDOFBoundary_v[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6611  {
6612  dflux_dv[ebNE*nQuadraturePoints_elementBoundary+
6613  k]
6614  =
6615  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6616  k*nSpace+
6617  1]
6618  *
6619  df_dv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6620  k*nSpace+
6621  1];
6622  flux[ebNE*nQuadraturePoints_elementBoundary+
6623  k]+=
6624  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6625  k*nSpace+
6626  1]
6627  *
6628  f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6629  k*nSpace+
6630  1];
6631  }
6632  else
6633  {
6634  flux[ebNE*nQuadraturePoints_elementBoundary+
6635  k]+=
6636  n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6637  k*nSpace+
6638  1]
6639  *
6640  bc_f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6641  k*nSpace+
6642  1];
6643  }
6644  }
6645  }
6646 }
6650 void calculateExteriorNumericalAdvectiveFluxStokesP3D(int nExteriorElementBoundaries_global,
6651  int nElementBoundaries_element,
6652  int nQuadraturePoints_elementBoundary,
6653  int nSpace,
6654  int* exteriorElementBoundaries,
6655  int* elementBoundaryElements,
6656  int* elementBoundaryLocalElementBoundaries,
6657  int *isDOFBoundary_p,
6658  int *isDOFBoundary_u,
6659  int *isDOFBoundary_v,
6660  int *isDOFBoundary_w,
6661  double* n,
6662  double* bc_f,
6663  double* bc_fpu,
6664  double* bc_fpv,
6665  double* bc_fpw,
6666  double* f,
6667  double* fpu,
6668  double* fpv,
6669  double* fpw,
6670  double* df_du,
6671  double* df_dv,
6672  double* df_dw,
6673  double* dfpu_dp,
6674  double* dfpv_dp,
6675  double* dfpw_dp,
6676  double* flux,
6677  double* fluxpu,
6678  double* fluxpv,
6679  double* fluxpw,
6680  double* dflux_du,
6681  double* dflux_dv,
6682  double* dflux_dw,
6683  double* dfluxpu_dp,
6684  double* dfluxpv_dp,
6685  double* dfluxpw_dp)
6686 {
6687  int ebNE,ebN,eN_global,ebN_element,k;
6688  for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
6689  {
6690  ebN = exteriorElementBoundaries[ebNE];
6691  eN_global = elementBoundaryElements[ebN*2+0];
6692  ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
6693  for(k=0;k<nQuadraturePoints_elementBoundary;k++)
6694  {
6695  fluxpu[ebN*nQuadraturePoints_elementBoundary+
6696  k] = 0.0;
6697  fluxpv[ebN*nQuadraturePoints_elementBoundary+
6698  k] = 0.0;
6699  fluxpw[ebN*nQuadraturePoints_elementBoundary+
6700  k] = 0.0;
6701  flux[ebN*nQuadraturePoints_elementBoundary+
6702  k] = 0.0;
6703 
6704  //u, v and w momentum fluxes due to pressure
6705  if (isDOFBoundary_p[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6706  {
6707  dfluxpu_dp[ebN*nQuadraturePoints_elementBoundary+
6708  k]
6709  =
6710  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6711  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6712  k*nSpace+
6713  0]
6714  *
6715  dfpu_dp[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6716  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6717  k*nSpace+
6718  0];
6719  fluxpu[ebN*nQuadraturePoints_elementBoundary+
6720  k]+=
6721  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6722  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6723  k*nSpace+
6724  0]
6725  *
6726  fpu[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6727  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6728  k*nSpace+
6729  0];
6730  dfluxpv_dp[ebN*nQuadraturePoints_elementBoundary+
6731  k]
6732  =
6733  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6734  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6735  k*nSpace+
6736  1]
6737  *
6738  dfpv_dp[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6739  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6740  k*nSpace+
6741  1];
6742  fluxpv[ebN*nQuadraturePoints_elementBoundary+
6743  k]+=
6744  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6745  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6746  k*nSpace+
6747  1]
6748  *
6749  fpv[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6750  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6751  k*nSpace+
6752  1];
6753  dfluxpw_dp[ebN*nQuadraturePoints_elementBoundary+
6754  k]
6755  =
6756  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6757  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6758  k*nSpace+
6759  2]
6760  *
6761  dfpw_dp[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6762  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6763  k*nSpace+
6764  2];
6765  fluxpw[ebN*nQuadraturePoints_elementBoundary+
6766  k]+=
6767  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6768  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6769  k*nSpace+
6770  2]
6771  *
6772  fpw[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6773  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6774  k*nSpace+
6775  2];
6776  }
6777  else
6778  {
6779  fluxpu[ebN*nQuadraturePoints_elementBoundary+
6780  k]+=
6781  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6782  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6783  k*nSpace+
6784  0]
6785  *
6786  bc_fpu[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6787  k*nSpace+
6788  0];
6789  fluxpv[ebN*nQuadraturePoints_elementBoundary+
6790  k]+=
6791  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6792  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6793  k*nSpace+
6794  1]
6795  *
6796  bc_fpv[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6797  k*nSpace+
6798  1];
6799  fluxpw[ebN*nQuadraturePoints_elementBoundary+
6800  k]+=
6801  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6802  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6803  k*nSpace+
6804  2]
6805  *
6806  bc_fpw[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6807  k*nSpace+
6808  2];
6809  }
6810  //mass flux
6811  if (isDOFBoundary_u[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6812  {
6813  dflux_du[ebN*nQuadraturePoints_elementBoundary+
6814  k]
6815  =
6816  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6817  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6818  k*nSpace+
6819  0]
6820  *
6821  df_du[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6822  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6823  k*nSpace+
6824  0];
6825  flux[ebN*nQuadraturePoints_elementBoundary+
6826  k]+=
6827  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6828  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6829  k*nSpace+
6830  0]
6831  *
6832  f[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6833  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6834  k*nSpace+
6835  0];
6836  }
6837  else
6838  {
6839  flux[ebN*nQuadraturePoints_elementBoundary+
6840  k]+=
6841  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6842  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6843  k*nSpace+
6844  0]
6845  *
6846  bc_f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
6847  k*nSpace+
6848  0];
6849  }
6850  if (isDOFBoundary_v[ebNE*nQuadraturePoints_elementBoundary+k] != 1)
6851  {
6852  dflux_dv[ebN*nQuadraturePoints_elementBoundary+
6853  k]
6854  =
6855  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6856  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6857  k*nSpace+
6858  1]
6859  *
6860  df_dv[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6861  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6862  k*nSpace+
6863  1];
6864  flux[ebN*nQuadraturePoints_elementBoundary+
6865  k]+=
6866  n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6867  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6868  k*nSpace+
6869  1]
6870  *
6871  f[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
6872  ebN_element*nQuadraturePoints_elementBoundary*nSpace+
6873  k*nSpace+
6874  1];
6875  }
6876  else
6877  {
6878  flux[ebN*nQuadraturePoints_elementBoun