proteus 1.9.0
C/C++/Fortran libraries
Loading...
Searching...
No Matches
femIntegrals.c
Go to the documentation of this file.
1#include <stdlib.h>
2#include <stdio.h>
3#include <math.h>
4#include <string.h>
5#include <strings.h>
6#include <assert.h>
7#include "femIntegrals.h"
8#include PROTEUS_LAPACK_H
9
19
20void copyLeftElementBoundaryInfo(int nElementBoundaries_element,
21 int nElementBoundaryQuadraturePoints_elementBoundary,
22 int nSpace_global,
23 int nExteriorElementBoundaries_global,
24 int nInteriorElementBoundaries_global,
25 int* elementBoundaryElementsArray,
26 int* elementBoundaryLocalElementBoundariesArray,
27 int* exteriorElementBoundariesArray,
28 int* interiorElementBoundariesArray,
29 double* x,
30 double* n,
31 double* xg,
32 double* ng)
33{
34 int ebNE,ebNI,ebN,k,left_eN_global,left_ebN_element,right_eN_global,right_ebN_element,I;
35 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
36 {
37 ebN = exteriorElementBoundariesArray[ebNE];
38 left_eN_global = elementBoundaryElementsArray[ebN*2+0];
39 left_ebN_element = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
40 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
41 {
42 for (I=0;I<3;I++)
43 xg[ebN*nElementBoundaryQuadraturePoints_elementBoundary*3+
44 k*3+
45 I] =
46 x[left_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
47 left_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
48 k*3+
49 I];
50 for (I=0;I<nSpace_global;I++)
51 ng[ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
52 k*nSpace_global+
53 I] =
54 n[left_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
55 left_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
56 k*nSpace_global+
57 I];
58 }
59 }
60 for (ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
61 {
62 ebN = interiorElementBoundariesArray[ebNI];
63 left_eN_global = elementBoundaryElementsArray[ebN*2+0];
64 left_ebN_element = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
65 right_eN_global = elementBoundaryElementsArray[ebN*2+1];
66 right_ebN_element = elementBoundaryLocalElementBoundariesArray[ebN*2+1];
67 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
68 {
69 for (I=0;I<3;I++)
70 {
71 xg[ebN*nElementBoundaryQuadraturePoints_elementBoundary*3+
72 k*3+
73 I] =
74 x[left_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
75 left_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
76 k*3+
77 I];
78 x[right_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
79 right_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
80 k*3+
81 I]=
82 x[left_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
83 left_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
84 k*3+
85 I];
86 }
87 for (I=0;I<nSpace_global;I++)
88 {
89 ng[ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
90 k*nSpace_global+
91 I] =
92 n[left_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
93 left_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
94 k*nSpace_global+
95 I];
96 n[right_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
97 right_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
98 k*nSpace_global+
99 I]=
100 -n[left_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
101 left_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
102 k*nSpace_global+
103 I];
104 }
105 }
106 }
107}
108
109void copyGlobalElementBoundaryInfo(int nElementBoundaries_element,
110 int nElementBoundaryQuadraturePoints_elementBoundary,
111 int nSpace_global,
112 int nExteriorElementBoundaries_global,
113 int nInteriorElementBoundaries_global,
114 int* elementBoundaryElementsArray,
115 int* elementBoundaryLocalElementBoundariesArray,
116 int* exteriorElementBoundariesArray,
117 int* interiorElementBoundariesArray,
118 double* x,
119 double* n,
120 double* ebqe_x,
121 double* ebqe_n,
122 double* xg,
123 double* ng)
124{
125 int ebNE,ebNI,ebN,k,left_eN_global,left_ebN_element,right_eN_global,right_ebN_element,I,J;
126 double dot,sign;
127 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
128 {
129 ebN = exteriorElementBoundariesArray[ebNE];
130 left_eN_global = elementBoundaryElementsArray[ebN*2+0];
131 left_ebN_element = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
132 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
133 {
134 dot=0.0;
135 for (J=0;J<nSpace_global;J++)
136 dot+= ebqe_n[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
137 k*nSpace_global+
138 J]*
139 ng[ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
140 k*nSpace_global+
141 J];
142 if(dot < 0.0)
143 sign=-1.0;
144 else
145 sign=1.0;
146
147 for (I=0;I<3;I++)
148 {
149 x[left_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
150 left_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
151 k*3+
152 I] = xg[ebN*nElementBoundaryQuadraturePoints_elementBoundary*3+
153 k*3+
154 I];
155 ebqe_x[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*3+
156 k*3+
157 I] = xg[ebN*nElementBoundaryQuadraturePoints_elementBoundary*3+
158 k*3+
159 I];
160 }
161 for (I=0;I<nSpace_global;I++)
162 {
163 n[left_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
164 left_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
165 k*nSpace_global+
166 I] =
167 ng[ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
168 k*nSpace_global+
169 I];
170 ebqe_n[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
171 k*nSpace_global+
172 I]=
173 sign*ng[ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
174 k*nSpace_global+
175 I];
176 }
177 }
178 }
179 for (ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
180 {
181 ebN = interiorElementBoundariesArray[ebNI];
182 left_eN_global = elementBoundaryElementsArray[ebN*2+0];
183 left_ebN_element = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
184 right_eN_global = elementBoundaryElementsArray[ebN*2+1];
185 right_ebN_element = elementBoundaryLocalElementBoundariesArray[ebN*2+1];
186 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
187 {
188 for (I=0;I<3;I++)
189 {
190 x[left_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
191 left_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
192 k*3+
193 I] = xg[ebN*nElementBoundaryQuadraturePoints_elementBoundary*3+
194 k*3+
195 I];
196 x[right_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
197 right_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
198 k*3+
199 I] = xg[ebN*nElementBoundaryQuadraturePoints_elementBoundary*3+
200 k*3+
201 I];
202 }
203 for (I=0;I<nSpace_global;I++)
204 {
205 n[left_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
206 left_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
207 k*nSpace_global+
208 I] = ng[ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
209 k*nSpace_global+
210 I];
211 n[right_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
212 right_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
213 k*nSpace_global+
214 I] = -ng[ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global+
215 k*nSpace_global+
216 I];
217 }
218 }
219 }
220}
221
222void copyLeftElementBoundaryInfo_movingDomain(int nElementBoundaries_element,
223 int nElementBoundaryQuadraturePoints_elementBoundary,
224 int nExteriorElementBoundaries_global,
225 int nInteriorElementBoundaries_global,
226 int* elementBoundaryElementsArray,
227 int* elementBoundaryLocalElementBoundariesArray,
228 int* exteriorElementBoundariesArray,
229 int* interiorElementBoundariesArray,
230 double* xt)
231{
232 int ebNI,ebN,k,left_eN_global,left_ebN_element,right_eN_global,right_ebN_element,I;
233 for (ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
234 {
235 ebN = interiorElementBoundariesArray[ebNI];
236 left_eN_global = elementBoundaryElementsArray[ebN*2+0];
237 left_ebN_element = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
238 right_eN_global = elementBoundaryElementsArray[ebN*2+1];
239 right_ebN_element = elementBoundaryLocalElementBoundariesArray[ebN*2+1];
240 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
241 for (I=0;I<3;I++)
242 {
243 xt[right_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
244 right_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
245 k*3+
246 I]=
247 xt[left_eN_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
248 left_ebN_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
249 k*3+
250 I];
251 }
252 }
253}
254
255void parametricFiniteElementSpace_getValues(int nElements_global,
256 int nQuadraturePoints_element,
257 int nDOF_element,
258 double* psi,
259 double* vArray)
260{
261 int eN,k,j;
262 for(eN=0;eN<nElements_global;eN++)
263 for(k=0;k<nQuadraturePoints_element;k++)
264 for(j=0;j<nDOF_element;j++)
265 vArray[eN*nQuadraturePoints_element*nDOF_element+
266 k*nDOF_element+
267 j]
268 =
269 psi[k*nDOF_element+
270 j];
271}
272
273void parametricFiniteElementSpace_getValuesTrace(int nElements_global,
274 int nElementBoundaries_element,
275 int nElementBoundaryQuadraturePoints_elementBoundary,
276 int nDOF_element,
277 double* psi,
278 int* permutations,
279 double* vArray)
280{
281 int eN,ebN,k,j;
282 for(eN=0;eN<nElements_global;eN++)
283 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
284 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
285 for(j=0;j<nDOF_element;j++)
286 vArray[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
287 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
288 k*nDOF_element+
289 j]
290 =
291 psi[permutations[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary+
292 ebN*nElementBoundaryQuadraturePoints_elementBoundary+
293 k]*nDOF_element+
294 j];
295}
296
297void parametricFiniteElementSpace_getValuesGlobalExteriorTrace(int nElementBoundaries_element,
298 int nElementBoundaryQuadraturePoints_elementBoundary,
299 int nDOF_element,
300 int nExteriorElementBoundaries_global,
301 const int* exteriorElementBoundariesArray,
302 const int* elementBoundaryElementsArray,
303 const int* elementBoundaryLocalElementBoundariesArray,
304 double* psi,
305 double* vArray)
306{
307 int eN,ebN,ebNE,ebN_local,k,j;
308 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
309 {
310 ebN = exteriorElementBoundariesArray[ebNE];
311 eN = elementBoundaryElementsArray[ebN*2+0];
312 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
313 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
314 for(j=0;j<nDOF_element;j++)
315 vArray[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
316 k*nDOF_element+
317 j]
318 =
319 psi[ebN_local*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element +
320 k*nDOF_element +
321 j];
322 }
323}
324
325void parametricFiniteElementSpace_getGradientValues(int nElements_global,
326 int nQuadraturePoints_element,
327 int nDOF_element,
328 int nSpace_global,
329 double* grad_psi,
330 double* inverseJacobianArray,
331 double* grad_vArray)
332{
333 int eN,k,j,I,J,nSpace_global2 = nSpace_global*nSpace_global;
334 for(eN=0;eN<nElements_global;eN++)
335 for(k=0;k<nQuadraturePoints_element;k++)
336 for(j=0;j<nDOF_element;j++)
337 for (I=0;I<nSpace_global;I++)
338 for (J=0;J<nSpace_global;J++)
339 grad_vArray[eN*nQuadraturePoints_element*nDOF_element*nSpace_global+
340 k*nDOF_element*nSpace_global+
341 j*nSpace_global+
342 I]
343 +=
344 grad_psi[k*nDOF_element*nSpace_global+
345 j*nSpace_global+
346 J]
347 *
348 inverseJacobianArray[eN*nQuadraturePoints_element*nSpace_global2+
349 k*nSpace_global2+
350 J*nSpace_global+
351 I];
352}
353
354void parametricFiniteElementSpace_getHessianValues(int nElements_global,
355 int nQuadraturePoints_element,
356 int nDOF_element,
357 int nSpace_global,
358 double* Hessian_psi,
359 double* inverseJacobianArray,
360 double* Hessian_vArray)
361{
362 int eN,k,j,I,J,K,L,nSpace_global2 = nSpace_global*nSpace_global;
363 for(eN=0;eN<nElements_global;eN++)
364 for(k=0;k<nQuadraturePoints_element;k++)
365 for(j=0;j<nDOF_element;j++)
366 for (I=0;I<nSpace_global;I++)
367 for (J=0;J<nSpace_global;J++)
368 for (K=0;K<nSpace_global;K++)
369 for (L=0;L<nSpace_global;L++)
370 Hessian_vArray[eN*nQuadraturePoints_element*nDOF_element*nSpace_global2+
371 k*nDOF_element*nSpace_global2+
372 j*nSpace_global2+
373 I*nSpace_global+
374 J]
375 +=
376 Hessian_psi[k*nDOF_element*nSpace_global2+
377 j*nSpace_global2+
378 K*nSpace_global+
379 L]
380 *
381 inverseJacobianArray[eN*nQuadraturePoints_element*nSpace_global2+
382 k*nSpace_global2+
383 L*nSpace_global+
384 J]
385 *
386 inverseJacobianArray[eN*nQuadraturePoints_element*nSpace_global2+
387 k*nSpace_global2+
388 K*nSpace_global+
389 I];
390}
391
392void parametricFiniteElementSpace_getGradientValuesTrace(int nElements_global,
393 int nElementBoundaries_element,
394 int nElementBoundaryQuadraturePoints_elementBoundary,
395 int nDOF_element,
396 int nSpace_global,
397 double* grad_psi,
398 int* permutations,
399 double* inverseJacobianArray,
400 double* grad_vArray)
401{
402 int eN,ebN,k,j,I,J,nSpace_global2 = nSpace_global*nSpace_global;
403 for(eN=0;eN<nElements_global;eN++)
404 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
405 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
406 for(j=0;j<nDOF_element;j++)
407 for (I=0;I<nSpace_global;I++)
408 for (J=0;J<nSpace_global;J++)
409 grad_vArray[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace_global+
410 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace_global+
411 k*nDOF_element*nSpace_global+
412 j*nSpace_global+
413 I]
414 +=
415 grad_psi[permutations[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary+
416 ebN*nElementBoundaryQuadraturePoints_elementBoundary+
417 k]*nDOF_element*nSpace_global+
418 j*nSpace_global+
419 J]
420 *
421 inverseJacobianArray[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global2+
422 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global2+
423 k*nSpace_global2+
424 J*nSpace_global+
425 I];
426}
427
428void parametricFiniteElementSpace_getGradientValuesGlobalExteriorTrace(int nElementBoundaries_element,
429 int nElementBoundaryQuadraturePoints_elementBoundary,
430 int nDOF_element,
431 int nSpace_global,
432 int nExteriorElementBoundaries_global,
433 const int *exteriorElementBoundariesArray,
434 const int *elementBoundaryElementsArray,
435 const int *elementBoundaryLocalElementBoundariesArray,
436 double* grad_psi,
437 double* inverseJacobianArray,
438 double* grad_vArray)
439{
440 int ebN,ebNE,ebN_local,eN,k,j,I,J,nSpace_global2 = nSpace_global*nSpace_global;
441 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
442 {
443 ebN = exteriorElementBoundariesArray[ebNE];
444 eN = elementBoundaryElementsArray[ebN*2+0];
445 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
446 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
447 for(j=0;j<nDOF_element;j++)
448 for (I=0;I<nSpace_global;I++)
449 for (J=0;J<nSpace_global;J++)
450 grad_vArray[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace_global+
451 k*nDOF_element*nSpace_global+
452 j*nSpace_global+
453 I]
454 +=
455 grad_psi[ebN_local*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace_global+
456 k*nDOF_element*nSpace_global+
457 j*nSpace_global+
458 J]
459 *
460 inverseJacobianArray[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global2+
461 k*nSpace_global2+
462 J*nSpace_global+
463 I];
464 }
465}
466
467void parametricMaps_getPermutations(int nElements_global,
468 int nElementBoundaries_element,
469 int nElementBoundaryQuadraturePoints_elementBoundary,
470 int nSpace_global,
471 double* xiArray,
472 int* permutations)
473{
474 const int kTot=(nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary);
475 int eN,ebN,k,k0,I;
476 register double errorNorm,errorNormMin;
477 /* permutations are relative to the ordering on the first element so the first entries used are the identity*/
478 for (k0=0;k0<kTot;k0++)
479 permutations[k0]=k0;
480 /* now loop over remaining elements and find the permutation used to get to reference points to match*/
481 for (eN=1;eN<nElements_global;eN++)
482 {
483 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
484 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
485 {
486 errorNormMin=1.0;
487 for (k0=0;k0<kTot;k0++)
488 {
489 errorNorm=0.0;
490 for (I=0;I<nSpace_global;I++)
491 {
492 errorNorm += fabs(xiArray[k0*3+I]
493 -
494 xiArray[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
495 ebN*nElementBoundaryQuadraturePoints_elementBoundary*3+
496 k*3+
497 I]);
498 }
499 if (errorNorm < errorNormMin)
500 {
501 permutations[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary+
502 ebN*nElementBoundaryQuadraturePoints_elementBoundary+
503 k] = k0;
504 errorNormMin = errorNorm;
505 }
506 }
507 }
508 }
509}
510void parametricMaps_getPermutationsGlobalExterior(int nElementBoundaryQuadraturePoints_elementBoundary,
511 int nSpace_global,
512 int nExteriorElementBoundaries_global,
513 const int * exteriorElementBoundariesArray,
514 const int * elementBoundaryElementsArray,
515 const int * elementBoundaryLocalElementBoundariesArray,
516 double* xiArray,
517 int* permutations)
518{
519 const int kTot=nElementBoundaryQuadraturePoints_elementBoundary;
520 int eN,ebN,ebNE,ebN_local,k,k0,I;
521 register double errorNorm,errorNormMin;
522 /* permutations are relative to the ordering on the first elementBoundary so the first entries used are the identity*/
523 for (k0=0;k0<kTot;k0++)
524 permutations[k0]=k0;
525 /* loop over exterior elementBoundaries and setup permutation used to get to reference points to match*/
526 for (ebNE = 1; ebNE < nExteriorElementBoundaries_global; ebNE++)
527 {
528 ebN = exteriorElementBoundariesArray[ebNE];
529 eN = elementBoundaryElementsArray[ebN*2+0];
530 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
531 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
532 {
533 errorNormMin=1.0;
534 for (k0=0;k0<kTot;k0++)
535 {
536 errorNorm=0.0;
537 for (I=0;I<nSpace_global;I++)
538 {
539 errorNorm += fabs(xiArray[k0*3+I]
540 -
541 xiArray[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*3+
542 k*3+
543 I]);
544 }
545 if (errorNorm < errorNormMin)
546 {
547 permutations[ebNE*nElementBoundaryQuadraturePoints_elementBoundary+
548 k] = k0;
549 errorNormMin = errorNorm;
550 }
551 }
552 }
553 }
554}
555
556void getPermutationsGlobal(int nElementBoundaries_global,
557 int nElementBoundaryQuadraturePoints_elementBoundary,
558 double* xArray,
559 double* xArrayNew,
560 int* permutations)
561{
562 int ebN,k,k0,I;
563 register double errorNorm,errorNormMin;
564 /* now loop over remaining elements and find the permutation used to get to reference points to match*/
565 for (ebN=0;ebN<nElementBoundaries_global;ebN++)
566 {
567 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
568 {
569 errorNormMin=1.0;
570 for (k0=0;k0<nElementBoundaryQuadraturePoints_elementBoundary;k0++)
571 {
572 errorNorm=0.0;
573 for (I=0;I<3;I++)
574 {
575 errorNorm += fabs(xArrayNew[ebN*nElementBoundaryQuadraturePoints_elementBoundary*3+
576 k0*3+
577 I]
578 -
579 xArray[ebN*nElementBoundaryQuadraturePoints_elementBoundary*3+
580 k*3+
581 I]);
582 }
583 if (errorNorm < errorNormMin)
584 {
585 permutations[ebN*nElementBoundaryQuadraturePoints_elementBoundary+
586 k] = k0;
587 errorNormMin = errorNorm;
588 }
589 }
590 }
591 }
592}
593
594void parametricMaps_getValues(int nElements_global,
595 int nQuadraturePoints_element,
596 int nDOF_element,
597 int nSpace_global,
598 double* psi,
599 int* l2g,
600 double* nodeArray,
601 double* xArray)
602{
603 memset(xArray,0,sizeof(double)*nElements_global*nQuadraturePoints_element*3);
604 int eN,k,j,j_global,I;
605 for(eN=0;eN<nElements_global;eN++)
606 for(k=0;k<nQuadraturePoints_element;k++)
607 for(j=0;j<nDOF_element;j++)
608 {
609 j_global = l2g[eN*nDOF_element+
610 j];
611 for(I=0;I<3;I++)
612 xArray[eN*nQuadraturePoints_element*3+
613 k*3+
614 I]
615 +=
616 psi[k*nDOF_element+
617 j]
618 *
619 nodeArray[j_global*3+
620 I];
621 }
622}
623
624void parametricMaps_getValuesTrace(int nElements_global,
625 int nElementBoundaries_element,
626 int nQuadraturePoints_element,
627 int nDOF_element,
628 int nSpace_global,
629 double* psi,
630 int* l2g,
631 double* nodeArray,
632 double* xArray)
633{
634 memset(xArray,0,sizeof(double)*nElements_global*nElementBoundaries_element*nQuadraturePoints_element*3);
635 int eN,ebN,k,j,j_global,I;
636 for(eN=0;eN<nElements_global;eN++)
637 for(ebN=0;ebN<nElementBoundaries_element;ebN++)
638 for(k=0;k<nQuadraturePoints_element;k++)
639 for(j=0;j<nDOF_element;j++)
640 {
641 j_global = l2g[eN*nDOF_element+
642 j];
643 for(I=0;I<3;I++)
644 xArray[eN*nElementBoundaries_element*nQuadraturePoints_element*3+
645 ebN*nQuadraturePoints_element*3+
646 k*3+
647 I]
648 +=
649 psi[ebN*nQuadraturePoints_element*nDOF_element+
650 k*nDOF_element+
651 j]
652 *
653 nodeArray[j_global*3+
654 I];
655 }
656}
657
658void parametricMaps_getValuesGlobalExteriorTrace(int nQuadraturePoints_elementBoundary,
659 int nDOF_element,
660 int nSpace_global,
661 int nExteriorElementBoundaries_global,
662 const int* exteriorElementBoundariesArray,
663 const int* elementBoundaryElementsArray,
664 const int* elementBoundaryLocalElementBoundariesArray,
665 double* psi,
666 int* l2g,
667 double* nodeArray,
668 double* xArray)
669{
670 memset(xArray,0,sizeof(double)*nExteriorElementBoundaries_global*nQuadraturePoints_elementBoundary*3);
671 int eN,ebN,ebNE,ebN_local,k,j,j_global,I;
672 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
673 {
674 ebN = exteriorElementBoundariesArray[ebNE];
675 eN = elementBoundaryElementsArray[ebN*2 + 0];
676 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2 + 0];
677 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
678 for(j=0;j<nDOF_element;j++)
679 {
680 j_global = l2g[eN*nDOF_element+
681 j];
682 for(I=0;I<3;I++)
683 xArray[ebNE*nQuadraturePoints_elementBoundary*3+
684 k*3+
685 I]
686 +=
687 psi[ebN_local*nQuadraturePoints_elementBoundary*nDOF_element+
688 k*nDOF_element+
689 j]
690 *
691 nodeArray[j_global*3+
692 I];
693 }
694 }
695}
696
697void parametricMaps_getInverseValues(int nElements_global,
698 int nQuadraturePoints_element,
699 int nDOF_element,
700 int nSpace_global,
701 double* inverseJacobian,
702 int* l2g,
703 double* nodeArray,
704 double* xArray,
705 double* xiArray)
706{
707 memset(xiArray,0,sizeof(double)*nElements_global*nQuadraturePoints_element*3);
708 int eN,k,node0,I,J,nSpace_global2=nSpace_global*nSpace_global;
709 double dx[nSpace_global];
710 for(eN=0;eN<nElements_global;eN++)
711 for(k=0;k<nQuadraturePoints_element;k++)
712 {
713 node0 = l2g[eN*nDOF_element];
714 for(I=0;I<nSpace_global;I++)
715 dx[I] =
716 xArray[eN*nQuadraturePoints_element*3+
717 k*3+
718 I]
719 -
720 nodeArray[node0*3+I];
721 for(I=0;I<nSpace_global;I++)
722 for(J=0;J<nSpace_global;J++)
723 xiArray[eN*nQuadraturePoints_element*3+
724 k*3+
725 I]
726 +=
727 inverseJacobian[eN*nQuadraturePoints_element*nSpace_global2+
728 k*nSpace_global2+
729 I*nSpace_global+
730 J]
731 *
732 dx[J];
733 }
734}
735
736void parametricMaps_getInverseValuesTrace(int nElements_global,
737 int nElementBoundaries_element,
738 int nElementBoundaryQuadraturePoints_elementBoundary,
739 int nDOF_element,
740 int nSpace_global,
741 double* inverseJacobian,
742 int* l2g,
743 double* nodeArray,
744 double* xArray,
745 double* xiArray)
746{
747 memset(xiArray,0,sizeof(double)*nElements_global*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3);
748 int eN,ebN,k,node0,I,J,nSpace_global2=nSpace_global*nSpace_global;
749 double dx[nSpace_global];
750 for(eN=0;eN<nElements_global;eN++)
751 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
752 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
753 {
754 node0 = l2g[eN*nDOF_element];
755 for(I=0;I<nSpace_global;I++)
756 dx[I] =
757 xArray[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
758 ebN*nElementBoundaryQuadraturePoints_elementBoundary*3+
759 k*3+
760 I]
761 -
762 nodeArray[node0*3+I];
763 for(I=0;I<nSpace_global;I++)
764 for(J=0;J<nSpace_global;J++)
765 xiArray[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*3+
766 ebN*nElementBoundaryQuadraturePoints_elementBoundary*3+
767 k*3+
768 I]
769 +=
770 inverseJacobian[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global2+
771 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global2+
772 k*nSpace_global2+
773 I*nSpace_global+
774 J]
775 *
776 dx[J];
777 }
778}
779
780void parametricMaps_getInverseValuesGlobalExteriorTrace(int nElementBoundaryQuadraturePoints_elementBoundary,
781 int nDOF_element,
782 int nSpace_global,
783 int nExteriorElementBoundaries_global,
784 const int* exteriorElementBoundariesArray,
785 const int* elementBoundaryElementsArray,
786 const int* elementBoundaryLocalElementBoundariesArray,
787 double* inverseJacobian,
788 int* l2g,
789 double* nodeArray,
790 double* xArray,
791 double* xiArray)
792{
793 memset(xiArray,0,sizeof(double)*nExteriorElementBoundaries_global*nElementBoundaryQuadraturePoints_elementBoundary*3);
794 int eN,ebN,ebNE,ebN_local,k,node0,I,J,nSpace_global2=nSpace_global*nSpace_global;
795 double dx[nSpace_global];
796 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
797 {
798 ebN = exteriorElementBoundariesArray[ebNE];
799 eN = elementBoundaryElementsArray[ebN*2+0];
800 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
801
802 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
803 {
804 node0 = l2g[eN*nDOF_element];
805 for(I=0;I<nSpace_global;I++)
806 dx[I] =
807 xArray[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*3+
808 k*3+
809 I]
810 -
811 nodeArray[node0*3+I];
812 for(I=0;I<nSpace_global;I++)
813 for(J=0;J<nSpace_global;J++)
814 xiArray[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*3+
815 k*3+
816 I]
817 +=
818 inverseJacobian[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nSpace_global2+
819 k*nSpace_global2+
820 I*nSpace_global+
821 J]
822 *
823 dx[J];
824 }
825 }
826}
827
828void parametricMaps_getJacobianValues3D(int nElements_global,
829 int nQuadraturePoints_element,
830 int nDOF_element,
831 double* grad_psi,
832 int* l2g,
833 double* nodeArray,
834 double* jacobianArray,
835 double* jacobianDeterminantArray,
836 double* jacobianInverseArray)
837{
838 int eN,k,j,j_global;
839 const int X=0,Y=1,Z=2,
840 XX=0,XY=1,XZ=2,
841 YX=3,YY=4,YZ=5,
842 ZX=6,ZY=7,ZZ=8;
843 double *jac=NULL,*jacDet=NULL,*jacInv=NULL,*grad=NULL,*node=NULL;
844 register double oneOverJacDet=0.0;
845 for(eN=0;eN<nElements_global;eN++)
846 for(k=0;k<nQuadraturePoints_element;k++)
847 {
848 jac = jacobianArray +
849 eN*nQuadraturePoints_element*9+
850 k*9;
851 jacDet = jacobianDeterminantArray +
852 eN*nQuadraturePoints_element+
853 k;
854 jacInv = jacobianInverseArray +
855 eN*nQuadraturePoints_element*9+
856 k*9;
857 for(j=0;j<nDOF_element;j++)
858 {
859 j_global = l2g[eN*nDOF_element+
860 j];
861 grad = grad_psi + k*nDOF_element*3 + j*3;
862 node = nodeArray + j_global*3;
863 jac[XX] += node[X]*grad[X];
864 jac[XY] += node[X]*grad[Y];
865 jac[XZ] += node[X]*grad[Z];
866 jac[YX] += node[Y]*grad[X];
867 jac[YY] += node[Y]*grad[Y];
868 jac[YZ] += node[Y]*grad[Z];
869 jac[ZX] += node[Z]*grad[X];
870 jac[ZY] += node[Z]*grad[Y];
871 jac[ZZ] += node[Z]*grad[Z];
872 }
873 *jacDet
874 =
875 jac[XX]*(jac[YY]*jac[ZZ] - jac[YZ]*jac[ZY]) -
876 jac[XY]*(jac[YX]*jac[ZZ] - jac[YZ]*jac[ZX]) +
877 jac[XZ]*(jac[YX]*jac[ZY] - jac[YY]*jac[ZX]);
878 oneOverJacDet = 1.0/(*jacDet);
879 jacInv[XX] = oneOverJacDet*(jac[YY]*jac[ZZ] - jac[YZ]*jac[ZY]);
880 jacInv[YX] = oneOverJacDet*(jac[YZ]*jac[ZX] - jac[YX]*jac[ZZ]);
881 jacInv[ZX] = oneOverJacDet*(jac[YX]*jac[ZY] - jac[YY]*jac[ZX]);
882 jacInv[XY] = oneOverJacDet*(jac[ZY]*jac[XZ] - jac[ZZ]*jac[XY]);
883 jacInv[YY] = oneOverJacDet*(jac[ZZ]*jac[XX] - jac[ZX]*jac[XZ]);
884 jacInv[ZY] = oneOverJacDet*(jac[ZX]*jac[XY] - jac[ZY]*jac[XX]);
885 jacInv[XZ] = oneOverJacDet*(jac[XY]*jac[YZ] - jac[XZ]*jac[YY]);
886 jacInv[YZ] = oneOverJacDet*(jac[XZ]*jac[YX] - jac[XX]*jac[YZ]);
887 jacInv[ZZ] = oneOverJacDet*(jac[XX]*jac[YY] - jac[XY]*jac[YX]);
888 }
889}
890
891void parametricMaps_getJacobianValues2D(int nElements_global,
892 int nQuadraturePoints_element,
893 int nDOF_element,
894 double* grad_psi,
895 int* l2g,
896 double* nodeArray,
897 double* jacobianArray,
898 double* jacobianDeterminantArray,
899 double* jacobianInverseArray)
900{
901 int eN,k,j,j_global;
902 const int X=0,Y=1,
903 XX=0,XY=1,
904 YX=2,YY=3;
905 double *jac=NULL,*jacDet=NULL,*jacInv=NULL,*grad=NULL,*node=NULL;
906 register double oneOverJacDet=0.0;
907 for(eN=0;eN<nElements_global;eN++)
908 for(k=0;k<nQuadraturePoints_element;k++)
909 {
910 jac = jacobianArray +
911 eN*nQuadraturePoints_element*4+
912 k*4;
913 jacDet = jacobianDeterminantArray +
914 eN*nQuadraturePoints_element+
915 k;
916 jacInv = jacobianInverseArray +
917 eN*nQuadraturePoints_element*4+
918 k*4;
919 for(j=0;j<nDOF_element;j++)
920 {
921 j_global = l2g[eN*nDOF_element+
922 j];
923 grad = grad_psi + k*nDOF_element*2 + j*2;
924 /* nodes are always 3D */
925 node = nodeArray + j_global*3;
926 jac[XX] += node[X]*grad[X];
927 jac[XY] += node[X]*grad[Y];
928 jac[YX] += node[Y]*grad[X];
929 jac[YY] += node[Y]*grad[Y];
930 }
931 *jacDet
932 =
933 jac[XX]*jac[YY]- jac[XY]*jac[YX];
934 oneOverJacDet = 1.0/(*jacDet);
935 jacInv[XX] = oneOverJacDet*jac[YY];
936 jacInv[YX] = -oneOverJacDet*jac[YX];
937 jacInv[XY] = -oneOverJacDet*jac[XY];
938 jacInv[YY] = oneOverJacDet*jac[XX];
939 }
940}
941
942void parametricMaps_getJacobianValues1D(int nElements_global,
943 int nQuadraturePoints_element,
944 int nDOF_element,
945 double* grad_psi,
946 int* l2g,
947 double* nodeArray,
948 double* jacobianArray,
949 double* jacobianDeterminantArray,
950 double* jacobianInverseArray)
951{
952 int eN,k,j,j_global;
953 const int X=0,
954 XX=0;
955 double *jac=NULL,*jacDet=NULL,*jacInv=NULL,*grad=NULL,*node=NULL;
956 register double oneOverJacDet=0.0;
957 for(eN=0;eN<nElements_global;eN++)
958 for(k=0;k<nQuadraturePoints_element;k++)
959 {
960 jac = jacobianArray +
961 eN*nQuadraturePoints_element+
962 k;
963 jacDet = jacobianDeterminantArray +
964 eN*nQuadraturePoints_element+
965 k;
966 jacInv = jacobianInverseArray +
967 eN*nQuadraturePoints_element+
968 k;
969 for(j=0;j<nDOF_element;j++)
970 {
971 j_global = l2g[eN*nDOF_element+
972 j];
973 grad = grad_psi + k*nDOF_element + j;
974 /* nodes are always 3D */
975 node = nodeArray + j_global*3;
976 jac[XX] += node[X]*grad[X];
977 }
978 *jacDet
979 =
980 jac[XX];
981 oneOverJacDet = 1.0/(*jacDet);
982 jacInv[XX] = oneOverJacDet;
983 }
984}
985
986void parametricMaps_getJacobianValuesTrace3D(int nElements_global,
987 int nElementBoundaries_element,
988 int nQuadraturePoints_element,
989 int nDOF_element,
990 double* grad_psi,
991 double* boundaryNormals,
992 double* boundaryJacobians,
993 int* l2g,
994 double* nodeArray,
995 double* jacobianInverseArray,
996 double* metricTensorArray,
997 double* metricTensorDeterminantSqrtArray,
998 double* unitNormalArray)
999{
1000 int eN,ebN,k,j,j_global;
1001 const int
1002 X=0,Y=1,Z=2,
1003 XX=0,XY=1,XZ=2,
1004 YX=3,YY=4,YZ=5,
1005 ZX=6,ZY=7,ZZ=8,
1006 XHX=0,XHY=1,
1007 YHX=2,YHY=3,
1008 ZHX=4,ZHY=5,
1009 HXHX=0,HXHY=1,
1010 HYHX=2,HYHY=3;
1011 double *jacInv=NULL,*mt=NULL,*mtDetSqrt=NULL,*n=NULL,*grad=NULL,*node=NULL,*bn,*bj;
1012 register double oneOverJacDet=0.0,oneOverNbn=0.0;
1013 double emj[9],ebmj[6];
1014 for(eN=0;eN<nElements_global;eN++)
1015 for(ebN=0;ebN<nElementBoundaries_element;ebN++)
1016 for(k=0;k<nQuadraturePoints_element;k++)
1017 {
1018 emj[XX] = 0.0;
1019 emj[XY] = 0.0;
1020 emj[XZ] = 0.0;
1021 emj[YX] = 0.0;
1022 emj[YY] = 0.0;
1023 emj[YZ] = 0.0;
1024 emj[ZX] = 0.0;
1025 emj[ZY] = 0.0;
1026 emj[ZZ] = 0.0;
1027 ebmj[XHX] = 0.0;
1028 ebmj[XHY] = 0.0;
1029 ebmj[YHX] = 0.0;
1030 ebmj[YHY] = 0.0;
1031 ebmj[ZHX] = 0.0;
1032 ebmj[ZHY] = 0.0;
1033 jacInv = jacobianInverseArray +
1034 eN*nElementBoundaries_element*nQuadraturePoints_element*9+
1035 ebN*nQuadraturePoints_element*9+
1036 k*9;
1037 mt = metricTensorArray +
1038 eN*nElementBoundaries_element*nQuadraturePoints_element*4+
1039 ebN*nQuadraturePoints_element*4+
1040 k*4;
1041 mtDetSqrt = metricTensorDeterminantSqrtArray +
1042 eN*nElementBoundaries_element*nQuadraturePoints_element+
1043 ebN*nQuadraturePoints_element+
1044 k;
1045 n = unitNormalArray+
1046 eN*nElementBoundaries_element*nQuadraturePoints_element*3+
1047 ebN*nQuadraturePoints_element*3+
1048 k*3;
1049 bn = boundaryNormals + ebN*3;
1050 bj = boundaryJacobians + ebN*6;
1051 for(j=0;j<nDOF_element;j++)
1052 {
1053 j_global = l2g[eN*nDOF_element+
1054 j];
1055 grad = grad_psi + ebN*nQuadraturePoints_element*nDOF_element*3+k*nDOF_element*3 + j*3;
1056 /* nodes are always 3D */
1057 node = nodeArray + j_global*3;
1058 emj[XX] += node[X]*grad[X];
1059 emj[XY] += node[X]*grad[Y];
1060 emj[XZ] += node[X]*grad[Z];
1061 emj[YX] += node[Y]*grad[X];
1062 emj[YY] += node[Y]*grad[Y];
1063 emj[YZ] += node[Y]*grad[Z];
1064 emj[ZX] += node[Z]*grad[X];
1065 emj[ZY] += node[Z]*grad[Y];
1066 emj[ZZ] += node[Z]*grad[Z];
1067 }
1068 oneOverJacDet = 1.0/(emj[XX]*(emj[YY]*emj[ZZ] - emj[YZ]*emj[ZY]) -
1069 emj[XY]*(emj[YX]*emj[ZZ] - emj[YZ]*emj[ZX]) +
1070 emj[XZ]*(emj[YX]*emj[ZY] - emj[YY]*emj[ZX]));
1071 jacInv[XX] = oneOverJacDet*(emj[YY]*emj[ZZ] - emj[YZ]*emj[ZY]);
1072 jacInv[YX] = oneOverJacDet*(emj[YZ]*emj[ZX] - emj[YX]*emj[ZZ]);
1073 jacInv[ZX] = oneOverJacDet*(emj[YX]*emj[ZY] - emj[YY]*emj[ZX]);
1074 jacInv[XY] = oneOverJacDet*(emj[ZY]*emj[XZ] - emj[ZZ]*emj[XY]);
1075 jacInv[YY] = oneOverJacDet*(emj[ZZ]*emj[XX] - emj[ZX]*emj[XZ]);
1076 jacInv[ZY] = oneOverJacDet*(emj[ZX]*emj[XY] - emj[ZY]*emj[XX]);
1077 jacInv[XZ] = oneOverJacDet*(emj[XY]*emj[YZ] - emj[XZ]*emj[YY]);
1078 jacInv[YZ] = oneOverJacDet*(emj[XZ]*emj[YX] - emj[XX]*emj[YZ]);
1079 jacInv[ZZ] = oneOverJacDet*(emj[XX]*emj[YY] - emj[XY]*emj[YX]);
1080
1081 ebmj[XHX] = emj[XX]*bj[XHX]+emj[XY]*bj[YHX]+emj[XZ]*bj[ZHX];
1082 ebmj[XHY] = emj[XX]*bj[XHY]+emj[XY]*bj[YHY]+emj[XZ]*bj[ZHY];
1083 ebmj[YHX] = emj[YX]*bj[XHX]+emj[YY]*bj[YHX]+emj[YZ]*bj[ZHX];
1084 ebmj[YHY] = emj[YX]*bj[XHY]+emj[YY]*bj[YHY]+emj[YZ]*bj[ZHY];
1085 ebmj[ZHX] = emj[ZX]*bj[XHX]+emj[ZY]*bj[YHX]+emj[ZZ]*bj[ZHX];
1086 ebmj[ZHY] = emj[ZX]*bj[XHY]+emj[ZY]*bj[YHY]+emj[ZZ]*bj[ZHY];
1087
1088 mt[HXHX] = ebmj[XHX]*ebmj[XHX]+ebmj[YHX]*ebmj[YHX]+ebmj[ZHX]*ebmj[ZHX];
1089 mt[HXHY] = ebmj[XHX]*ebmj[XHY]+ebmj[YHX]*ebmj[YHY]+ebmj[ZHX]*ebmj[ZHY];
1090 mt[HYHX] = ebmj[XHY]*ebmj[XHX]+ebmj[YHY]*ebmj[YHX]+ebmj[ZHY]*ebmj[ZHX];
1091 mt[HYHY] = ebmj[XHY]*ebmj[XHY]+ebmj[YHY]*ebmj[YHY]+ebmj[ZHY]*ebmj[ZHY];
1092
1093 *mtDetSqrt=sqrt(mt[HXHX]*mt[HYHY]- mt[HXHY]*mt[HYHX]);
1094
1095
1096 n[X] = (jacInv[XX]*bn[X]+jacInv[YX]*bn[Y]+jacInv[ZX]*bn[Z]);
1097 n[Y] = (jacInv[XY]*bn[X]+jacInv[YY]*bn[Y]+jacInv[ZY]*bn[Z]);
1098 n[Z] = (jacInv[XZ]*bn[X]+jacInv[YZ]*bn[Y]+jacInv[ZZ]*bn[Z]);
1099
1100 oneOverNbn = 1.0/sqrt(n[X]*n[X]+n[Y]*n[Y]+n[Z]*n[Z]);
1101
1102 n[X] *= oneOverNbn;
1103 n[Y] *= oneOverNbn;
1104 n[Z] *= oneOverNbn;
1105
1106 }
1107}
1108
1109void parametricMaps_getJacobianValuesTrace2D(int nElements_global,
1110 int nElementBoundaries_element,
1111 int nQuadraturePoints_element,
1112 int nDOF_element,
1113 double* grad_psi,
1114 double* boundaryNormals,
1115 double* boundaryJacobians,
1116 int* l2g,
1117 double* nodeArray,
1118 double* jacobianInverseArray,
1119 double* metricTensorArray,
1120 double* metricTensorDeterminantSqrtArray,
1121 double* unitNormalArray)
1122{
1123 int eN,ebN,k,j,j_global;
1124 const int X=0,Y=1,
1125 XX=0,XY=1,
1126 YX=2,YY=3;
1127 double *jacInv=NULL,*mt,*mtDetSqrt,*n,*grad=NULL,*node=NULL,*bn,*bj;
1128 register double oneOverJacDet=0.0,oneOverNbn=0.0;
1129 double emj[4],ebmj[2];
1130 for(eN=0;eN<nElements_global;eN++)
1131 for(ebN=0;ebN<nElementBoundaries_element;ebN++)
1132 for(k=0;k<nQuadraturePoints_element;k++)
1133 {
1134 emj[XX] = 0.0;
1135 emj[XY] = 0.0;
1136 emj[YX] = 0.0;
1137 emj[YY] = 0.0;
1138 ebmj[XX] = 0.0;
1139 ebmj[XY] = 0.0;
1140 jacInv = jacobianInverseArray +
1141 eN*nElementBoundaries_element*nQuadraturePoints_element*4+
1142 ebN*nQuadraturePoints_element*4+
1143 k*4;
1144 mt = metricTensorArray +
1145 eN*nElementBoundaries_element*nQuadraturePoints_element+
1146 ebN*nQuadraturePoints_element+
1147 k;
1148 mtDetSqrt = metricTensorDeterminantSqrtArray +
1149 eN*nElementBoundaries_element*nQuadraturePoints_element+
1150 ebN*nQuadraturePoints_element+
1151 k;
1152 n = unitNormalArray+
1153 eN*nElementBoundaries_element*nQuadraturePoints_element*2+
1154 ebN*nQuadraturePoints_element*2+
1155 k*2;
1156 bn = boundaryNormals + ebN*2;
1157 bj = boundaryJacobians + ebN*2;
1158 for(j=0;j<nDOF_element;j++)
1159 {
1160 j_global = l2g[eN*nDOF_element+
1161 j];
1162 grad = grad_psi + ebN*nQuadraturePoints_element*nDOF_element*2+k*nDOF_element*2 + j*2;
1163 /* nodes are always 3D */
1164 node = nodeArray + j_global*3;
1165 emj[XX] += node[X]*grad[X];
1166 emj[XY] += node[X]*grad[Y];
1167 emj[YX] += node[Y]*grad[X];
1168 emj[YY] += node[Y]*grad[Y];
1169 }
1170 oneOverJacDet = 1.0/(emj[XX]*emj[YY]- emj[XY]*emj[YX]);
1171 jacInv[XX] = oneOverJacDet*emj[YY];
1172 jacInv[YX] = -oneOverJacDet*emj[YX];
1173 jacInv[XY] = -oneOverJacDet*emj[XY];
1174 jacInv[YY] = oneOverJacDet*emj[XX];
1175 ebmj[X] = emj[XX]*bj[XX]+emj[XY]*bj[Y];
1176 ebmj[Y] = emj[YX]*bj[X]+emj[YY]*bj[Y];
1177 mt[X] = ebmj[X]*ebmj[X]+ebmj[Y]*ebmj[Y];
1178 *mtDetSqrt=sqrt(mt[XX]);
1179 n[X] = jacInv[XX]*bn[X]+jacInv[YX]*bn[Y];
1180 n[Y] = jacInv[XY]*bn[X]+jacInv[YY]*bn[Y];
1181 oneOverNbn= 1.0/sqrt(n[X]*n[X]+n[Y]*n[Y]);
1182 n[X] *= oneOverNbn;
1183 n[Y] *= oneOverNbn;
1184 }
1185}
1186
1187void parametricMaps_getJacobianValuesTrace2D_movingDomain(int nElements_global,
1188 int nElementBoundaries_element,
1189 int nQuadraturePoints_element,
1190 int nDOF_element,
1191 double* xtArray,
1192 double* grad_psi,
1193 double* boundaryNormals,
1194 double* boundaryJacobians,
1195 int* l2g,
1196 double* nodeArray,
1197 double* jacobianInverseArray,
1198 double* metricTensorArray,
1199 double* metricTensorDeterminantSqrtArray,
1200 double* unitNormalArray)
1201{
1202 int eN,ebN,k,j,j_global;
1203 const int X=0,Y=1,
1204 XX=0,XY=1,
1205 YX=2,YY=3;
1206 double *jacInv=NULL,*mt,*mtDetSqrt,*n,*grad=NULL,*node=NULL,*bn,*bj,*xt;
1207 register double oneOverJacDet=0.0,oneOverNbn=0.0,xt_dot_xt,xt_dot_n,xt_dot_bj;
1208 double emj[4],ebmj[2];
1209 for(eN=0;eN<nElements_global;eN++)
1210 for(ebN=0;ebN<nElementBoundaries_element;ebN++)
1211 for(k=0;k<nQuadraturePoints_element;k++)
1212 {
1213 emj[XX] = 0.0;
1214 emj[XY] = 0.0;
1215 emj[YX] = 0.0;
1216 emj[YY] = 0.0;
1217 ebmj[XX] = 0.0;
1218 ebmj[XY] = 0.0;
1219 jacInv = jacobianInverseArray +
1220 eN*nElementBoundaries_element*nQuadraturePoints_element*4+
1221 ebN*nQuadraturePoints_element*4+
1222 k*4;
1223 mt = metricTensorArray +
1224 eN*nElementBoundaries_element*nQuadraturePoints_element+
1225 ebN*nQuadraturePoints_element+
1226 k;
1227 mtDetSqrt = metricTensorDeterminantSqrtArray +
1228 eN*nElementBoundaries_element*nQuadraturePoints_element+
1229 ebN*nQuadraturePoints_element+
1230 k;
1231 n = unitNormalArray+
1232 eN*nElementBoundaries_element*nQuadraturePoints_element*2+
1233 ebN*nQuadraturePoints_element*2+
1234 k*2;
1235 xt = xtArray + eN*nElementBoundaries_element*nQuadraturePoints_element*3+
1236 ebN*nQuadraturePoints_element*3+
1237 k*3;
1238 bn = boundaryNormals + ebN*2;
1239 bj = boundaryJacobians + ebN*2;
1240 for(j=0;j<nDOF_element;j++)
1241 {
1242 j_global = l2g[eN*nDOF_element+
1243 j];
1244 grad = grad_psi + ebN*nQuadraturePoints_element*nDOF_element*2+k*nDOF_element*2 + j*2;
1245 /* nodes are always 3D */
1246 node = nodeArray + j_global*3;
1247 emj[XX] += node[X]*grad[X];
1248 emj[XY] += node[X]*grad[Y];
1249 emj[YX] += node[Y]*grad[X];
1250 emj[YY] += node[Y]*grad[Y];
1251 }
1252 oneOverJacDet = 1.0/(emj[XX]*emj[YY]- emj[XY]*emj[YX]);
1253 jacInv[XX] = oneOverJacDet*emj[YY];
1254 jacInv[YX] = -oneOverJacDet*emj[YX];
1255 jacInv[XY] = -oneOverJacDet*emj[XY];
1256 jacInv[YY] = oneOverJacDet*emj[XX];
1257 ebmj[X] = emj[XX]*bj[X]+emj[XY]*bj[Y];
1258 ebmj[Y] = emj[YX]*bj[X]+emj[YY]*bj[Y];
1259 mt[X] = ebmj[X]*ebmj[X]+ebmj[Y]*ebmj[Y];
1260 n[X] = jacInv[XX]*bn[X]+jacInv[YX]*bn[Y];
1261 n[Y] = jacInv[XY]*bn[X]+jacInv[YY]*bn[Y];
1262 oneOverNbn= 1.0/sqrt(n[X]*n[X]+n[Y]*n[Y]);
1263 n[X] *= oneOverNbn;
1264 n[Y] *= oneOverNbn;
1265 xt_dot_xt = xt[X]*xt[X]+xt[Y]*xt[Y];
1266 xt_dot_bj = xt[X]*ebmj[X]+xt[Y]*ebmj[Y];
1267 xt_dot_n = xt[X]*n[X]+xt[Y]*n[Y];
1268 //printf("%12.5e %12.5e %12.5e\n",xt_dot_xt,xt_dot_bj,xt_dot_n);
1269 //printf("%12.5e \n",((1.0+xt_dot_xt)*mt[X] - xt_dot_bj*xt_dot_bj)/(1.0+xt_dot_n*xt_dot_n));
1270 *mtDetSqrt=sqrt(((1.0+xt_dot_xt)*mt[X] - xt_dot_bj*xt_dot_bj)/(1.0+xt_dot_n*xt_dot_n));// sqrt(det(G^t G))/sqrt(1 + (xt^t n)^2)
1271 }
1272}
1273
1274void parametricMaps_getJacobianValuesTrace1D(int nElements_global,
1275 int nElementBoundaries_element,
1276 int nQuadraturePoints_element,
1277 int nDOF_element,
1278 double* grad_psi,
1279 double* boundaryNormals,
1280 double* boundaryJacobians,
1281 int* l2g,
1282 double* nodeArray,
1283 double* jacobianInverseArray,
1284 double* metricTensorArray,
1285 double* metricTensorDeterminantSqrtArray,
1286 double* unitNormalArray)
1287{
1288 int eN,ebN,k,j,j_global;
1289 const int X=0,
1290 XX=0;
1291 double *jacInv=NULL,*mt,*mtDetSqrt,*n,*grad=NULL,*node=NULL;
1292 register double emj=0.0,ebmj=0.0;
1293 for(eN=0;eN<nElements_global;eN++)
1294 for(ebN=0;ebN<nElementBoundaries_element;ebN++)
1295 for(k=0;k<nQuadraturePoints_element;k++)
1296 {
1297 emj = 0.0;
1298 ebmj = 0.0;
1299 jacInv = jacobianInverseArray +
1300 eN*nElementBoundaries_element*nQuadraturePoints_element+
1301 ebN*nQuadraturePoints_element+
1302 k;
1303 mt = metricTensorArray +
1304 eN*nElementBoundaries_element*nQuadraturePoints_element+
1305 ebN*nQuadraturePoints_element+
1306 k;
1307 mtDetSqrt = metricTensorDeterminantSqrtArray +
1308 eN*nElementBoundaries_element*nQuadraturePoints_element+
1309 ebN*nQuadraturePoints_element+
1310 k;
1311 n = unitNormalArray+
1312 eN*nElementBoundaries_element*nQuadraturePoints_element+
1313 ebN*nQuadraturePoints_element+
1314 k;
1315 for(j=0;j<nDOF_element;j++)
1316 {
1317 j_global = l2g[eN*nDOF_element+
1318 j];
1319 grad = grad_psi + ebN*nQuadraturePoints_element*nDOF_element+k*nDOF_element + j;
1320 /* nodes are always 3D */
1321 node = nodeArray + j_global*3;
1322 emj += node[X]*grad[X];
1323 }
1324 jacInv[XX] = 1.0/(emj);
1325 mt[XX] = 1.0;
1326 *mtDetSqrt=1.0;
1327 n[X] = boundaryNormals[ebN];
1328 }
1329}
1330
1331void parametricMaps_getJacobianValuesGlobalExteriorTrace1D(int nQuadraturePoints_element,
1332 int nDOF_element,
1333 int nExteriorElementBoundaries_global,
1334 const int * exteriorElementBoundariesArray,
1335 const int * elementBoundaryElementsArray,
1336 const int * elementBoundaryLocalElementBoundariesArray,
1337 double* grad_psi,
1338 double* boundaryNormals,
1339 double* boundaryJacobians,
1340 int* l2g,
1341 double* nodeArray,
1342 double* jacobianInverseArray,
1343 double* metricTensorArray,
1344 double* metricTensorDeterminantSqrtArray,
1345 double* unitNormalArray)
1346{
1347 int eN,ebN,ebNE,ebN_local,k,j,j_global;
1348 const int X=0,
1349 XX=0;
1350 double *jacInv=NULL,*mt,*mtDetSqrt,*n,*grad=NULL,*node=NULL;
1351 register double emj=0.0,ebmj=0.0;
1352 for(ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
1353 {
1354 ebN = exteriorElementBoundariesArray[ebNE];
1355 eN = elementBoundaryElementsArray[ebN*2+0];
1356 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
1357 for(k=0;k<nQuadraturePoints_element;k++)
1358 {
1359 emj = 0.0;
1360 ebmj = 0.0;
1361 jacInv = jacobianInverseArray +
1362 ebNE*nQuadraturePoints_element+
1363 k;
1364 mt = metricTensorArray +
1365 ebNE*nQuadraturePoints_element+
1366 k;
1367 mtDetSqrt = metricTensorDeterminantSqrtArray +
1368 ebNE*nQuadraturePoints_element+
1369 k;
1370 n = unitNormalArray+
1371 ebNE*nQuadraturePoints_element+
1372 k;
1373 for(j=0;j<nDOF_element;j++)
1374 {
1375 j_global = l2g[eN*nDOF_element+
1376 j];
1377 grad = grad_psi + ebN_local*nQuadraturePoints_element*nDOF_element+k*nDOF_element + j;
1378 /* nodes are always 3D */
1379 node = nodeArray + j_global*3;
1380 emj += node[X]*grad[X];
1381 }
1382 jacInv[XX] = 1.0/(emj);
1383 mt[XX] = 1.0;
1384 *mtDetSqrt=1.0;
1385 n[X] = boundaryNormals[ebN_local];
1386 }
1387 }
1388}
1389void parametricMaps_getJacobianValuesGlobalExteriorTrace2D(int nQuadraturePoints_element,
1390 int nDOF_element,
1391 int nExteriorElementBoundaries_global,
1392 const int * exteriorElementBoundariesArray,
1393 const int * elementBoundaryElementsArray,
1394 const int * elementBoundaryLocalElementBoundariesArray,
1395 double* grad_psi,
1396 double* boundaryNormals,
1397 double* boundaryJacobians,
1398 int* l2g,
1399 double* nodeArray,
1400 double* jacobianInverseArray,
1401 double* metricTensorArray,
1402 double* metricTensorDeterminantSqrtArray,
1403 double* unitNormalArray)
1404{
1405 int eN,ebN,ebNE,ebN_local,k,j,j_global;
1406 const int X=0,Y=1,
1407 XX=0,XY=1,
1408 YX=2,YY=3;
1409 double *jacInv=NULL,*mt,*mtDetSqrt,*n,*grad=NULL,*node=NULL,*bn,*bj;
1410 register double oneOverJacDet=0.0,oneOverNbn=0.0;
1411 double emj[4],ebmj[2];
1412 for(ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
1413 {
1414 ebN = exteriorElementBoundariesArray[ebNE];
1415 eN = elementBoundaryElementsArray[ebN*2+0];
1416 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
1417 for(k=0;k<nQuadraturePoints_element;k++)
1418 {
1419 emj[XX] = 0.0;
1420 emj[XY] = 0.0;
1421 emj[YX] = 0.0;
1422 emj[YY] = 0.0;
1423 ebmj[XX] = 0.0;
1424 ebmj[XY] = 0.0;
1425 jacInv = jacobianInverseArray +
1426 ebNE*nQuadraturePoints_element*4+
1427 k*4;
1428 mt = metricTensorArray +
1429 ebNE*nQuadraturePoints_element+
1430 k;
1431 mtDetSqrt = metricTensorDeterminantSqrtArray +
1432 ebNE*nQuadraturePoints_element+
1433 k;
1434 n = unitNormalArray+
1435 ebNE*nQuadraturePoints_element*2+
1436 k*2;
1437 bn = boundaryNormals + ebN_local*2;
1438 bj = boundaryJacobians + ebN_local*2;
1439 for(j=0;j<nDOF_element;j++)
1440 {
1441 j_global = l2g[eN*nDOF_element+
1442 j];
1443 grad = grad_psi + ebN_local*nQuadraturePoints_element*nDOF_element*2+k*nDOF_element*2 + j*2;
1444 /* nodes are always 3D */
1445 node = nodeArray + j_global*3;
1446 emj[XX] += node[X]*grad[X];
1447 emj[XY] += node[X]*grad[Y];
1448 emj[YX] += node[Y]*grad[X];
1449 emj[YY] += node[Y]*grad[Y];
1450 }
1451 oneOverJacDet = 1.0/(emj[XX]*emj[YY]- emj[XY]*emj[YX]);
1452 jacInv[XX] = oneOverJacDet*emj[YY];
1453 jacInv[YX] = -oneOverJacDet*emj[YX];
1454 jacInv[XY] = -oneOverJacDet*emj[XY];
1455 jacInv[YY] = oneOverJacDet*emj[XX];
1456 ebmj[X] = emj[XX]*bj[XX]+emj[XY]*bj[Y];
1457 ebmj[Y] = emj[YX]*bj[X]+emj[YY]*bj[Y];
1458 mt[X] = ebmj[X]*ebmj[X]+ebmj[Y]*ebmj[Y];
1459 *mtDetSqrt=sqrt(mt[XX]);
1460 n[X] = jacInv[XX]*bn[X]+jacInv[YX]*bn[Y];
1461 n[Y] = jacInv[XY]*bn[X]+jacInv[YY]*bn[Y];
1462 oneOverNbn= 1.0/sqrt(n[X]*n[X]+n[Y]*n[Y]);
1463 n[X] *= oneOverNbn;
1464 n[Y] *= oneOverNbn;
1465 }
1466 }
1467}
1468
1469void parametricMaps_getJacobianValuesGlobalExteriorTrace2D_movingDomain(int nQuadraturePoints_element,
1470 int nDOF_element,
1471 int nExteriorElementBoundaries_global,
1472 const int * exteriorElementBoundariesArray,
1473 const int * elementBoundaryElementsArray,
1474 const int * elementBoundaryLocalElementBoundariesArray,
1475 double* xtArray,
1476 double* grad_psi,
1477 double* boundaryNormals,
1478 double* boundaryJacobians,
1479 int* l2g,
1480 double* nodeArray,
1481 double* jacobianInverseArray,
1482 double* metricTensorArray,
1483 double* metricTensorDeterminantSqrtArray,
1484 double* unitNormalArray)
1485{
1486 int eN,ebN,ebNE,ebN_local,k,j,j_global;
1487 const int X=0,Y=1,
1488 XX=0,XY=1,
1489 YX=2,YY=3;
1490 double *jacInv=NULL,*mt,*mtDetSqrt,*n,*grad=NULL,*node=NULL,*bn,*bj,*xt;
1491 register double oneOverJacDet=0.0,oneOverNbn=0.0,xt_dot_xt,xt_dot_n,xt_dot_bj;
1492 double emj[4],ebmj[2];
1493 for(ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
1494 {
1495 ebN = exteriorElementBoundariesArray[ebNE];
1496 eN = elementBoundaryElementsArray[ebN*2+0];
1497 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
1498 for(k=0;k<nQuadraturePoints_element;k++)
1499 {
1500 emj[XX] = 0.0;
1501 emj[XY] = 0.0;
1502 emj[YX] = 0.0;
1503 emj[YY] = 0.0;
1504 ebmj[XX] = 0.0;
1505 ebmj[XY] = 0.0;
1506 jacInv = jacobianInverseArray +
1507 ebNE*nQuadraturePoints_element*4+
1508 k*4;
1509 mt = metricTensorArray +
1510 ebNE*nQuadraturePoints_element+
1511 k;
1512 mtDetSqrt = metricTensorDeterminantSqrtArray +
1513 ebNE*nQuadraturePoints_element+
1514 k;
1515 n = unitNormalArray+
1516 ebNE*nQuadraturePoints_element*2+
1517 k*2;
1518 xt = xtArray+
1519 ebNE*nQuadraturePoints_element*3+
1520 k*3;
1521 bn = boundaryNormals + ebN_local*2;
1522 bj = boundaryJacobians + ebN_local*2;
1523 for(j=0;j<nDOF_element;j++)
1524 {
1525 j_global = l2g[eN*nDOF_element+
1526 j];
1527 grad = grad_psi + ebN_local*nQuadraturePoints_element*nDOF_element*2+k*nDOF_element*2 + j*2;
1528 /* nodes are always 3D */
1529 node = nodeArray + j_global*3;
1530 emj[XX] += node[X]*grad[X];
1531 emj[XY] += node[X]*grad[Y];
1532 emj[YX] += node[Y]*grad[X];
1533 emj[YY] += node[Y]*grad[Y];
1534 }
1535 oneOverJacDet = 1.0/(emj[XX]*emj[YY]- emj[XY]*emj[YX]);
1536 jacInv[XX] = oneOverJacDet*emj[YY];
1537 jacInv[YX] = -oneOverJacDet*emj[YX];
1538 jacInv[XY] = -oneOverJacDet*emj[XY];
1539 jacInv[YY] = oneOverJacDet*emj[XX];
1540 ebmj[X] = emj[XX]*bj[XX]+emj[XY]*bj[Y];
1541 ebmj[Y] = emj[YX]*bj[X]+emj[YY]*bj[Y];
1542 mt[X] = ebmj[X]*ebmj[X]+ebmj[Y]*ebmj[Y];
1543 n[X] = jacInv[XX]*bn[X]+jacInv[YX]*bn[Y];
1544 n[Y] = jacInv[XY]*bn[X]+jacInv[YY]*bn[Y];
1545 oneOverNbn= 1.0/sqrt(n[X]*n[X]+n[Y]*n[Y]);
1546 n[X] *= oneOverNbn;
1547 n[Y] *= oneOverNbn;
1548 xt_dot_xt = xt[X]*xt[X]+xt[Y]*xt[Y];
1549 xt_dot_bj = xt[X]*ebmj[X]+xt[Y]*ebmj[Y];
1550 xt_dot_n = xt[X]*n[X]+xt[Y]*n[Y];
1551 //printf("%12.5e %12.5e %12.5e\n",xt_dot_xt,xt_dot_bj,xt_dot_n);
1552 *mtDetSqrt=sqrt(((1.0+xt_dot_xt)*mt[X] - xt_dot_bj*xt_dot_bj)/(1.0+xt_dot_n*xt_dot_n));// sqrt(det(G^t G))/sqrt(1 + (xt^t n)^2)
1553 }
1554 }
1555}
1556void parametricMaps_getJacobianValuesGlobalExteriorTrace3D(int nQuadraturePoints_element,
1557 int nDOF_element,
1558 int nExteriorElementBoundaries_global,
1559 const int * exteriorElementBoundariesArray,
1560 const int * elementBoundaryElementsArray,
1561 const int * elementBoundaryLocalElementBoundariesArray,
1562 double* grad_psi,
1563 double* boundaryNormals,
1564 double* boundaryJacobians,
1565 int* l2g,
1566 double* nodeArray,
1567 double* jacobianInverseArray,
1568 double* metricTensorArray,
1569 double* metricTensorDeterminantSqrtArray,
1570 double* unitNormalArray)
1571{
1572 int eN,ebN,ebNE,ebN_local,k,j,j_global;
1573 const int
1574 X=0,Y=1,Z=2,
1575 XX=0,XY=1,XZ=2,
1576 YX=3,YY=4,YZ=5,
1577 ZX=6,ZY=7,ZZ=8,
1578 XHX=0,XHY=1,
1579 YHX=2,YHY=3,
1580 ZHX=4,ZHY=5,
1581 HXHX=0,HXHY=1,
1582 HYHX=2,HYHY=3;
1583 double *jacInv=NULL,*mt=NULL,*mtDetSqrt=NULL,*n=NULL,*grad=NULL,*node=NULL,*bn,*bj;
1584 register double oneOverJacDet=0.0,oneOverNbn=0.0;
1585 double emj[9],ebmj[6];
1586 for(ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
1587 {
1588 ebN = exteriorElementBoundariesArray[ebNE];
1589 eN = elementBoundaryElementsArray[ebN*2+0];
1590 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
1591 for(k=0;k<nQuadraturePoints_element;k++)
1592 {
1593 emj[XX] = 0.0;
1594 emj[XY] = 0.0;
1595 emj[XZ] = 0.0;
1596 emj[YX] = 0.0;
1597 emj[YY] = 0.0;
1598 emj[YZ] = 0.0;
1599 emj[ZX] = 0.0;
1600 emj[ZY] = 0.0;
1601 emj[ZZ] = 0.0;
1602 ebmj[XHX] = 0.0;
1603 ebmj[XHY] = 0.0;
1604 ebmj[YHX] = 0.0;
1605 ebmj[YHY] = 0.0;
1606 ebmj[ZHX] = 0.0;
1607 ebmj[ZHY] = 0.0;
1608 jacInv = jacobianInverseArray +
1609 ebNE*nQuadraturePoints_element*9+
1610 k*9;
1611 mt = metricTensorArray +
1612 ebNE*nQuadraturePoints_element*4+
1613 k*4;
1614 mtDetSqrt = metricTensorDeterminantSqrtArray +
1615 ebNE*nQuadraturePoints_element+
1616 k;
1617 n = unitNormalArray+
1618 ebNE*nQuadraturePoints_element*3+
1619 k*3;
1620 bn = boundaryNormals + ebN_local*3;
1621 bj = boundaryJacobians + ebN_local*6;
1622 for(j=0;j<nDOF_element;j++)
1623 {
1624 j_global = l2g[eN*nDOF_element+
1625 j];
1626 grad = grad_psi + ebN_local*nQuadraturePoints_element*nDOF_element*3+k*nDOF_element*3 + j*3;
1627 /* nodes are always 3D */
1628 node = nodeArray + j_global*3;
1629 emj[XX] += node[X]*grad[X];
1630 emj[XY] += node[X]*grad[Y];
1631 emj[XZ] += node[X]*grad[Z];
1632 emj[YX] += node[Y]*grad[X];
1633 emj[YY] += node[Y]*grad[Y];
1634 emj[YZ] += node[Y]*grad[Z];
1635 emj[ZX] += node[Z]*grad[X];
1636 emj[ZY] += node[Z]*grad[Y];
1637 emj[ZZ] += node[Z]*grad[Z];
1638 }
1639 oneOverJacDet = 1.0/(emj[XX]*(emj[YY]*emj[ZZ] - emj[YZ]*emj[ZY]) -
1640 emj[XY]*(emj[YX]*emj[ZZ] - emj[YZ]*emj[ZX]) +
1641 emj[XZ]*(emj[YX]*emj[ZY] - emj[YY]*emj[ZX]));
1642 jacInv[XX] = oneOverJacDet*(emj[YY]*emj[ZZ] - emj[YZ]*emj[ZY]);
1643 jacInv[YX] = oneOverJacDet*(emj[YZ]*emj[ZX] - emj[YX]*emj[ZZ]);
1644 jacInv[ZX] = oneOverJacDet*(emj[YX]*emj[ZY] - emj[YY]*emj[ZX]);
1645 jacInv[XY] = oneOverJacDet*(emj[ZY]*emj[XZ] - emj[ZZ]*emj[XY]);
1646 jacInv[YY] = oneOverJacDet*(emj[ZZ]*emj[XX] - emj[ZX]*emj[XZ]);
1647 jacInv[ZY] = oneOverJacDet*(emj[ZX]*emj[XY] - emj[ZY]*emj[XX]);
1648 jacInv[XZ] = oneOverJacDet*(emj[XY]*emj[YZ] - emj[XZ]*emj[YY]);
1649 jacInv[YZ] = oneOverJacDet*(emj[XZ]*emj[YX] - emj[XX]*emj[YZ]);
1650 jacInv[ZZ] = oneOverJacDet*(emj[XX]*emj[YY] - emj[XY]*emj[YX]);
1651
1652 ebmj[XHX] = emj[XX]*bj[XHX]+emj[XY]*bj[YHX]+emj[XZ]*bj[ZHX];
1653 ebmj[XHY] = emj[XX]*bj[XHY]+emj[XY]*bj[YHY]+emj[XZ]*bj[ZHY];
1654 ebmj[YHX] = emj[YX]*bj[XHX]+emj[YY]*bj[YHX]+emj[YZ]*bj[ZHX];
1655 ebmj[YHY] = emj[YX]*bj[XHY]+emj[YY]*bj[YHY]+emj[YZ]*bj[ZHY];
1656 ebmj[ZHX] = emj[ZX]*bj[XHX]+emj[ZY]*bj[YHX]+emj[ZZ]*bj[ZHX];
1657 ebmj[ZHY] = emj[ZX]*bj[XHY]+emj[ZY]*bj[YHY]+emj[ZZ]*bj[ZHY];
1658
1659 mt[HXHX] = ebmj[XHX]*ebmj[XHX]+ebmj[YHX]*ebmj[YHX]+ebmj[ZHX]*ebmj[ZHX];
1660 mt[HXHY] = ebmj[XHX]*ebmj[XHY]+ebmj[YHX]*ebmj[YHY]+ebmj[ZHX]*ebmj[ZHY];
1661 mt[HYHX] = ebmj[XHY]*ebmj[XHX]+ebmj[YHY]*ebmj[YHX]+ebmj[ZHY]*ebmj[ZHX];
1662 mt[HYHY] = ebmj[XHY]*ebmj[XHY]+ebmj[YHY]*ebmj[YHY]+ebmj[ZHY]*ebmj[ZHY];
1663
1664 *mtDetSqrt=sqrt(mt[HXHX]*mt[HYHY]- mt[HXHY]*mt[HYHX]);
1665
1666
1667 n[X] = (jacInv[XX]*bn[X]+jacInv[YX]*bn[Y]+jacInv[ZX]*bn[Z]);
1668 n[Y] = (jacInv[XY]*bn[X]+jacInv[YY]*bn[Y]+jacInv[ZY]*bn[Z]);
1669 n[Z] = (jacInv[XZ]*bn[X]+jacInv[YZ]*bn[Y]+jacInv[ZZ]*bn[Z]);
1670
1671 oneOverNbn = 1.0/sqrt(n[X]*n[X]+n[Y]*n[Y]+n[Z]*n[Z]);
1672
1673 n[X] *= oneOverNbn;
1674 n[Y] *= oneOverNbn;
1675 n[Z] *= oneOverNbn;
1676
1677 }
1678 }
1679}
1680
1712void updateMass_weak(int nElements_global,
1713 int nQuadraturePoints_element,
1714 int nDOF_test_element,
1715 double* mt,
1716 double* w_dV,
1717 double* weak_residual)
1718{
1719 int eN,i,k;
1720 for(eN=0;eN<nElements_global;eN++)
1721 for (i=0;i<nDOF_test_element;i++)
1722 for (k=0;k<nQuadraturePoints_element;k++)
1723 weak_residual[eN*nDOF_test_element +
1724 i]
1725 +=
1726 mt[eN*nQuadraturePoints_element +
1727 k]
1728 *
1729 w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
1730 k*nDOF_test_element +
1731 i];
1732}
1733
1773void updateMassJacobian_weak(int nElements_global,
1774 int nQuadraturePoints_element,
1775 int nDOF_trial_element,
1776 int nDOF_test_element,
1777 double* dmt,
1778 double* v_X_w_dV,
1779 double* jacobian_weak_residual)
1780{
1781 int eN,i,j,k,nDOF_test_X_trial_element=nDOF_trial_element*nDOF_test_element;
1782 for(eN=0;eN<nElements_global;eN++)
1783 for (i=0;i<nDOF_test_element;i++)
1784 for (k=0;k<nQuadraturePoints_element;k++)
1785 for (j=0;j<nDOF_trial_element;j++)
1786 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
1787 i*nDOF_trial_element+
1788 j]
1789 +=
1790 dmt[eN*nQuadraturePoints_element +
1791 k]
1792 *
1793 v_X_w_dV[eN*nQuadraturePoints_element*nDOF_test_X_trial_element +
1794 k*nDOF_test_X_trial_element +
1795 j*nDOF_test_element+
1796 i];
1797}
1798
1799void updateMassJacobian_weak_lowmem(int nElements_global,
1800 int nQuadraturePoints_element,
1801 int nDOF_trial_element,
1802 int nDOF_test_element,
1803 double* dmt,
1804 double* v,
1805 double* w_dV,
1806 double* jacobian_weak_residual)
1807{
1808 int eN,i,j,k,nDOF_test_X_trial_element=nDOF_trial_element*nDOF_test_element;
1809 for(eN=0;eN<nElements_global;eN++)
1810 for (i=0;i<nDOF_test_element;i++)
1811 for (k=0;k<nQuadraturePoints_element;k++)
1812 for (j=0;j<nDOF_trial_element;j++)
1813 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
1814 i*nDOF_trial_element+
1815 j]
1816 +=
1817 dmt[eN*nQuadraturePoints_element +
1818 k]
1819 *
1820 v[eN*nQuadraturePoints_element*nDOF_trial_element +
1821 k*nDOF_trial_element +
1822 j]
1823 *
1824 w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
1825 k*nDOF_test_element +
1826 i];
1827}
1828
1848void updateMass_strong(int nElements_global,
1849 int nQuadraturePoints_element,
1850 double* mt,
1851 double* strong_residual)
1852{
1853 int eN,k;
1854 for(eN=0;eN<nElements_global;eN++)
1855 for (k=0;k<nQuadraturePoints_element;k++)
1856 strong_residual[eN*nQuadraturePoints_element+
1857 k]
1858 +=
1859 mt[eN*nQuadraturePoints_element+
1860 k];
1861}
1862
1887void updateMassJacobian_strong(int nElements_global,
1888 int nQuadraturePoints_element,
1889 int nDOF_trial_element,
1890 double* dmt,
1891 double* v,
1892 double* dstrong_residual)
1893{
1894 int eN,k,j;
1895 for(eN=0;eN<nElements_global;eN++)
1896 for(j=0;j<nDOF_trial_element;j++)
1897 for (k=0;k<nQuadraturePoints_element;k++)
1898 dstrong_residual[eN*nQuadraturePoints_element*nDOF_trial_element+
1899 k*nDOF_trial_element +
1900 j]
1901 +=
1902 dmt[eN*nQuadraturePoints_element+
1903 k]
1904 *
1905 v[eN*nQuadraturePoints_element*nDOF_trial_element+
1906 k*nDOF_trial_element +
1907 j];
1908}
1909
1935void updateMass_adjoint(int nElements_global,
1936 int nQuadraturePoints_element,
1937 int nDOF_test_element,
1938 double* dmt,
1939 double* w_dV,
1940 double* Lstar_w_dV)
1941{
1942 int eN,i,k;
1943 for(eN=0;eN<nElements_global;eN++)
1944 for (i=0;i<nDOF_test_element;i++)
1945 for (k=0;k<nQuadraturePoints_element;k++)
1946 Lstar_w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
1947 k*nDOF_test_element +
1948 i]
1949 +=
1950 dmt[eN*nQuadraturePoints_element +
1951 k]
1952 *
1953 w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
1954 k*nDOF_test_element +
1955 i];
1956}
1957
1958
1999void updateAdvection_weak(int nElements_global,
2000 int nQuadraturePoints_element,
2001 int nDOF_test_element,
2002 int nSpace,
2003 double* f,
2004 double* grad_w_dV,
2005 double* weak_residual)
2006{
2007 int eN,i,k,I;
2008 for(eN=0;eN<nElements_global;eN++)
2009 for (i=0;i<nDOF_test_element;i++)
2010 for (k=0;k<nQuadraturePoints_element;k++)
2011 for (I=0;I<nSpace;I++)
2012 weak_residual[eN*nDOF_test_element +
2013 i]
2014 -=
2015 f[eN*nQuadraturePoints_element*nSpace +
2016 k*nSpace +
2017 I]
2018 *
2019 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
2020 k*nDOF_test_element*nSpace +
2021 i*nSpace +
2022 I];
2023}
2024
2069void updateAdvectionJacobian_weak(int nElements_global,
2070 int nQuadraturePoints_element,
2071 int nDOF_trial_element,
2072 int nDOF_test_element,
2073 int nSpace,
2074 double* df,
2075 double* v_X_grad_w_dV,
2076 double* jacobian_weak_residual)
2077{
2078 int eN,i,j,k,I,nDOF_test_X_trial_element=nDOF_trial_element*nDOF_test_element;
2079 for(eN=0;eN<nElements_global;eN++)
2080 for (i=0;i<nDOF_test_element;i++)
2081 for (k=0;k<nQuadraturePoints_element;k++)
2082 for (j=0;j<nDOF_trial_element;j++)
2083 for (I=0;I<nSpace;I++)
2084 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
2085 i*nDOF_trial_element+
2086 j]
2087 -=
2088 df[eN*nQuadraturePoints_element*nSpace +
2089 k*nSpace +
2090 I]
2091 *
2092 v_X_grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_X_trial_element*nSpace +
2093 k*nDOF_test_X_trial_element*nSpace +
2094 j*nDOF_test_element*nSpace +
2095 i*nSpace +
2096 I];
2097}
2098
2099void updateAdvectionJacobian_weak_lowmem(int nElements_global,
2100 int nQuadraturePoints_element,
2101 int nDOF_trial_element,
2102 int nDOF_test_element,
2103 int nSpace,
2104 double* df,
2105 double* v,
2106 double* grad_w_dV,
2107 double* jacobian_weak_residual)
2108{
2109 int eN,i,j,k,I,nDOF_test_X_trial_element=nDOF_trial_element*nDOF_test_element;
2110 for(eN=0;eN<nElements_global;eN++)
2111 for (i=0;i<nDOF_test_element;i++)
2112 for (k=0;k<nQuadraturePoints_element;k++)
2113 for (j=0;j<nDOF_trial_element;j++)
2114 for (I=0;I<nSpace;I++)
2115 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
2116 i*nDOF_trial_element+
2117 j]
2118 -=
2119 df[eN*nQuadraturePoints_element*nSpace +
2120 k*nSpace +
2121 I]
2122 *
2123 v[eN*nQuadraturePoints_element*nDOF_trial_element +
2124 k*nDOF_trial_element +
2125 j]
2126 *
2127 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
2128 k*nDOF_test_element*nSpace +
2129 i*nSpace +
2130 I];
2131}
2132
2157void updateAdvection_strong(int nElements_global,
2158 int nQuadraturePoints_element,
2159 int nSpace,
2160 double* df,
2161 double* grad_u,
2162 double* strong_residual)
2163{
2164 int eN,k,I;
2165 for(eN=0;eN<nElements_global;eN++)
2166 for (k=0;k<nQuadraturePoints_element;k++)
2167 for(I=0;I<nSpace;I++)
2168 strong_residual[eN*nQuadraturePoints_element+
2169 k]
2170 +=
2171 df[eN*nQuadraturePoints_element*nSpace +
2172 k*nSpace +
2173 I]
2174 *
2175 grad_u[eN*nQuadraturePoints_element*nSpace +
2176 k*nSpace +
2177 I];
2178}
2179
2204void updateAdvectionJacobian_strong(int nElements_global,
2205 int nQuadraturePoints_element,
2206 int nDOF_trial_element,
2207 int nSpace,
2208 double* df,
2209 double* grad_v,
2210 double* dstrong_residual)
2211{
2212 int eN,k,j,I;
2213 for(eN=0;eN<nElements_global;eN++)
2214 for(j=0;j<nDOF_trial_element;j++)
2215 for (k=0;k<nQuadraturePoints_element;k++)
2216 for (I=0;I<nSpace;I++)
2217 dstrong_residual[eN*nQuadraturePoints_element*nDOF_trial_element+
2218 k*nDOF_trial_element +
2219 j]
2220 +=
2221 df[eN*nQuadraturePoints_element*nSpace +
2222 k*nSpace +
2223 I]
2224 *
2225 grad_v[eN*nQuadraturePoints_element*nSpace*nDOF_trial_element +
2226 k*nSpace*nDOF_trial_element +
2227 j*nSpace+
2228 I];
2229}
2230
2261void updateAdvection_adjoint(int nElements_global,
2262 int nQuadraturePoints_element,
2263 int nDOF_test_element,
2264 int nSpace,
2265 double* df,
2266 double* grad_w_dV,
2267 double* Lstar_w_dV)
2268{
2269 int eN,i,k,I;
2270 for(eN=0;eN<nElements_global;eN++)
2271 for (i=0;i<nDOF_test_element;i++)
2272 for (k=0;k<nQuadraturePoints_element;k++)
2273 for (I=0;I<nSpace;I++)
2274 Lstar_w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
2275 k*nDOF_test_element +
2276 i]
2277 -=
2278 df[eN*nQuadraturePoints_element*nSpace +
2279 k*nSpace +
2280 I]
2281 *
2282 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
2283 k*nDOF_test_element*nSpace +
2284 i*nSpace +
2285 I];
2286}
2287
2320void updateHamiltonian_weak(int nElements_global,
2321 int nQuadraturePoints_element,
2322 int nDOF_test_element,
2323 double* H,
2324 double* w_dV,
2325 double* weak_residual)
2326{
2327 int eN,i,k;
2328 for(eN=0;eN<nElements_global;eN++)
2329 for (i=0;i<nDOF_test_element;i++)
2330 for (k=0;k<nQuadraturePoints_element;k++)
2331 weak_residual[eN*nDOF_test_element + i]
2332 +=
2333 H[eN*nQuadraturePoints_element +
2334 k]
2335 *
2336 w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
2337 k*nDOF_test_element +
2338 i];
2339}
2340
2386void updateHamiltonianJacobian_weak(int nElements_global,
2387 int nQuadraturePoints_element,
2388 int nDOF_trial_element,
2389 int nDOF_test_element,
2390 int nSpace,
2391 double* dH,
2392 double* grad_v_X_w_dV,
2393 double* jacobian_weak_residual)
2394{
2395 int eN,i,j,k,I,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
2396 for(eN=0;eN<nElements_global;eN++)
2397 for (i=0;i<nDOF_test_element;i++)
2398 for (k=0;k<nQuadraturePoints_element;k++)
2399 for (j=0;j<nDOF_trial_element;j++)
2400 for (I=0;I<nSpace;I++)
2401 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
2402 i*nDOF_trial_element +
2403 j]
2404 +=
2405 dH[eN*nQuadraturePoints_element*nSpace +
2406 k*nSpace+
2407 I]
2408 *
2409 grad_v_X_w_dV[eN*nQuadraturePoints_element*nDOF_test_X_trial_element*nSpace +
2410 k*nDOF_test_X_trial_element*nSpace +
2411 j*nDOF_test_element*nSpace +
2412 i*nSpace+
2413 I];
2414}
2415
2416void updateHamiltonianJacobian_weak_lowmem(int nElements_global,
2417 int nQuadraturePoints_element,
2418 int nDOF_trial_element,
2419 int nDOF_test_element,
2420 int nSpace,
2421 double* dH,
2422 double* grad_v,
2423 double* w_dV,
2424 double* jacobian_weak_residual)
2425{
2426 int eN,i,j,k,I,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
2427 for(eN=0;eN<nElements_global;eN++)
2428 for (i=0;i<nDOF_test_element;i++)
2429 for (k=0;k<nQuadraturePoints_element;k++)
2430 for (j=0;j<nDOF_trial_element;j++)
2431 for (I=0;I<nSpace;I++)
2432 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
2433 i*nDOF_trial_element +
2434 j]
2435 +=
2436 dH[eN*nQuadraturePoints_element*nSpace +
2437 k*nSpace+
2438 I]
2439 *
2440 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
2441 k*nDOF_trial_element*nSpace +
2442 j*nSpace +
2443 I]
2444 *
2445 w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
2446 k*nDOF_test_element +
2447 i];
2448}
2449
2476void updateHamiltonian_strong(int nElements_global,
2477 int nQuadraturePoints_element,
2478 int nSpace,
2479 double* dH,
2480 double* grad_u,
2481 double* strong_residual)
2482{
2483 int eN,k,I;
2484 for(eN=0;eN<nElements_global;eN++)
2485 for (k=0;k<nQuadraturePoints_element;k++)
2486 for (I=0;I<nSpace;I++)
2487 strong_residual[eN*nQuadraturePoints_element+k]
2488 +=
2489 dH[eN*nQuadraturePoints_element*nSpace+
2490 k*nSpace+
2491 I]
2492 *
2493 grad_u[eN*nQuadraturePoints_element*nSpace+
2494 k*nSpace+
2495 I];
2496}
2497
2522void updateHamiltonianJacobian_strong(int nElements_global,
2523 int nQuadraturePoints_element,
2524 int nDOF_trial_element,
2525 int nSpace,
2526 double* dH,
2527 double* grad_v,
2528 double* dstrong_residual)
2529{
2530 int eN,k,j,I;
2531 for(eN=0;eN<nElements_global;eN++)
2532 for(j=0;j<nDOF_trial_element;j++)
2533 for (k=0;k<nQuadraturePoints_element;k++)
2534 for (I=0;I<nSpace;I++)
2535 dstrong_residual[eN*nQuadraturePoints_element*nDOF_trial_element+
2536 k*nDOF_trial_element +
2537 j]
2538 +=
2539 dH[eN*nQuadraturePoints_element*nSpace+
2540 k*nSpace+
2541 I]
2542 *
2543 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace+
2544 k*nDOF_trial_element*nSpace +
2545 j*nSpace +
2546 I];
2547}
2548
2580void updateHamiltonian_adjoint(int nElements_global,
2581 int nQuadraturePoints_element,
2582 int nDOF_test_element,
2583 int nSpace,
2584 double* dH,
2585 double* grad_w_dV,
2586 double* Lstar_w_dV)
2587{
2588 int eN,i,k,I;
2589 for(eN=0;eN<nElements_global;eN++)
2590 for (i=0;i<nDOF_test_element;i++)
2591 for (k=0;k<nQuadraturePoints_element;k++)
2592 for (I=0;I<nSpace;I++)
2593 Lstar_w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
2594 k*nDOF_test_element +
2595 i]
2596 -=
2597 dH[eN*nQuadraturePoints_element*nSpace +
2598 k*nSpace +
2599 I]
2600 *
2601 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
2602 k*nDOF_test_element*nSpace +
2603 i*nSpace +
2604 I];
2605}
2606
2647/*#define SCALAR_DIFFUSION*/
2648void updateDiffusion_weak(int nElements_global,
2649 int nQuadraturePoints_element,
2650 int nDOF_test_element,
2651 int nSpace,
2652 double* a,
2653 double* grad_phi_X_grad_w_dV,
2654 double* weak_residual)
2655{
2656 int eN,i,k,I,J,nSpace2=nSpace*nSpace;
2657 for(eN=0;eN<nElements_global;eN++)
2658 for (i=0;i<nDOF_test_element;i++)
2659 for (k=0;k<nQuadraturePoints_element;k++)
2660 for (I=0;I<nSpace;I++)
2661 for (J=0;J<nSpace;J++)
2662 weak_residual[eN*nDOF_test_element + i]
2663 +=
2664 a[eN*nQuadraturePoints_element*nSpace2 +
2665 k*nSpace2 +
2666 I*nSpace +
2667 J]
2668 *
2669 grad_phi_X_grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace2 +
2670 k*nDOF_test_element*nSpace2 +
2671 i*nSpace2+
2672 J*nSpace +
2673 I];
2674}
2675
2676void updateDiffusion_weak_lowmem(int nElements_global,
2677 int nQuadraturePoints_element,
2678 int nDOF_test_element,
2679 int nSpace,
2680 double* a,
2681 double* grad_phi,
2682 double* grad_w_dV,
2683 double* weak_residual)
2684{
2685 int eN,i,k,I,J,nSpace2=nSpace*nSpace;
2686 for(eN=0;eN<nElements_global;eN++)
2687 for (i=0;i<nDOF_test_element;i++)
2688 for (k=0;k<nQuadraturePoints_element;k++)
2689#ifdef SCALAR_DIFFUSION
2690 for (I=0;I<nSpace;I++)
2691 {
2692 J=I;
2693 weak_residual[eN*nDOF_test_element + i]
2694 +=
2695 a[eN*nQuadraturePoints_element*nSpace2 +
2696 k*nSpace2]
2697 *
2698 grad_phi[eN*nQuadraturePoints_element*nSpace +
2699 k*nSpace +
2700 J]
2701 *
2702 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
2703 k*nDOF_test_element*nSpace +
2704 i*nSpace+
2705 I];
2706 }
2707#else
2708 for (I=0;I<nSpace;I++)
2709 for (J=0;J<nSpace;J++)
2710 weak_residual[eN*nDOF_test_element + i]
2711 +=
2712 a[eN*nQuadraturePoints_element*nSpace2 +
2713 k*nSpace2 +
2714 I*nSpace +
2715 J]
2716 *
2717 grad_phi[eN*nQuadraturePoints_element*nSpace +
2718 k*nSpace +
2719 J]
2720 *
2721 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
2722 k*nDOF_test_element*nSpace +
2723 i*nSpace+
2724 I];
2725#endif
2726}
2727
2728void updateDiffusion_weak_sd(int nElements_global,
2729 int nQuadraturePoints_element,
2730 int nDOF_test_element,
2731 int nSpace,
2732 int* rowptr,
2733 int* colind,
2734 double* a,
2735 double* grad_phi,
2736 double* grad_w_dV,
2737 double* weak_residual)
2738{
2739 int eN,i,k,I,m,nnz=rowptr[nSpace];
2740 for(eN=0;eN<nElements_global;eN++)
2741 for (i=0;i<nDOF_test_element;i++)
2742 for (k=0;k<nQuadraturePoints_element;k++)
2743 for (I=0;I<nSpace;I++)
2744 for (m=rowptr[I];m<rowptr[I+1];m++)
2745 weak_residual[eN*nDOF_test_element + i]
2746 +=
2747 a[eN*nQuadraturePoints_element*nnz+
2748 k*nnz +
2749 m]
2750 *
2751 grad_phi[eN*nQuadraturePoints_element*nSpace +
2752 k*nSpace +
2753 colind[m]]
2754 *
2755 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
2756 k*nDOF_test_element*nSpace +
2757 i*nSpace+
2758 I];
2759}
2760
2833void updateDiffusionJacobian_weak(int nElements_global,
2834 int nQuadraturePoints_element,
2835 int nDOF_trial_element,
2836 int nDOF_test_element,
2837 int nSpace,
2838 int* l2g,
2839 double* a,
2840 double* da,
2841 double* grad_phi_X_grad_w_dV,
2842 double* dphi,
2843 double* v,
2844 double* grad_v_X_grad_w_dV,
2845 double* jacobian_weak_residual)
2846{
2847 int eN,i,j,k,I,J,nSpace2=nSpace*nSpace,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
2848 double daProduct,dphiProduct;
2849 for(eN=0;eN<nElements_global;eN++)
2850 for (i=0;i<nDOF_test_element;i++)
2851 for (k=0;k<nQuadraturePoints_element;k++)
2852 {
2853 daProduct=0.0;
2854 for (I=0;I<nSpace;I++)
2855 for (J=0;J<nSpace;J++)
2856 daProduct
2857 +=
2858 da[eN*nQuadraturePoints_element*nSpace2 +
2859 k*nSpace2 +
2860 I*nSpace +
2861 J]
2862 *
2863 grad_phi_X_grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace2 +
2864 k*nDOF_test_element*nSpace2 +
2865 i*nSpace2+
2866 J*nSpace +
2867 I];
2868 for (j=0;j<nDOF_trial_element;j++)
2869 {
2870 dphiProduct=0.0;
2871 for (I=0;I<nSpace;I++)
2872 for (J=0;J<nSpace;J++)
2873 dphiProduct
2874 +=
2875 a[eN*nQuadraturePoints_element*nSpace2 +
2876 k*nSpace2+
2877 I*nSpace +
2878 J]
2879 *
2880 grad_v_X_grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_X_trial_element*nSpace2 +
2881 k*nDOF_test_X_trial_element*nSpace2 +
2882 j*nDOF_test_element*nSpace2 +
2883 i*nSpace2 +
2884 J*nSpace +
2885 I];
2886 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
2887 i*nDOF_trial_element +
2888 j]
2889 +=
2890 daProduct
2891 *
2892 v[eN*nQuadraturePoints_element*nDOF_trial_element+
2893 k*nDOF_trial_element+
2894 j]
2895 +
2896 dphiProduct
2897 *
2898 dphi[l2g[eN*nDOF_trial_element +
2899 j]];
2900 }
2901 }
2902}
2903
2904void updateDiffusionJacobian_weak_lowmem(int nElements_global,
2905 int nQuadraturePoints_element,
2906 int nDOF_trial_element,
2907 int nDOF_test_element,
2908 int nSpace,
2909 int* l2g,
2910 double* a,
2911 double* da,
2912 double* grad_phi,
2913 double* grad_w_dV,
2914 double* dphi,
2915 double* v,
2916 double* grad_v,
2917 double* jacobian_weak_residual)
2918{
2919 int eN,i,j,k,I,J,nSpace2=nSpace*nSpace,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
2920 double daProduct,dphiProduct;
2921 for(eN=0;eN<nElements_global;eN++)
2922 for (i=0;i<nDOF_test_element;i++)
2923 for (k=0;k<nQuadraturePoints_element;k++)
2924 {
2925 daProduct=0.0;
2926#ifdef SCALAR_DIFFUSION
2927 for (I=0;I<nSpace;I++)
2928 {
2929 J=I;
2930 daProduct
2931 +=
2932 da[eN*nQuadraturePoints_element*nSpace2 +
2933 k*nSpace2]
2934 *
2935 grad_phi[eN*nQuadraturePoints_element*nSpace +
2936 k*nSpace +
2937 J]
2938 *
2939 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
2940 k*nDOF_test_element*nSpace +
2941 i*nSpace+
2942 I];
2943 }
2944 for (j=0;j<nDOF_trial_element;j++)
2945 {
2946 dphiProduct=0.0;
2947 for (I=0;I<nSpace;I++)
2948 {
2949 J=I;
2950 dphiProduct
2951 +=
2952 a[eN*nQuadraturePoints_element*nSpace2 +
2953 k*nSpace2]
2954 *
2955 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
2956 k*nDOF_trial_element*nSpace +
2957 j*nSpace +
2958 J]
2959 *
2960 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
2961 k*nDOF_test_element*nSpace +
2962 i*nSpace +
2963 I];
2964 }
2965 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
2966 i*nDOF_trial_element +
2967 j]
2968 +=
2969 daProduct
2970 *
2971 v[eN*nQuadraturePoints_element*nDOF_trial_element+
2972 k*nDOF_trial_element+
2973 j]
2974 +
2975 dphiProduct
2976 *
2977 dphi[l2g[eN*nDOF_trial_element +
2978 j]];
2979 }
2980#else
2981 for (I=0;I<nSpace;I++)
2982 for (J=0;J<nSpace;J++)
2983 daProduct
2984 +=
2985 da[eN*nQuadraturePoints_element*nSpace2 +
2986 k*nSpace2 +
2987 I*nSpace +
2988 J]
2989 *
2990 grad_phi[eN*nQuadraturePoints_element*nSpace +
2991 k*nSpace +
2992 J]
2993 *
2994 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
2995 k*nDOF_test_element*nSpace +
2996 i*nSpace+
2997 I];
2998 for (j=0;j<nDOF_trial_element;j++)
2999 {
3000 dphiProduct=0.0;
3001 for (I=0;I<nSpace;I++)
3002 for (J=0;J<nSpace;J++)
3003 dphiProduct
3004 +=
3005 a[eN*nQuadraturePoints_element*nSpace2 +
3006 k*nSpace2+
3007 I*nSpace +
3008 J]
3009 *
3010 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
3011 k*nDOF_trial_element*nSpace +
3012 j*nSpace +
3013 J]
3014 *
3015 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
3016 k*nDOF_test_element*nSpace +
3017 i*nSpace +
3018 I];
3019 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
3020 i*nDOF_trial_element +
3021 j]
3022 +=
3023 daProduct
3024 *
3025 v[eN*nQuadraturePoints_element*nDOF_trial_element+
3026 k*nDOF_trial_element+
3027 j]
3028 +
3029 dphiProduct
3030 *
3031 dphi[l2g[eN*nDOF_trial_element +
3032 j]];
3033 }
3034#endif
3035 }
3036}
3037void updateDiffusionJacobian_weak_sd(int nElements_global,
3038 int nQuadraturePoints_element,
3039 int nDOF_trial_element,
3040 int nDOF_test_element,
3041 int nSpace,
3042 int* rowptr,
3043 int* colind,
3044 int* l2g,
3045 double* a,
3046 double* da,
3047 double* grad_phi,
3048 double* grad_w_dV,
3049 double* dphi,
3050 double* v,
3051 double* grad_v,
3052 double* jacobian_weak_residual)
3053{
3054 int eN,i,j,k,I,m,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,nnz=rowptr[nSpace];
3055 double daProduct,dphiProduct;
3056 for(eN=0;eN<nElements_global;eN++)
3057 for (i=0;i<nDOF_test_element;i++)
3058 for (k=0;k<nQuadraturePoints_element;k++)
3059 {
3060 daProduct=0.0;
3061 for (I=0;I<nSpace;I++)
3062 for (m=rowptr[I];m<rowptr[I+1];m++)
3063 daProduct
3064 +=
3065 da[eN*nQuadraturePoints_element*nnz+
3066 k*nnz +
3067 m]
3068 *
3069 grad_phi[eN*nQuadraturePoints_element*nSpace +
3070 k*nSpace +
3071 colind[m]]
3072 *
3073 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
3074 k*nDOF_test_element*nSpace +
3075 i*nSpace+
3076 I];
3077 for (j=0;j<nDOF_trial_element;j++)
3078 {
3079 dphiProduct=0.0;
3080 for (I=0;I<nSpace;I++)
3081 for(m=rowptr[I];m<rowptr[I+1];m++)
3082 dphiProduct
3083 +=
3084 a[eN*nQuadraturePoints_element*nnz +
3085 k*nnz+
3086 m]
3087 *
3088 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
3089 k*nDOF_trial_element*nSpace +
3090 j*nSpace +
3091 colind[m]]
3092 *
3093 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
3094 k*nDOF_test_element*nSpace +
3095 i*nSpace +
3096 I];
3097 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
3098 i*nDOF_trial_element +
3099 j]
3100 +=
3101 daProduct
3102 *
3103 v[eN*nQuadraturePoints_element*nDOF_trial_element+
3104 k*nDOF_trial_element+
3105 j]
3106 +
3107 dphiProduct
3108 *
3109 dphi[l2g[eN*nDOF_trial_element +
3110 j]];
3111 }
3112 }
3113}
3114
3139void updateDiffusion_strong(int nElements_global,
3140 int nQuadraturePoints_element,
3141 int nSpace,
3142 double* da,
3143 double* grad_phi,
3144 double* grad_u,
3145 double* strong_residual)
3146{
3147 int eN,k,I,J,nSpace2=nSpace*nSpace;
3148 for(eN=0;eN<nElements_global;eN++)
3149 for (k=0;k<nQuadraturePoints_element;k++)
3150 for(I=0;I<nSpace;I++)
3151 for (J=0;J<nSpace;J++)
3152 strong_residual[eN*nQuadraturePoints_element+
3153 k]
3154 -=
3155 da[eN*nQuadraturePoints_element*nSpace2 +
3156 k*nSpace2 +
3157 I*nSpace+
3158 J]
3159 *
3160 grad_phi[eN*nQuadraturePoints_element*nSpace +
3161 k*nSpace +
3162 J]
3163 *grad_u[eN*nQuadraturePoints_element*nSpace +
3164 k*nSpace +
3165 I];
3166}
3167void updateDiffusion_strong_sd(int nElements_global,
3168 int nQuadraturePoints_element,
3169 int nSpace,
3170 int* rowptr,
3171 int* colind,
3172 double* da,
3173 double* grad_phi,
3174 double* grad_u,
3175 double* strong_residual)
3176{
3177 int eN,k,I,m,nnz=rowptr[nSpace];
3178 for(eN=0;eN<nElements_global;eN++)
3179 for (k=0;k<nQuadraturePoints_element;k++)
3180 for(I=0;I<nSpace;I++)
3181 for(m=rowptr[I];m<rowptr[I+1];m++)
3182 strong_residual[eN*nQuadraturePoints_element+
3183 k]
3184 -=
3185 da[eN*nQuadraturePoints_element*nnz +
3186 k*nnz+
3187 m]
3188 *
3189 grad_phi[eN*nQuadraturePoints_element*nSpace +
3190 k*nSpace +
3191 colind[m]]
3192 *grad_u[eN*nQuadraturePoints_element*nSpace +
3193 k*nSpace +
3194 I];
3195}
3196
3221void updateDiffusionJacobian_strong(int nElements_global,
3222 int nQuadraturePoints_element,
3223 int nDOF_trial_element,
3224 int nSpace,
3225 int* l2g,
3226 double* da,
3227 double* dphi,
3228 double* grad_phi,
3229 double* grad_u,
3230 double* grad_v,
3231 double* dstrong_residual)
3232{
3233 int eN,k,j,I,J,nSpace2=nSpace*nSpace;
3234 for(eN=0;eN<nElements_global;eN++)
3235 for (k=0;k<nQuadraturePoints_element;k++)
3236 for(j=0;j<nDOF_trial_element;j++)
3237 for(I=0;I<nSpace;I++)
3238 for(J=0;J<nSpace;J++)
3239 {
3240 dstrong_residual[eN*nQuadraturePoints_element*nDOF_trial_element+
3241 k*nDOF_trial_element +
3242 j]
3243 -=
3244 da[eN*nQuadraturePoints_element*nSpace2 +
3245 k*nSpace2 +
3246 I*nSpace+
3247 J]
3248 *
3249 (
3250 grad_phi[eN*nQuadraturePoints_element*nSpace +
3251 k*nSpace +
3252 J]
3253 *
3254 grad_v[eN*nQuadraturePoints_element*nSpace*nDOF_trial_element +
3255 k*nSpace*nDOF_trial_element +
3256 j*nSpace +
3257 I]
3258 +
3259 dphi[l2g[eN*nDOF_trial_element +
3260 j]]*
3261 grad_v[eN*nQuadraturePoints_element*nSpace*nDOF_trial_element +
3262 k*nSpace*nDOF_trial_element +
3263 j*nSpace +
3264 J]
3265 *
3266 grad_u[eN*nQuadraturePoints_element*nSpace+
3267 k*nSpace+
3268 I]
3269 );
3270 }
3271}
3272void updateDiffusionJacobian_strong_sd(int nElements_global,
3273 int nQuadraturePoints_element,
3274 int nDOF_trial_element,
3275 int nSpace,
3276 int* rowptr,
3277 int* colind,
3278 int* l2g,
3279 double* da,
3280 double* dphi,
3281 double* grad_phi,
3282 double* grad_u,
3283 double* grad_v,
3284 double* dstrong_residual)
3285{
3286 int eN,k,j,I,m,nnz=rowptr[nSpace];
3287 for(eN=0;eN<nElements_global;eN++)
3288 for (k=0;k<nQuadraturePoints_element;k++)
3289 for(j=0;j<nDOF_trial_element;j++)
3290 for(I=0;I<nSpace;I++)
3291 for(m=rowptr[I];m<rowptr[I+1];m++)
3292 {
3293 dstrong_residual[eN*nQuadraturePoints_element*nDOF_trial_element+
3294 k*nDOF_trial_element +
3295 j]
3296 -=
3297 da[eN*nQuadraturePoints_element*nnz +
3298 k*nnz+
3299 m]
3300 *
3301 (
3302 grad_phi[eN*nQuadraturePoints_element*nSpace +
3303 k*nSpace +
3304 colind[m]]
3305 *
3306 grad_v[eN*nQuadraturePoints_element*nSpace*nDOF_trial_element +
3307 k*nSpace*nDOF_trial_element +
3308 j*nSpace +
3309 I]
3310 +
3311 dphi[l2g[eN*nDOF_trial_element +
3312 j]]*
3313 grad_v[eN*nQuadraturePoints_element*nSpace*nDOF_trial_element +
3314 k*nSpace*nDOF_trial_element +
3315 j*nSpace +
3316 colind[m]]
3317 *
3318 grad_u[eN*nQuadraturePoints_element*nSpace+
3319 k*nSpace+
3320 I]
3321 );
3322 }
3323}
3324
3325
3358void updateDiffusion_adjoint(int nElements_global,
3359 int nQuadraturePoints_element,
3360 int nDOF_test_element,
3361 int nSpace,
3362 double* da,
3363 double* grad_phi,
3364 double* grad_w_dV,
3365 double* Lstar_w_dV)
3366{
3367 int eN,i,k,I,J,nSpace2=nSpace*nSpace;
3368 for(eN=0;eN<nElements_global;eN++)
3369 for (i=0;i<nDOF_test_element;i++)
3370 for (k=0;k<nQuadraturePoints_element;k++)
3371 for (I=0;I<nSpace;I++)
3372 for(J=0;J<nSpace;J++)
3373 Lstar_w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
3374 k*nDOF_test_element +
3375 i]
3376 +=
3377 da[eN*nQuadraturePoints_element*nSpace2 +
3378 k*nSpace2 +
3379 I*nSpace+
3380 J]
3381 *
3382 grad_phi[eN*nQuadraturePoints_element*nSpace+
3383 k*nSpace+
3384 J]
3385 *
3386 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
3387 k*nDOF_test_element*nSpace +
3388 i*nSpace +
3389 I];
3390}
3391
3392void updateDiffusion_adjoint_sd(int nElements_global,
3393 int nQuadraturePoints_element,
3394 int nDOF_test_element,
3395 int nSpace,
3396 int* rowptr,
3397 int* colind,
3398 double* da,
3399 double* grad_phi,
3400 double* grad_w_dV,
3401 double* Lstar_w_dV)
3402{
3403 int eN,i,k,I,m,nnz=rowptr[nSpace];
3404 for(eN=0;eN<nElements_global;eN++)
3405 for (i=0;i<nDOF_test_element;i++)
3406 for (k=0;k<nQuadraturePoints_element;k++)
3407 for (I=0;I<nSpace;I++)
3408 for(m=rowptr[I];m<rowptr[I+1];m++)
3409 Lstar_w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
3410 k*nDOF_test_element +
3411 i]
3412 +=
3413 da[eN*nQuadraturePoints_element*nnz +
3414 k*nnz+
3415 m]
3416 *
3417 grad_phi[eN*nQuadraturePoints_element*nSpace+
3418 k*nSpace+
3419 colind[m]]
3420 *
3421 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
3422 k*nDOF_test_element*nSpace +
3423 i*nSpace +
3424 I];
3425}
3426
3427void updateDiffusion2_strong(int nElements_global,
3428 int nQuadraturePoints_element,
3429 int nSpace,
3430 double* a,
3431 double* Hess_phi,
3432 double* strong_residual)
3433{
3434 int eN,k,I,J,nSpace2=nSpace*nSpace;
3435 for(eN=0;eN<nElements_global;eN++)
3436 for (k=0;k<nQuadraturePoints_element;k++)
3437 for(I=0;I<nSpace;I++)
3438 for (J=0;J<nSpace;J++)
3439 {
3440 strong_residual[eN*nQuadraturePoints_element+
3441 k]
3442 -=
3443 a[eN*nQuadraturePoints_element*nSpace2 +
3444 k*nSpace2 +
3445 I*nSpace+
3446 J]
3447 *
3448 Hess_phi[eN*nQuadraturePoints_element*nSpace2 +
3449 k*nSpace2 +
3450 J*nSpace+
3451 I];
3452 }
3453}
3454
3455void updateDiffusion2_strong_sd(int nElements_global,
3456 int nQuadraturePoints_element,
3457 int nSpace,
3458 int* rowptr,
3459 int* colind,
3460 double* a,
3461 double* Hess_phi,
3462 double* strong_residual)
3463{
3464 int eN,k,I,m,nSpace2=nSpace*nSpace,nnz=rowptr[nSpace];
3465 for(eN=0;eN<nElements_global;eN++)
3466 for (k=0;k<nQuadraturePoints_element;k++)
3467 for(I=0;I<nSpace;I++)
3468 for (m=rowptr[I];m<rowptr[I+1];m++)
3469 {
3470 strong_residual[eN*nQuadraturePoints_element+
3471 k]
3472 -=
3473 a[eN*nQuadraturePoints_element*nnz +
3474 k*nnz+
3475 m]
3476 *
3477 Hess_phi[eN*nQuadraturePoints_element*nSpace2 +
3478 k*nSpace2 +
3479 colind[m]*nSpace+
3480 I];
3481 }
3482}
3483
3484void updateDiffusionJacobian2_strong(int nElements_global,
3485 int nQuadraturePoints_element,
3486 int nDOF_trial_element,
3487 int nSpace,
3488 int* l2g,
3489 double* a,
3490 double* da,
3491 double* v,
3492 double* Hess_phi,
3493 double* dphi,
3494 double* Hess_v,
3495 double* dstrong_residual)
3496{
3497 int eN,k,j,I,J,nSpace2=nSpace*nSpace;
3498 /*double tmp;*/
3499 for(eN=0;eN<nElements_global;eN++)
3500 for (k=0;k<nQuadraturePoints_element;k++)
3501 for (j=0;j<nDOF_trial_element;j++)
3502 for(I=0;I<nSpace;I++)
3503 for (J=0;J<nSpace;J++)
3504 {
3505 dstrong_residual[eN*nQuadraturePoints_element*nDOF_trial_element+
3506 k*nDOF_trial_element+
3507 j]
3508 -=
3509 (da[eN*nQuadraturePoints_element*nSpace2 +
3510 k*nSpace2 +
3511 I*nSpace+
3512 J]
3513 *
3514 v[eN*nQuadraturePoints_element*nDOF_trial_element+
3515 k*nDOF_trial_element+
3516 j]
3517 *
3518 Hess_phi[eN*nQuadraturePoints_element*nSpace2 +
3519 k*nSpace2 +
3520 J*nSpace+
3521 I]
3522 +
3523 a[eN*nQuadraturePoints_element*nSpace2 +
3524 k*nSpace2 +
3525 I*nSpace+
3526 J]
3527 *
3528 dphi[l2g[eN*nDOF_trial_element +
3529 j]]
3530 *
3531 Hess_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace2 +
3532 k*nDOF_trial_element*nSpace2 +
3533 j*nSpace2+
3534 J*nSpace+
3535 I]);
3536 }
3537}
3538
3539void updateDiffusionJacobian2_strong_sd(int nElements_global,
3540 int nQuadraturePoints_element,
3541 int nDOF_trial_element,
3542 int nSpace,
3543 int* rowptr,
3544 int* colind,
3545 int* l2g,
3546 double* a,
3547 double* da,
3548 double* v,
3549 double* Hess_phi,
3550 double* dphi,
3551 double* Hess_v,
3552 double* dstrong_residual)
3553{
3554 int eN,k,j,I,m,nSpace2=nSpace*nSpace,nnz=rowptr[nSpace];
3555 /*double tmp;*/
3556 for(eN=0;eN<nElements_global;eN++)
3557 for (k=0;k<nQuadraturePoints_element;k++)
3558 for (j=0;j<nDOF_trial_element;j++)
3559 for(I=0;I<nSpace;I++)
3560 for (m=rowptr[I];m<rowptr[I+1];m++)
3561 {
3562 dstrong_residual[eN*nQuadraturePoints_element*nDOF_trial_element+
3563 k*nDOF_trial_element+
3564 j]
3565 -=
3566 (da[eN*nQuadraturePoints_element*nnz+
3567 k*nnz+
3568 m]
3569 *
3570 v[eN*nQuadraturePoints_element*nDOF_trial_element+
3571 k*nDOF_trial_element+
3572 j]
3573 *
3574 Hess_phi[eN*nQuadraturePoints_element*nSpace2 +
3575 k*nSpace2 +
3576 colind[m]*nSpace+
3577 I]
3578 +
3579 a[eN*nQuadraturePoints_element*nnz+
3580 k*nnz+
3581 m]
3582 *
3583 dphi[l2g[eN*nDOF_trial_element +
3584 j]]
3585 *
3586 Hess_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace2 +
3587 k*nDOF_trial_element*nSpace2 +
3588 j*nSpace2+
3589 colind[m]*nSpace+
3590 I]);
3591 }
3592}
3593
3594void updateDiffusion2_adjoint(int nElements_global,
3595 int nQuadraturePoints_element,
3596 int nDOF_test_element,
3597 int nSpace,
3598 double* a,
3599 double* Hess_w_dV,
3600 double* Lstar_w_dV)
3601{
3602 int eN,i,k,I,J,nSpace2=nSpace*nSpace;
3603 for(eN=0;eN<nElements_global;eN++)
3604 for (i=0;i<nDOF_test_element;i++)
3605 for (k=0;k<nQuadraturePoints_element;k++)
3606 for (I=0;I<nSpace;I++)
3607 for(J=0;J<nSpace;J++)
3608 {
3609 Lstar_w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
3610 k*nDOF_test_element +
3611 i]
3612 -=
3613 a[eN*nQuadraturePoints_element*nSpace2 +
3614 k*nSpace2 +
3615 I*nSpace+
3616 J]
3617 *
3618 Hess_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace2 +
3619 k*nDOF_test_element*nSpace2 +
3620 i*nSpace2+
3621 I*nSpace +
3622 J];
3623 }
3624}
3625
3626
3627void updateDiffusion2_adjoint_sd(int nElements_global,
3628 int nQuadraturePoints_element,
3629 int nDOF_test_element,
3630 int nSpace,
3631 int* rowptr,
3632 int* colind,
3633 double* a,
3634 double* Hess_w_dV,
3635 double* Lstar_w_dV)
3636{
3637 int eN,i,k,I,m,nSpace2=nSpace*nSpace,nnz=rowptr[nSpace];
3638 for(eN=0;eN<nElements_global;eN++)
3639 for (i=0;i<nDOF_test_element;i++)
3640 for (k=0;k<nQuadraturePoints_element;k++)
3641 for (I=0;I<nSpace;I++)
3642 for(m=rowptr[I];m<rowptr[I+1];m++)
3643 {
3644 Lstar_w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
3645 k*nDOF_test_element +
3646 i]
3647 -=
3648 a[eN*nQuadraturePoints_element*nnz+
3649 k*nnz+
3650 m]
3651 *
3652 Hess_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace2 +
3653 k*nDOF_test_element*nSpace2 +
3654 i*nSpace2+
3655 I*nSpace +
3656 colind[m]];
3657 }
3658}
3659
3660
3694void updateReaction_weak(int nElements_global,
3695 int nQuadraturePoints_element,
3696 int nDOF_test_element,
3697 double* r,
3698 double* w_dV,
3699 double* weak_residual)
3700{
3701 updateMass_weak(nElements_global,nQuadraturePoints_element,nDOF_test_element,r,w_dV,weak_residual);
3702}
3703
3743void updateReactionJacobian_weak(int nElements_global,
3744 int nQuadraturePoints_element,
3745 int nDOF_trial_element,
3746 int nDOF_test_element,
3747 double* dr,
3748 double* v_X_w_dV,
3749 double* jacobian_weak_residual)
3750{
3751 updateMassJacobian_weak(nElements_global,nQuadraturePoints_element,nDOF_trial_element,nDOF_test_element,dr,v_X_w_dV,jacobian_weak_residual);
3752}
3753
3754void updateReactionJacobian_weak_lowmem(int nElements_global,
3755 int nQuadraturePoints_element,
3756 int nDOF_trial_element,
3757 int nDOF_test_element,
3758 double* dr,
3759 double* v,
3760 double* w_dV,
3761 double* jacobian_weak_residual)
3762{
3763 updateMassJacobian_weak_lowmem(nElements_global,nQuadraturePoints_element,nDOF_trial_element,nDOF_test_element,dr,
3764 v,w_dV,jacobian_weak_residual);
3765}
3766
3785void updateReaction_strong(int nElements_global,
3786 int nQuadraturePoints_element,
3787 double* r,
3788 double* strong_residual)
3789{
3790 int eN,k;
3791 for(eN=0;eN<nElements_global;eN++)
3792 for (k=0;k<nQuadraturePoints_element;k++)
3793 strong_residual[eN*nQuadraturePoints_element+
3794 k]
3795 +=
3796 r[eN*nQuadraturePoints_element+
3797 k];
3798}
3799
3819void updateReactionJacobian_strong(int nElements_global,
3820 int nQuadraturePoints_element,
3821 int nDOF_trial_element,
3822 double* dr,
3823 double* v,
3824 double* dstrong_residual)
3825{
3826 int eN,k,j;
3827 for(eN=0;eN<nElements_global;eN++)
3828 for(j=0;j<nDOF_trial_element;j++)
3829 for (k=0;k<nQuadraturePoints_element;k++)
3830 dstrong_residual[eN*nQuadraturePoints_element*nDOF_trial_element+
3831 k*nDOF_trial_element +
3832 j]
3833 +=
3834 dr[eN*nQuadraturePoints_element+
3835 k]
3836 *
3837 v[eN*nQuadraturePoints_element*nDOF_trial_element+
3838 k*nDOF_trial_element +
3839 j];
3840}
3841
3866void updateReaction_adjoint(int nElements_global,
3867 int nQuadraturePoints_element,
3868 int nDOF_test_element,
3869 double* dr,
3870 double* w_dV,
3871 double* Lstar_w_dV)
3872{
3873 int eN,i,k;
3874 for(eN=0;eN<nElements_global;eN++)
3875 for (i=0;i<nDOF_test_element;i++)
3876 for (k=0;k<nQuadraturePoints_element;k++)
3877 Lstar_w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
3878 k*nDOF_test_element +
3879 i]
3880 +=
3881 dr[eN*nQuadraturePoints_element +
3882 k]
3883 *
3884 w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
3885 k*nDOF_test_element +
3886 i];
3887}
3888
3889
3923void updateSubgridError(int nElements_global,
3924 int nQuadraturePoints_element,
3925 int nDOF_test_element,
3926 double* error,
3927 double* Lstar_w_dV,
3928 double* weak_residual)
3929{
3930 int eN,i,k;
3931 for(eN=0;eN<nElements_global;eN++)
3932 for (i=0;i<nDOF_test_element;i++)
3933 for (k=0;k<nQuadraturePoints_element;k++)
3934 weak_residual[eN*nDOF_test_element + i]
3935 +=
3936 error[eN*nQuadraturePoints_element +
3937 k]
3938 *
3939 Lstar_w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
3940 k*nDOF_test_element +
3941 i];
3942}
3943
3983void updateSubgridErrorJacobian(int nElements_global,
3984 int nQuadraturePoints_element,
3985 int nDOF_trial_element,
3986 int nDOF_test_element,
3987 double* derror,
3988 double* Lstar_w_dV,
3989 double* jacobian_weak_residual)
3990{
3991 int eN,i,j,k,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
3992 for(eN=0;eN<nElements_global;eN++)
3993 for (i=0;i<nDOF_test_element;i++)
3994 for (k=0;k<nQuadraturePoints_element;k++)
3995 for (j=0;j<nDOF_trial_element;j++)
3996 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
3997 i*nDOF_trial_element +
3998 j]
3999 +=
4000 derror[eN*nQuadraturePoints_element*nDOF_trial_element+
4001 k*nDOF_trial_element+
4002 j]
4003 *
4004 Lstar_w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
4005 k*nDOF_test_element +
4006 i];
4007}
4008
4048void updateNumericalDiffusion(int nElements_global,
4049 int nQuadraturePoints_element,
4050 int nDOF_test_element,
4051 int nSpace,
4052 double* numDiff,
4053 double* grad_u_X_grad_w_dV,
4054 double* weak_residual)
4055{
4056 int eN,i,k,I,nSpace2=nSpace*nSpace;
4057 for(eN=0;eN<nElements_global;eN++)
4058 for (i=0;i<nDOF_test_element;i++)
4059 for (k=0;k<nQuadraturePoints_element;k++)
4060 for (I=0;I<nSpace;I++)
4061 weak_residual[eN*nDOF_test_element + i]
4062 +=
4063 numDiff[eN*nQuadraturePoints_element +
4064 k]
4065 *
4066 grad_u_X_grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace2 +
4067 k*nDOF_test_element*nSpace2 +
4068 i*nSpace2 +
4069 I*nSpace +
4070 I];
4071}
4072
4073void updateNumericalDiffusion_lowmem(int nElements_global,
4074 int nQuadraturePoints_element,
4075 int nDOF_test_element,
4076 int nSpace,
4077 double* numDiff,
4078 double* grad_u,
4079 double* grad_w_dV,
4080 double* weak_residual)
4081{
4082 int eN,i,k,I;
4083 for(eN=0;eN<nElements_global;eN++)
4084 for (i=0;i<nDOF_test_element;i++)
4085 for (k=0;k<nQuadraturePoints_element;k++)
4086 for (I=0;I<nSpace;I++)
4087 weak_residual[eN*nDOF_test_element + i]
4088 +=
4089 numDiff[eN*nQuadraturePoints_element +
4090 k]
4091 *
4092 grad_u[eN*nQuadraturePoints_element*nSpace +
4093 k*nSpace +
4094 I]
4095 *
4096 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
4097 k*nDOF_test_element*nSpace +
4098 i*nSpace +
4099 I];
4100}
4101
4145void updateNumericalDiffusionJacobian(int nElements_global,
4146 int nQuadraturePoints_element,
4147 int nDOF_trial_element,
4148 int nDOF_test_element,
4149 int nSpace,
4150 double* numDiff,
4151 double* grad_v_X_grad_w_dV,
4152 double* jacobian_weak_residual)
4153{
4154 int eN,i,j,k,I,nSpace2=nSpace*nSpace,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
4155 for(eN=0;eN<nElements_global;eN++)
4156 for (i=0;i<nDOF_test_element;i++)
4157 for (k=0;k<nQuadraturePoints_element;k++)
4158 for (j=0;j<nDOF_trial_element;j++)
4159 for (I=0;I<nSpace;I++)
4160 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
4161 i*nDOF_trial_element +
4162 j]
4163 +=
4164 numDiff[eN*nQuadraturePoints_element +
4165 k]
4166 *
4167 grad_v_X_grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_X_trial_element*nSpace2 +
4168 k*nDOF_test_X_trial_element*nSpace2 +
4169 j*nDOF_test_element*nSpace2 +
4170 i*nSpace2 +
4171 I*nSpace +
4172 I];
4173}
4174
4175void updateNumericalDiffusionJacobian_lowmem(int nElements_global,
4176 int nQuadraturePoints_element,
4177 int nDOF_trial_element,
4178 int nDOF_test_element,
4179 int nSpace,
4180 double* numDiff,
4181 double* grad_v,
4182 double* grad_w_dV,
4183 double* jacobian_weak_residual)
4184{
4185 int eN,i,j,k,I,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
4186 for(eN=0;eN<nElements_global;eN++)
4187 for (i=0;i<nDOF_test_element;i++)
4188 for (k=0;k<nQuadraturePoints_element;k++)
4189 for (j=0;j<nDOF_trial_element;j++)
4190 for (I=0;I<nSpace;I++)
4191 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
4192 i*nDOF_trial_element +
4193 j]
4194 +=
4195 numDiff[eN*nQuadraturePoints_element +
4196 k]
4197 *
4198 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
4199 k*nDOF_trial_element*nSpace +
4200 j*nSpace +
4201 I]
4202 *
4203 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
4204 k*nDOF_test_element*nSpace +
4205 i*nSpace +
4206 I];
4207}
4208
4212void calculateScalarScalarProduct(int nElements_global,
4213 int nQuadraturePoints_element,
4214 double* s1,
4215 double* s2,
4216 double* sResult)
4217{
4218 int eN,k;
4219 for(eN=0;eN<nElements_global;eN++)
4220 for (k=0;k<nQuadraturePoints_element;k++)
4221 sResult[eN*nQuadraturePoints_element +
4222 k]
4223 =
4224 s1[eN*nQuadraturePoints_element +
4225 k]
4226 *
4227 s2[eN*nQuadraturePoints_element +
4228 k];
4229}
4230
4234void calculateVectorScalarProduct(int nElements_global,
4235 int nQuadraturePoints_element,
4236 int nSpace,
4237 double* v,
4238 double* s,
4239 double* vResult)
4240{
4241 int eN,k,I;
4242 for(eN=0;eN<nElements_global;eN++)
4243 for (k=0;k<nQuadraturePoints_element;k++)
4244 for (I=0;I<nSpace;I++)
4245 vResult[eN*nQuadraturePoints_element*nSpace +
4246 k*nSpace +
4247 I]
4248 =
4249 v[eN*nQuadraturePoints_element*nSpace +
4250 k*nSpace +
4251 I]
4252 *
4253 s[eN*nQuadraturePoints_element +
4254 k];
4255}
4256
4260void calculateTensorScalarProduct(int nElements_global,
4261 int nQuadraturePoints_element,
4262 int nSpace,
4263 double* t,
4264 double* s,
4265 double* tResult)
4266{
4267 int eN,k,I,J,nSpace2=nSpace*nSpace;
4268 for(eN=0;eN<nElements_global;eN++)
4269 for (k=0;k<nQuadraturePoints_element;k++)
4270 for (I=0;I<nSpace;I++)
4271 for (J=0;J<nSpace;J++)
4272 tResult[eN*nQuadraturePoints_element*nSpace2 +
4273 k*nSpace2 +
4274 I*nSpace +
4275 J]
4276 =
4277 t[eN*nQuadraturePoints_element*nSpace2 +
4278 k*nSpace2 +
4279 I*nSpace +
4280 J]
4281 *
4282 s[eN*nQuadraturePoints_element +
4283 k];
4284}
4285
4286
4287
4288
4289
4290
4294void updateInteriorElementBoundaryFlux(int nInteriorElementBoundaries_global,
4295 int nElementBoundaries_element,
4296 int nQuadraturePoints_elementBoundary,
4297 int nDOF_test_element,
4298 int* interiorElementBoundaries,
4299 int* elementBoundaryElements,
4300 int* elementBoundaryLocalElementBoundaries,
4301 double* flux,
4302 double* w_dS,
4303 double* residual)
4304{
4305 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,i,k;
4306 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
4307 {
4308 ebN = interiorElementBoundaries[ebNI];
4309 left_eN_global = elementBoundaryElements[ebN*2+0];
4310 right_eN_global = elementBoundaryElements[ebN*2+1];
4311 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4312 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
4313 for(i=0;i<nDOF_test_element;i++)
4314 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4315 {
4316 residual[left_eN_global*nDOF_test_element+
4317 i]
4318 +=
4319 flux[ebN*nQuadraturePoints_elementBoundary+
4320 k]*
4321 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4322 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4323 k*nDOF_test_element+
4324 i];
4325 residual[right_eN_global*nDOF_test_element+
4326 i]
4327 -=
4328 flux[ebN*nQuadraturePoints_elementBoundary+
4329 k]*
4330 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4331 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4332 k*nDOF_test_element+
4333 i];
4334 }
4335 }
4336}
4337
4341void updateExteriorElementBoundaryFlux(int nExteriorElementBoundaries_global,
4342 int nElementBoundaries_element,
4343 int nQuadraturePoints_elementBoundary,
4344 int nDOF_test_element,
4345 int* exteriorElementBoundaries,
4346 int* elementBoundaryElements,
4347 int* elementBoundaryLocalElementBoundaries,
4348 double* flux,
4349 double* w_dS,
4350 double* residual)
4351{
4352 int ebNE,ebN,eN_global,ebN_element,i,k;
4353 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4354 {
4355 ebN = exteriorElementBoundaries[ebNE];
4356 eN_global = elementBoundaryElements[ebN*2+0];
4357 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4358 for(i=0;i<nDOF_test_element;i++)
4359 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4360 {
4361 residual[eN_global*nDOF_test_element+
4362 i]
4363 +=
4364 flux[ebN*nQuadraturePoints_elementBoundary+
4365 k]
4366 *
4367 w_dS[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4368 ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4369 k*nDOF_test_element+
4370 i];
4371 }
4372 }
4373}
4374
4375void updateGlobalExteriorElementBoundaryFlux(int nExteriorElementBoundaries_global,
4376 int nQuadraturePoints_elementBoundary,
4377 int nDOF_test_element,
4378 int* exteriorElementBoundaries,
4379 int* elementBoundaryElements,
4380 int* elementBoundaryLocalElementBoundaries,
4381 double* flux,
4382 double* w_dS,
4383 double* residual)
4384{
4385 int ebNE,ebN,eN_global,ebN_element,i,k;
4386 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4387 {
4388 ebN = exteriorElementBoundaries[ebNE];
4389 eN_global = elementBoundaryElements[ebN*2+0];
4390 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4391 for(i=0;i<nDOF_test_element;i++)
4392 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4393 {
4394 residual[eN_global*nDOF_test_element+
4395 i]
4396 +=
4397 flux[ebNE*nQuadraturePoints_elementBoundary+
4398 k]
4399 *
4400 w_dS[ebNE*nQuadraturePoints_elementBoundary*nDOF_test_element+
4401 k*nDOF_test_element+
4402 i];
4403 }
4404 }
4405}
4406void updateGlobalExteriorElementBoundaryStressFlux(int nExteriorElementBoundaries_global,
4407 int nQuadraturePoints_elementBoundary,
4408 int nDOF_test_element,
4409 int* exteriorElementBoundaries,
4410 int* elementBoundaryElements,
4411 int* elementBoundaryLocalElementBoundaries,
4412 double* stressFlux,
4413 double* w_dS,
4414 double* residual)
4415{
4416 int ebNE,ebN,eN_global,ebN_element,i,k,I;
4417 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4418 {
4419 ebN = exteriorElementBoundaries[ebNE];
4420 eN_global = elementBoundaryElements[ebN*2+0];
4421 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4422 for(i=0;i<nDOF_test_element;i++)
4423 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4424 residual[eN_global*nDOF_test_element+
4425 i]
4426 +=
4427 stressFlux[ebNE*nQuadraturePoints_elementBoundary+
4428 k]
4429 *
4430 w_dS[ebNE*nQuadraturePoints_elementBoundary*nDOF_test_element+
4431 k*nDOF_test_element+
4432 i];
4433 }
4434}
4435
4438void updateInteriorTwoSidedElementBoundaryFlux(int nInteriorElementBoundaries_global,
4439 int nElementBoundaries_element,
4440 int nQuadraturePoints_elementBoundary,
4441 int nDOF_test_element,
4442 int* interiorElementBoundaries,
4443 int* elementBoundaryElements,
4444 int* elementBoundaryLocalElementBoundaries,
4445 double* flux,
4446 double* w_dS,
4447 double* residual)
4448{
4449 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,i,k;
4450 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
4451 {
4452 ebN = interiorElementBoundaries[ebNI];
4453 left_eN_global = elementBoundaryElements[ebN*2+0];
4454 right_eN_global = elementBoundaryElements[ebN*2+1];
4455 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4456 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
4457 for(i=0;i<nDOF_test_element;i++)
4458 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4459 {
4460 residual[left_eN_global*nDOF_test_element+
4461 i]
4462 +=
4463 flux[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
4464 left_ebN_element*nQuadraturePoints_elementBoundary+ /*left flux*/
4465 k]*
4466 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4467 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4468 k*nDOF_test_element+
4469 i];
4470 residual[right_eN_global*nDOF_test_element+
4471 i]
4472 +=
4473 flux[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
4474 right_ebN_element*nQuadraturePoints_elementBoundary+ /*right flux*/
4475 k]*
4476 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4477 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4478 k*nDOF_test_element+
4479 i];
4480 }
4481 }
4482}
4483
4484void calculateExteriorElementBoundaryStress3D(int nExteriorElementBoundaries_global,
4485 int nQuadraturePoints_elementBoundary,
4486 int* elementBoundaryMaterialTypes,
4487 int* exteriorElementBoundaries,
4488 int* elementBoundaryElements,
4489 int* elementBoundaryLocalElementBoundaries,
4490 double* p,
4491 double* mom_flux_vec_u,
4492 double* mom_flux_vec_v,
4493 double* mom_flux_vec_w,
4494 double* dS,
4495 double* n,
4496 double* F)
4497{
4498 int ebNE,ebN,eN_global,ebN_element,k,I;
4499 double stress_x,stress_y,stress_z;
4500 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4501 {
4502 ebN = exteriorElementBoundaries[ebNE];
4503 eN_global = elementBoundaryElements[ebN*2+0];
4504 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4505 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4506 {
4507 stress_x = 0.0;
4508 stress_y = 0.0;
4509 stress_z = 0.0;
4510 stress_x += p[ebNE*nQuadraturePoints_elementBoundary+
4511 k]
4512 *
4513 n[ebNE*nQuadraturePoints_elementBoundary*3+
4514 k*3+
4515 0];
4516 stress_y += p[ebNE*nQuadraturePoints_elementBoundary+
4517 k]
4518 *
4519 n[ebNE*nQuadraturePoints_elementBoundary*3+
4520 k*3+
4521 1];
4522 stress_z += p[ebNE*nQuadraturePoints_elementBoundary+
4523 k]
4524 *
4525 n[ebNE*nQuadraturePoints_elementBoundary*3+
4526 k*3+
4527 2];
4528 for(I=0;I<3;I++)
4529 {
4530 stress_x += mom_flux_vec_u[ebNE*nQuadraturePoints_elementBoundary*3+
4531 k*3+
4532 I]
4533 *
4534 n[ebNE*nQuadraturePoints_elementBoundary*3+
4535 k*3+
4536 I];
4537 stress_y += mom_flux_vec_v[ebNE*nQuadraturePoints_elementBoundary*3+
4538 k*3+
4539 I]
4540 *
4541 n[ebNE*nQuadraturePoints_elementBoundary*3+
4542 k*3+
4543 I];
4544 stress_z += mom_flux_vec_w[ebNE*nQuadraturePoints_elementBoundary*3+
4545 k*3+
4546 I]
4547 *
4548 n[ebNE*nQuadraturePoints_elementBoundary*3+
4549 k*3+
4550 I];
4551 }
4552 F[elementBoundaryMaterialTypes[ebN]*3 + 0] += stress_x*
4553 dS[ebNE*nQuadraturePoints_elementBoundary+
4554 k];
4555 F[elementBoundaryMaterialTypes[ebN]*3 + 1] += stress_y*
4556 dS[ebNE*nQuadraturePoints_elementBoundary+
4557 k];
4558 F[elementBoundaryMaterialTypes[ebN]*3 + 2] += stress_z*
4559 dS[ebNE*nQuadraturePoints_elementBoundary+
4560 k];
4561 }
4562 }
4563}
4564
4565void calculateExteriorElementBoundaryStress2D(int nExteriorElementBoundaries_global,
4566 int nQuadraturePoints_elementBoundary,
4567 int* elementBoundaryMaterialTypes,
4568 int* exteriorElementBoundaries,
4569 int* elementBoundaryElements,
4570 int* elementBoundaryLocalElementBoundaries,
4571 double* p,
4572 double* mom_flux_vec_u,
4573 double* mom_flux_vec_v,
4574 double* dS,
4575 double* n,
4576 double* F)
4577{
4578 int ebNE,ebN,eN_global,ebN_element,k,I;
4579 double stress_x,stress_y;
4580 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4581 {
4582 ebN = exteriorElementBoundaries[ebNE];
4583 eN_global = elementBoundaryElements[ebN*2+0];
4584 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4585 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4586 {
4587 stress_x = 0.0;
4588 stress_y = 0.0;
4589 stress_x += p[ebNE*nQuadraturePoints_elementBoundary+
4590 k]
4591 *
4592 n[ebNE*nQuadraturePoints_elementBoundary*2+
4593 k*2+
4594 0];
4595 stress_y += p[ebNE*nQuadraturePoints_elementBoundary+
4596 k]
4597 *
4598 n[ebNE*nQuadraturePoints_elementBoundary*2+
4599 k*2+
4600 1];
4601 /* for(I=0;I<2;I++) */
4602 /* { */
4603 /* stress_x += mom_flux_vec_u[ebNE*nQuadraturePoints_elementBoundary*2+ */
4604 /* k*2+ */
4605 /* I] */
4606 /* * */
4607 /* n[ebNE*nQuadraturePoints_elementBoundary*2+ */
4608 /* k*2+ */
4609 /* I]; */
4610 /* stress_y += mom_flux_vec_v[ebNE*nQuadraturePoints_elementBoundary*2+ */
4611 /* k*2+ */
4612 /* I] */
4613 /* * */
4614 /* n[ebNE*nQuadraturePoints_elementBoundary*2+ */
4615 /* k*2+ */
4616 /* I]; */
4617 /* } */
4618 F[elementBoundaryMaterialTypes[ebN]*2 + 0] += stress_x*
4619 dS[ebNE*nQuadraturePoints_elementBoundary+
4620 k];
4621 F[elementBoundaryMaterialTypes[ebN]*2 + 1] += stress_y*
4622 dS[ebNE*nQuadraturePoints_elementBoundary+
4623 k];
4624 }
4625 }
4626}
4627
4632void accumulateExteriorElementPressureIntegrals(int nExteriorElementBoundaries_global,
4633 int nQuadraturePoints_elementBoundary,
4634 int* elementBoundaryMaterialTypes,
4635 int* exteriorElementBoundaries,
4636 double* p,
4637 double* dS,
4638 double* P,
4639 double* boundaryMeasure)
4640{
4641 int ebNE,ebN,k,elementBoundaryFlag;
4642 /*loop through exterior element boundaries*/
4643 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
4644 {
4645 /*get the global element boundary number for the current exterior element boundary*/
4646 ebN = exteriorElementBoundaries[ebNE];
4647 /*integer flag for this boundary*/
4648 elementBoundaryFlag = elementBoundaryMaterialTypes[ebN];
4649 /*loop through element boundary quadrature points and accumulate pressure and boundary area/length */
4650 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4651 {
4652 P[elementBoundaryFlag] += p[ebNE*nQuadraturePoints_elementBoundary+k]
4653 *
4654 dS[ebNE*nQuadraturePoints_elementBoundary+k];
4655 boundaryMeasure[elementBoundaryFlag] +=
4656 dS[ebNE*nQuadraturePoints_elementBoundary+k];
4657 }
4658 }
4659}
4660
4661
4665void updateGlobalResidualFromElementResidual(int nElements_global,
4666 int nDOF_test_element,
4667 int offset_r,
4668 int stride_r,
4669 int* nFreeDOF_element_r,
4670 int* freeLocal_r,
4671 int* freeGlobal_r,
4672 double* elementResidual,
4673 double* globalResidual)
4674{
4675 int eN,ii;
4676 for (eN=0;eN<nElements_global;eN++)
4677 for (ii=0;ii<nFreeDOF_element_r[eN];ii++)
4678 globalResidual[offset_r +
4679 stride_r*freeGlobal_r[eN*nDOF_test_element+
4680 ii]]
4681 +=
4682 elementResidual[eN*nDOF_test_element +
4683 freeLocal_r[eN*nDOF_test_element+
4684 ii]];
4685}
4686
4690void updateGlobalJacobianFromElementJacobian_dense(int nElements_global,
4691 int nDOF_test_element,
4692 int nDOF_trial_element,
4693 int offset_r,
4694 int stride_r,
4695 int offset_u,
4696 int stride_u,
4697 int nFreeVDOF_global,
4698 int* nFreeDOF_element_r,
4699 int* freeLocal_r,
4700 int* freeGlobal_r,
4701 int* nFreeDOF_element_u,
4702 int* freeLocal_u,
4703 int* freeGlobal_u,
4704 double* elementJacobian,
4705 double* globalJacobian)
4706{
4707 int eN,ii,jj,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,i,j,jacIndex,I,J;
4708 for (eN=0;eN<nElements_global;eN++)
4709 for (ii=0;ii<nFreeDOF_element_r[eN];ii++)
4710 {
4711 i = freeLocal_r[eN*nDOF_test_element+
4712 ii];
4713 I = offset_r + stride_r*freeGlobal_r[eN*nDOF_test_element+
4714 ii];
4715 for (jj=0;jj<nFreeDOF_element_u[eN];jj++)
4716 {
4717 j = freeLocal_u[eN*nDOF_trial_element+
4718 jj];
4719 J = offset_u + stride_u*freeGlobal_u[eN*nDOF_trial_element+
4720 jj];
4721 jacIndex = I + J*nFreeVDOF_global;
4722 globalJacobian[jacIndex]
4723 +=
4724 elementJacobian[eN*nDOF_test_X_trial_element +
4725 i*nDOF_trial_element+
4726 j];
4727 }
4728 }
4729}
4730
4734void updateGlobalJacobianFromElementJacobian_eb_dense(int* elementNeighbors,
4735 int nElements_global,
4736 int nElementBoundaries_element,
4737 int nDOF_test_element,
4738 int nDOF_trial_element,
4739 int offset_r,
4740 int stride_r,
4741 int offset_u,
4742 int stride_u,
4743 int nFreeVDOF_global,
4744 int* nFreeDOF_element_r,
4745 int* freeLocal_r,
4746 int* freeGlobal_r,
4747 int* nFreeDOF_element_u,
4748 int* freeLocal_u,
4749 int* freeGlobal_u,
4750 double* elementJacobian_eb,
4751 double* globalJacobian)
4752{
4753 int eN,ebN,eN_ebN,ii,jj,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,i,j,jacIndex,I,J;
4754 for (eN=0;eN<nElements_global;eN++)
4755 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
4756 {
4757/* /\*cek 1D debugging *\/ */
4758/* if(ebN == 0) */
4759/* eN_ebN = eN+1; */
4760/* if(ebN == 1) */
4761/* eN_ebN = eN-1; */
4762/* if(eN_ebN >= 0 && eN_ebN < nElements_global) */
4763 eN_ebN = elementNeighbors[eN*nElementBoundaries_element+ebN];
4764 if (eN_ebN >= 0)
4765 for (ii=0;ii<nFreeDOF_element_r[eN];ii++)
4766 {
4767 i = freeLocal_r[eN*nDOF_test_element+
4768 ii];
4769 I = offset_r + stride_r*freeGlobal_r[eN*nDOF_test_element+
4770 ii];
4771 for (jj=0;jj<nFreeDOF_element_u[eN_ebN];jj++)
4772 {
4773 j = freeLocal_u[eN_ebN*nDOF_trial_element+
4774 jj];
4775 J = offset_u + stride_u*freeGlobal_u[eN_ebN*nDOF_trial_element+
4776 jj];
4777 jacIndex = I + J*nFreeVDOF_global;
4778 globalJacobian[jacIndex]
4779 +=
4780 elementJacobian_eb[eN*nElementBoundaries_element*nDOF_test_X_trial_element +
4781 ebN*nDOF_test_X_trial_element+
4782 i*nDOF_trial_element+
4783 j];
4784 }
4785 }
4786 }
4787}
4788
4792void updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_dense(int nInteriorElementBoundaries_global,
4793 int nElementBoundaries_element,
4794 int nQuadraturePoints_elementBoundary,
4795 int nDOF_test_element,
4796 int nDOF_trial_element,
4797 int offset_r,
4798 int stride_r,
4799 int offset_u,
4800 int stride_u,
4801 int nFreeVDOF_global,
4802 int* interiorElementBoundaries,
4803 int* elementBoundaryElements,
4804 int* elementBoundaryLocalElementBoundaries,
4805 int* nFreeDOF_element_r,
4806 int* freeLocal_r,
4807 int* freeGlobal_r,
4808 int* nFreeDOF_element_u,
4809 int* freeLocal_u,
4810 int* freeGlobal_u,
4811 double* elementBoundaryFluxJacobian,
4812 double* w_dS,
4813 double* jac)
4814{
4815 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,ii,i,k,jj,j,jacIndex,I,J;
4816 for (ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
4817 {
4818 ebN = interiorElementBoundaries[ebNI];
4819 left_eN_global = elementBoundaryElements[ebN*2+0];
4820 right_eN_global = elementBoundaryElements[ebN*2+1];
4821 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4822 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
4823 for(ii=0;ii<nFreeDOF_element_r[left_eN_global];ii++)
4824 {
4825 i = freeLocal_r[left_eN_global*nDOF_test_element+
4826 ii];
4827 I = offset_r + stride_r*freeGlobal_r[left_eN_global*nDOF_test_element+
4828 ii];
4829 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4830 {
4831 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
4832 {
4833 j = freeLocal_u[left_eN_global*nDOF_trial_element+
4834 jj];
4835 J = offset_u + stride_u*freeGlobal_u[left_eN_global*nDOF_trial_element+
4836 jj];
4837 jacIndex = I+J*nFreeVDOF_global;
4838 jac[jacIndex]
4839 +=
4840 elementBoundaryFluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element +
4841 0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4842 k*nDOF_trial_element+
4843 j]
4844 *
4845 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
4846 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4847 k*nDOF_test_element+
4848 i];
4849 }
4850 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
4851 {
4852 j = freeLocal_u[right_eN_global*nDOF_trial_element+
4853 jj];
4854 J = offset_u + stride_u*freeGlobal_u[right_eN_global*nDOF_trial_element+
4855 jj];
4856 jacIndex = I+J*nFreeVDOF_global;
4857 jac[jacIndex]
4858 +=
4859 elementBoundaryFluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element +
4860 1*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4861 k*nDOF_trial_element+
4862 j]*
4863 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
4864 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4865 k*nDOF_test_element+i];
4866 }
4867 }
4868 }
4869 for(ii=0;ii<nFreeDOF_element_r[right_eN_global];ii++)
4870 {
4871 i = freeLocal_r[right_eN_global*nDOF_test_element+
4872 ii];
4873 I = offset_r + stride_r*freeGlobal_r[right_eN_global*nDOF_test_element+
4874 ii];
4875 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4876 {
4877 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
4878 {
4879 j = freeLocal_u[left_eN_global*nDOF_trial_element+
4880 jj];
4881 J = offset_u + stride_u*freeGlobal_u[left_eN_global*nDOF_trial_element+
4882 jj];
4883 jacIndex = I+J*nFreeVDOF_global;
4884 jac[jacIndex]
4885 -=
4886 elementBoundaryFluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4887 0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4888 k*nDOF_trial_element+
4889 j]
4890 *
4891 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4892 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4893 k*nDOF_test_element+
4894 i];
4895 }
4896 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
4897 {
4898 j = freeLocal_u[right_eN_global*nDOF_trial_element+
4899 jj];
4900 J = offset_u + stride_u*freeGlobal_u[right_eN_global*nDOF_trial_element+
4901 jj];
4902 jacIndex = I+J*nFreeVDOF_global;
4903 jac[jacIndex]
4904 -=
4905 elementBoundaryFluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4906 1*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4907 k*nDOF_trial_element+
4908 j]*
4909 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4910 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4911 k*nDOF_test_element+
4912 i];
4913 }
4914 }
4915 }
4916 }
4917}
4918
4922void updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_eb_dense(int* elementNeighbors,
4923 int nElements_global,
4924 int nInteriorElementBoundaries_global,
4925 int nElementBoundaries_element,
4926 int nQuadraturePoints_elementBoundary,
4927 int nDOF_test_element,
4928 int nDOF_trial_element,
4929 int offset_r,
4930 int stride_r,
4931 int offset_u,
4932 int stride_u,
4933 int nFreeVDOF_global,
4934 int* interiorElementBoundaries,
4935 int* elementBoundaryElements,
4936 int* elementBoundaryLocalElementBoundaries,
4937 int* nFreeDOF_element_r,
4938 int* freeLocal_r,
4939 int* freeGlobal_r,
4940 int* nFreeDOF_element_u,
4941 int* freeLocal_u,
4942 int* freeGlobal_u,
4943 double* elementBoundaryFluxJacobian_eb,
4944 double* w_dS,
4945 double* jac)
4946{
4947 int ebNI,ebN,ebN_element,left_eN_ebN,right_eN_ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,ii,i,k,jj,j,jacIndex,I,J;
4948 for (ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
4949 {
4950 ebN = interiorElementBoundaries[ebNI];
4951 left_eN_global = elementBoundaryElements[ebN*2+0];
4952 right_eN_global = elementBoundaryElements[ebN*2+1];
4953 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
4954 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
4955 for(ebN_element=0;ebN_element<nElementBoundaries_element;ebN_element++)
4956 {
4957/* /\* cek debugging 1D *\/ */
4958/* if(ebN_element == 0) */
4959/* left_eN_ebN = left_eN_global+1; */
4960/* if(ebN_element == 1) */
4961/* left_eN_ebN = left_eN_global-1; */
4962/* if(ebN_element == 0) */
4963/* right_eN_ebN = right_eN_global+1; */
4964/* if(ebN_element == 1) */
4965/* right_eN_ebN = right_eN_global-1; */
4966 left_eN_ebN = elementNeighbors[left_eN_global*nElementBoundaries_element+ebN_element];
4967 right_eN_ebN = elementNeighbors[right_eN_global*nElementBoundaries_element+ebN_element];
4968 for(ii=0;ii<nFreeDOF_element_r[left_eN_global];ii++)
4969 {
4970 i = freeLocal_r[left_eN_global*nDOF_test_element+
4971 ii];
4972 I = offset_r + stride_r*freeGlobal_r[left_eN_global*nDOF_test_element+
4973 ii];
4974 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
4975 {
4976/* if(left_eN_ebN >= 0 && left_eN_ebN < nElements_global) */
4977 if(left_eN_ebN >= 0)
4978 for(jj=0;jj<nFreeDOF_element_u[left_eN_ebN];jj++)
4979 {
4980 j = freeLocal_u[left_eN_ebN*nDOF_trial_element+
4981 jj];
4982 J = offset_u + stride_u*freeGlobal_u[left_eN_ebN*nDOF_trial_element+
4983 jj];
4984 jacIndex = I+J*nFreeVDOF_global;
4985 jac[jacIndex]
4986 +=
4987 elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element +
4988 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4989 ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
4990 k*nDOF_trial_element+
4991 j]
4992 *
4993 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
4994 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
4995 k*nDOF_test_element+
4996 i];
4997/* printf("ind=%i,ebN = %i,left_eN_global=%i,left_ebN_element=%i,ebN_element=%i,i=%i,j=%i,jac=%12.5e,fjac=%12.5e,w=%12.5e\n", */
4998/* jacIndex,ebN,left_eN_global,left_ebN_element,ebN_element,i,j,jac[jacIndex], */
4999/* elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element + */
5000/* 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5001/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5002/* k*nDOF_trial_element+ */
5003/* j], */
5004/* w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element + */
5005/* left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+ */
5006/* k*nDOF_test_element+ */
5007/* i]); */
5008 }
5009/* if(right_eN_ebN >= 0 && right_eN_ebN < nElements_global) */
5010 if(right_eN_ebN >= 0)
5011 for(jj=0;jj<nFreeDOF_element_u[right_eN_ebN];jj++)
5012 {
5013 j = freeLocal_u[right_eN_ebN*nDOF_trial_element+
5014 jj];
5015 J = offset_u + stride_u*freeGlobal_u[right_eN_ebN*nDOF_trial_element+
5016 jj];
5017 jacIndex = I+J*nFreeVDOF_global;
5018 jac[jacIndex]
5019 +=
5020 elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element +
5021 1*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5022 ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5023 k*nDOF_trial_element+
5024 j]*
5025 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
5026 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5027 k*nDOF_test_element+i];
5028/* printf("ind=%i,ebN = %i,left_eN_global=%i,left_ebN_element=%i,ebN_element=%i,i=%i,j=%i,jac=%12.5e,fjac=%12.5e,w=%12.5e\n", */
5029/* jacIndex,ebN,left_eN_global,left_ebN_element,ebN_element,i,j,jac[jacIndex], */
5030/* elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element + */
5031/* 1*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5032/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5033/* k*nDOF_trial_element+ */
5034/* j], */
5035/* w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element + */
5036/* left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+ */
5037/* k*nDOF_test_element+ */
5038/* i]); */
5039 }
5040 }
5041 }
5042 for(ii=0;ii<nFreeDOF_element_r[right_eN_global];ii++)
5043 {
5044 i = freeLocal_r[right_eN_global*nDOF_test_element+
5045 ii];
5046 I = offset_r + stride_r*freeGlobal_r[right_eN_global*nDOF_test_element+
5047 ii];
5048 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5049 {
5050/* if(left_eN_ebN >= 0 && left_eN_ebN < nElements_global) */
5051 if(left_eN_ebN >= 0)
5052 for(jj=0;jj<nFreeDOF_element_u[left_eN_ebN];jj++)
5053 {
5054 j = freeLocal_u[left_eN_ebN*nDOF_trial_element+
5055 jj];
5056 J = offset_u + stride_u*freeGlobal_u[left_eN_ebN*nDOF_trial_element+
5057 jj];
5058 jacIndex = I+J*nFreeVDOF_global;
5059 jac[jacIndex]
5060 -=
5061 elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5062 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5063 ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5064 k*nDOF_trial_element+
5065 j]
5066 *
5067 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5068 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5069 k*nDOF_test_element+
5070 i];
5071/* printf("ind=%i,ebN = %i,left_eN_global=%i,left_ebN_element=%i,ebN_element=%i,i=%i,j=%i,jac=%12.5e,fjac=%12.5e,w=%12.5e\n", */
5072/* jacIndex,ebN,right_eN_global,right_ebN_element,ebN_element,i,j,jac[jacIndex], */
5073/* elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element + */
5074/* 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5075/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5076/* k*nDOF_trial_element+ */
5077/* j], */
5078/* w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element + */
5079/* right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+ */
5080/* k*nDOF_test_element+ */
5081/* i]); */
5082 }
5083/* if(right_eN_ebN >= 0 && right_eN_ebN < nElements_global) */
5084 if(right_eN_ebN >= 0)
5085 for(jj=0;jj<nFreeDOF_element_u[right_eN_ebN];jj++)
5086 {
5087 j = freeLocal_u[right_eN_ebN*nDOF_trial_element+
5088 jj];
5089 J = offset_u + stride_u*freeGlobal_u[right_eN_ebN*nDOF_trial_element+
5090 jj];
5091 jacIndex = I+J*nFreeVDOF_global;
5092 jac[jacIndex]
5093 -=
5094 elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5095 1*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5096 ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5097 k*nDOF_trial_element+
5098 j]*
5099 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5100 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5101 k*nDOF_test_element+
5102 i];
5103/* printf("ind=%i,ebN = %i,left_eN_global=%i,left_ebN_element=%i,ebN_element=%i,i=%i,j=%i,jac=%12.5e,fjac=%12.5e,w=%12.5e\n", */
5104/* jacIndex,ebN,right_eN_global,right_ebN_element,ebN_element,i,j,jac[jacIndex], */
5105/* elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element + */
5106/* 1*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5107/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5108/* k*nDOF_trial_element+ */
5109/* j], */
5110/* w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element + */
5111/* right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+ */
5112/* k*nDOF_test_element+ */
5113/* i]); */
5114 }
5115 }
5116 }
5117 }
5118 }
5119}
5120
5123void updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_2sided_dense(int nInteriorElementBoundaries_global,
5124 int nElementBoundaries_element,
5125 int nQuadraturePoints_elementBoundary,
5126 int nDOF_test_element,
5127 int nDOF_trial_element,
5128 int offset_r,
5129 int stride_r,
5130 int offset_u,
5131 int stride_u,
5132 int nFreeVDOF_global,
5133 int* interiorElementBoundaries,
5134 int* elementBoundaryElements,
5135 int* elementBoundaryLocalElementBoundaries,
5136 int* nFreeDOF_element_r,
5137 int* freeLocal_r,
5138 int* freeGlobal_r,
5139 int* nFreeDOF_element_u,
5140 int* freeLocal_u,
5141 int* freeGlobal_u,
5142 double* elementBoundaryFluxJacobian_2sided,
5143 double* w_dS,
5144 double* jac)
5145{
5146 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,ii,i,k,jj,j,jacIndex,I,J;
5147 for (ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
5148 {
5149 ebN = interiorElementBoundaries[ebNI];
5150 left_eN_global = elementBoundaryElements[ebN*2+0];
5151 right_eN_global = elementBoundaryElements[ebN*2+1];
5152 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
5153 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
5154 /*left flux*/
5155 for(ii=0;ii<nFreeDOF_element_r[left_eN_global];ii++)
5156 {
5157 i = freeLocal_r[left_eN_global*nDOF_test_element+
5158 ii];
5159 I = offset_r + stride_r*freeGlobal_r[left_eN_global*nDOF_test_element+
5160 ii];
5161 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5162 {
5163 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
5164 {
5165 j = freeLocal_u[left_eN_global*nDOF_trial_element+
5166 jj];
5167 J = offset_u + stride_u*freeGlobal_u[left_eN_global*nDOF_trial_element+
5168 jj];
5169 jacIndex = I+J*nFreeVDOF_global;
5170 jac[jacIndex]
5171 +=
5172 elementBoundaryFluxJacobian_2sided[ebN*2*2*nQuadraturePoints_elementBoundary*nDOF_trial_element +
5173 0*2*nQuadraturePoints_elementBoundary*nDOF_trial_element + /*left flux*/
5174 0*nQuadraturePoints_elementBoundary*nDOF_trial_element+ /*left neig. dep*/
5175 k*nDOF_trial_element+
5176 j]
5177 *
5178 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
5179 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5180 k*nDOF_test_element+
5181 i];
5182 }
5183 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
5184 {
5185 j = freeLocal_u[right_eN_global*nDOF_trial_element+
5186 jj];
5187 J = offset_u + stride_u*freeGlobal_u[right_eN_global*nDOF_trial_element+
5188 jj];
5189 jacIndex = I+J*nFreeVDOF_global;
5190 jac[jacIndex]
5191 +=
5192 elementBoundaryFluxJacobian_2sided[ebN*2*2*nQuadraturePoints_elementBoundary*nDOF_trial_element +
5193 0*2*nQuadraturePoints_elementBoundary*nDOF_trial_element + /*left flux*/
5194 1*nQuadraturePoints_elementBoundary*nDOF_trial_element+ /*right neig. dep*/
5195 k*nDOF_trial_element+
5196 j]*
5197 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
5198 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5199 k*nDOF_test_element+i];
5200 }
5201 }/*k*/
5202 }/*ii*/
5203 /*right flux*/
5204 for(ii=0;ii<nFreeDOF_element_r[right_eN_global];ii++)
5205 {
5206 i = freeLocal_r[right_eN_global*nDOF_test_element+
5207 ii];
5208 I = offset_r + stride_r*freeGlobal_r[right_eN_global*nDOF_test_element+
5209 ii];
5210 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5211 {
5212 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
5213 {
5214 j = freeLocal_u[left_eN_global*nDOF_trial_element+
5215 jj];
5216 J = offset_u + stride_u*freeGlobal_u[left_eN_global*nDOF_trial_element+
5217 jj];
5218 jacIndex = I+J*nFreeVDOF_global;
5219 jac[jacIndex]
5220 +=
5221 elementBoundaryFluxJacobian_2sided[ebN*2*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5222 1*2*nQuadraturePoints_elementBoundary*nDOF_trial_element + /*right flux*/
5223 0*nQuadraturePoints_elementBoundary*nDOF_trial_element+ /*left neighbor*/
5224 k*nDOF_trial_element+
5225 j]
5226 *
5227 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5228 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5229 k*nDOF_test_element+
5230 i];
5231 }
5232 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
5233 {
5234 j = freeLocal_u[right_eN_global*nDOF_trial_element+
5235 jj];
5236 J = offset_u + stride_u*freeGlobal_u[right_eN_global*nDOF_trial_element+
5237 jj];
5238 jacIndex = I+J*nFreeVDOF_global;
5239 jac[jacIndex]
5240 +=
5241 elementBoundaryFluxJacobian_2sided[ebN*2*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5242 1*2*nQuadraturePoints_elementBoundary*nDOF_trial_element + /*right flux*/
5243 1*nQuadraturePoints_elementBoundary*nDOF_trial_element+ /*right neig dep*/
5244 k*nDOF_trial_element+
5245 j]*
5246 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5247 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5248 k*nDOF_test_element+
5249 i];
5250 }
5251 }
5252 }
5253 }
5254}
5255
5259void updateGlobalJacobianFromExteriorElementBoundaryFluxJacobian_dense(int nExteriorElementBoundaries_global,
5260 int nElementBoundaries_element,
5261 int nQuadraturePoints_elementBoundary,
5262 int nDOF_test_element,
5263 int nDOF_trial_element,
5264 int offset_r,
5265 int stride_r,
5266 int offset_u,
5267 int stride_u,
5268 int nFreeVDOF_global,
5269 int* exteriorElementBoundaries,
5270 int* elementBoundaryElements,
5271 int* elementBoundaryLocalElementBoundaries,
5272 int* nFreeDOF_element_r,
5273 int* freeLocal_r,
5274 int* freeGlobal_r,
5275 int* nFreeDOF_element_u,
5276 int* freeLocal_u,
5277 int* freeGlobal_u,
5278 double* elementBoundaryFluxJacobian,
5279 double* w_dS,
5280 double* jac)
5281{
5282 int ebNE,ebN,eN_global,ebN_element,ii,i,k,jj,j,I,J,jacIndex;
5283 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
5284 {
5285 ebN = exteriorElementBoundaries[ebNE];
5286 eN_global = elementBoundaryElements[ebN*2+0];
5287 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
5288 for(ii=0;ii<nFreeDOF_element_r[eN_global];ii++)
5289 {
5290 i = freeLocal_r[eN_global*nDOF_test_element+
5291 ii];
5292 I = offset_r + stride_r*freeGlobal_r[eN_global*nDOF_test_element+
5293 ii];
5294 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5295 {
5296 for(jj=0;jj<nFreeDOF_element_u[eN_global];jj++)
5297 {
5298 j = freeLocal_u[eN_global*nDOF_trial_element+
5299 jj];
5300 J = offset_u + stride_u*freeGlobal_u[eN_global*nDOF_trial_element+
5301 jj];
5302 jacIndex = I+J*nFreeVDOF_global;
5303 jac[jacIndex]
5304 +=
5305 elementBoundaryFluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element +
5306 0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5307 k*nDOF_trial_element+
5308 j]
5309 *
5310 w_dS[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
5311 ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5312 k*nDOF_test_element+
5313 i];
5314 }
5315 }
5316 }
5317 }
5318}
5319
5323void updateGlobalJacobianFromExteriorElementBoundaryFluxJacobian_eb_dense(int* elementNeighbors,
5324 int nElements_global,
5325 int nExteriorElementBoundaries_global,
5326 int nElementBoundaries_element,
5327 int nQuadraturePoints_elementBoundary,
5328 int nDOF_test_element,
5329 int nDOF_trial_element,
5330 int offset_r,
5331 int stride_r,
5332 int offset_u,
5333 int stride_u,
5334 int nFreeVDOF_global,
5335 int* exteriorElementBoundaries,
5336 int* elementBoundaryElements,
5337 int* elementBoundaryLocalElementBoundaries,
5338 int* nFreeDOF_element_r,
5339 int* freeLocal_r,
5340 int* freeGlobal_r,
5341 int* nFreeDOF_element_u,
5342 int* freeLocal_u,
5343 int* freeGlobal_u,
5344 double* elementBoundaryFluxJacobian_eb,
5345 double* w_dS,
5346 double* jac)
5347{
5348 int ebNE,ebN,eN_global,ebN_element,ebN_eN,eN_ebN,ii,i,k,jj,j,I,J,jacIndex;
5349 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
5350 {
5351 ebN = exteriorElementBoundaries[ebNE];
5352 eN_global = elementBoundaryElements[ebN*2+0];
5353 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
5354 for (ebN_eN=0;ebN_eN<nElementBoundaries_element;ebN_eN++)
5355 {
5356/* /\* cek debugging 1D *\/ */
5357/* if(ebN_eN == 0) */
5358/* eN_ebN = eN_global+1; */
5359/* if(ebN_eN == 1) */
5360/* eN_ebN = eN_global-1; */
5361 eN_ebN = elementNeighbors[eN_global*nElementBoundaries_element+ebN_eN];
5362 for(ii=0;ii<nFreeDOF_element_r[eN_global];ii++)
5363 {
5364 i = freeLocal_r[eN_global*nDOF_test_element+
5365 ii];
5366 I = offset_r + stride_r*freeGlobal_r[eN_global*nDOF_test_element+
5367 ii];
5368 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5369 {
5370/* if(eN_ebN >= 0 && eN_ebN < nElements_global) */
5371 if(eN_ebN >= 0)
5372 for(jj=0;jj<nFreeDOF_element_u[eN_ebN];jj++)
5373 {
5374 j = freeLocal_u[eN_ebN*nDOF_trial_element+
5375 jj];
5376 J = offset_u + stride_u*freeGlobal_u[eN_ebN*nDOF_trial_element+
5377 jj];
5378 jacIndex = I+J*nFreeVDOF_global;
5379 jac[jacIndex]
5380 +=
5381 elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element +
5382 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5383 ebN_eN*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5384 k*nDOF_trial_element+
5385 j]
5386 *
5387 w_dS[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
5388 ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5389 k*nDOF_test_element+
5390 i];
5391/* printf("ind=%i,ebN = %i,eN_global=%i,ebN_element=%i,ebN_element=%i,i=%i,j=%i,jac=%12.5e,fjac=%12.5e,w=%12.5e\n", */
5392/* jacIndex,ebN,eN_global,ebN_element,ebN_element,i,j,jac[jacIndex], */
5393/* elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element + */
5394/* 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5395/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5396/* k*nDOF_trial_element+ */
5397/* j], */
5398/* w_dS[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element + */
5399/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+ */
5400/* k*nDOF_test_element+ */
5401/* i]); */
5402 }
5403 }
5404 }
5405 }
5406 }
5407}
5408
5413void updateGlobalJacobianFromGlobalExteriorElementBoundaryFluxJacobian_eb_dense(int* elementNeighbors,
5414 int nElements_global,
5415 int nExteriorElementBoundaries_global,
5416 int nElementBoundaries_element,
5417 int nQuadraturePoints_elementBoundary,
5418 int nDOF_test_element,
5419 int nDOF_trial_element,
5420 int offset_r,
5421 int stride_r,
5422 int offset_u,
5423 int stride_u,
5424 int nFreeVDOF_global,
5425 int* exteriorElementBoundaries,
5426 int* elementBoundaryElements,
5427 int* elementBoundaryLocalElementBoundaries,
5428 int* nFreeDOF_element_r,
5429 int* freeLocal_r,
5430 int* freeGlobal_r,
5431 int* nFreeDOF_element_u,
5432 int* freeLocal_u,
5433 int* freeGlobal_u,
5434 double* elementBoundaryFluxJacobian_eb,
5435 double* w_dS,
5436 double* jac)
5437{
5438 int ebNE,ebN,eN_global,ebN_element,ebN_eN,eN_ebN,ii,i,k,jj,j,I,J,jacIndex;
5439 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
5440 {
5441 ebN = exteriorElementBoundaries[ebNE];
5442 eN_global = elementBoundaryElements[ebN*2+0];
5443 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
5444 for (ebN_eN=0;ebN_eN<nElementBoundaries_element;ebN_eN++)
5445 {
5446/* /\* cek debugging 1D *\/ */
5447/* if(ebN_eN == 0) */
5448/* eN_ebN = eN_global+1; */
5449/* if(ebN_eN == 1) */
5450/* eN_ebN = eN_global-1; */
5451 eN_ebN = elementNeighbors[eN_global*nElementBoundaries_element+ebN_eN];
5452 for(ii=0;ii<nFreeDOF_element_r[eN_global];ii++)
5453 {
5454 i = freeLocal_r[eN_global*nDOF_test_element+
5455 ii];
5456 I = offset_r + stride_r*freeGlobal_r[eN_global*nDOF_test_element+
5457 ii];
5458 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5459 {
5460/* if(eN_ebN >= 0 && eN_ebN < nElements_global) */
5461 if(eN_ebN >= 0)
5462 for(jj=0;jj<nFreeDOF_element_u[eN_ebN];jj++)
5463 {
5464 j = freeLocal_u[eN_ebN*nDOF_trial_element+
5465 jj];
5466 J = offset_u + stride_u*freeGlobal_u[eN_ebN*nDOF_trial_element+
5467 jj];
5468 jacIndex = I+J*nFreeVDOF_global;
5469 jac[jacIndex]
5470 +=
5471 elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element +
5472 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5473 ebN_eN*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5474 k*nDOF_trial_element+
5475 j]
5476 *
5477 w_dS[ebNE*nQuadraturePoints_elementBoundary*nDOF_test_element+
5478 k*nDOF_test_element+
5479 i];
5480/* printf("ind=%i,ebN = %i,eN_global=%i,ebN_element=%i,ebN_element=%i,i=%i,j=%i,jac=%12.5e,fjac=%12.5e,w=%12.5e\n", */
5481/* jacIndex,ebN,eN_global,ebN_element,ebN_element,i,j,jac[jacIndex], */
5482/* elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element + */
5483/* 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5484/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5485/* k*nDOF_trial_element+ */
5486/* j], */
5487/* w_dS[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element + */
5488/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+ */
5489/* k*nDOF_test_element+ */
5490/* i]); */
5491 }
5492 }
5493 }
5494 }
5495 }
5496}
5497
5500void updateGlobalJacobianFromGlobalExteriorElementBoundaryFluxJacobian_dense(int nExteriorElementBoundaries_global,
5501 int nQuadraturePoints_elementBoundary,
5502 int nDOF_test_element,
5503 int nDOF_trial_element,
5504 int offset_r,
5505 int stride_r,
5506 int offset_u,
5507 int stride_u,
5508 int nFreeVDOF_global,
5509 int* exteriorElementBoundaries,
5510 int* elementBoundaryElements,
5511 int* elementBoundaryLocalElementBoundaries,
5512 int* nFreeDOF_element_r,
5513 int* freeLocal_r,
5514 int* freeGlobal_r,
5515 int* nFreeDOF_element_u,
5516 int* freeLocal_u,
5517 int* freeGlobal_u,
5518 double* elementBoundaryFluxJacobian,
5519 double* w_dS,
5520 double* jac)
5521{
5522 int ebNE,ebN,eN_global,ebN_element,ii,i,k,jj,j,I,J,jacIndex;
5523 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
5524 {
5525 ebN = exteriorElementBoundaries[ebNE];
5526 eN_global = elementBoundaryElements[ebN*2+0];
5527 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
5528 for(ii=0;ii<nFreeDOF_element_r[eN_global];ii++)
5529 {
5530 i = freeLocal_r[eN_global*nDOF_test_element+
5531 ii];
5532 I = offset_r + stride_r*freeGlobal_r[eN_global*nDOF_test_element+
5533 ii];
5534 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5535 {
5536 for(jj=0;jj<nFreeDOF_element_u[eN_global];jj++)
5537 {
5538 j = freeLocal_u[eN_global*nDOF_trial_element+
5539 jj];
5540 J = offset_u + stride_u*freeGlobal_u[eN_global*nDOF_trial_element+
5541 jj];
5542 jacIndex = I+J*nFreeVDOF_global;
5543 jac[jacIndex]
5544 +=
5545 elementBoundaryFluxJacobian[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5546 k*nDOF_trial_element+
5547 j]
5548 *
5549 w_dS[ebNE*nQuadraturePoints_elementBoundary*nDOF_test_element+
5550 k*nDOF_test_element+
5551 i];
5552 }
5553 }
5554 }
5555 }
5556}
5557
5561void updateGlobalJacobianFromElementJacobian_CSR(int nElements_global,
5562 int nDOF_test_element,
5563 int nDOF_trial_element,
5564 int* nFreeDOF_element_r,
5565 int* freeLocal_r,
5566 int* nFreeDOF_element_u,
5567 int* freeLocal_u,
5568 int* csrRowIndeces_ru,
5569 int* csrColumnOffsets_ru,
5570 double* elementJacobian,
5571 double* globalJacobian)
5572{
5573 int eN,ii,jj,i,j,jacIndex,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
5574 for (eN=0;eN<nElements_global;eN++)
5575 for (ii=0;ii<nFreeDOF_element_r[eN];ii++)
5576 {
5577 i = freeLocal_r[eN*nDOF_test_element+
5578 ii];
5579 for (jj=0;jj<nFreeDOF_element_u[eN];jj++)
5580 {
5581 j = freeLocal_u[eN*nDOF_trial_element+
5582 jj];
5583 jacIndex = csrRowIndeces_ru[eN*nDOF_test_element+
5584 ii]
5585 +
5586 csrColumnOffsets_ru[eN*nDOF_test_X_trial_element+
5587 ii*nDOF_trial_element+
5588 jj];
5589 globalJacobian[jacIndex]
5590 +=
5591 elementJacobian[eN*nDOF_test_X_trial_element +
5592 i*nDOF_trial_element +
5593 j];
5594 }
5595 }
5596}
5597
5601void updateGlobalJacobianFromElementJacobian_eb_CSR(int* elementNeighbors,
5602 int nElements_global,
5603 int nElementBoundaries_element,
5604 int nDOF_test_element,
5605 int nDOF_trial_element,
5606 int* nFreeDOF_element_r,
5607 int* freeLocal_r,
5608 int* nFreeDOF_element_u,
5609 int* freeLocal_u,
5610 int* csrRowIndeces_ru,
5611 int* csrColumnOffsets_eb_ru,
5612 double* elementJacobian_eb,
5613 double* globalJacobian)
5614{
5615 int eN,ebN,eN_ebN,ii,jj,i,j,jacIndex,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
5616 for (eN=0;eN<nElements_global;eN++)
5617 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
5618 {
5619/* /\*cek 1D debugging *\/ */
5620/* /\** \todo cek Need to add mesh structure for getting element's corresponding to element boundaries and */
5621/* fix sparse matrix load of off element jacobian terms in the element Jacobians for LDG methods *\/ */
5622/* if(ebN == 0) */
5623/* eN_ebN = eN+1; */
5624/* if(ebN == 1) */
5625/* eN_ebN = eN-1; */
5626 eN_ebN = elementNeighbors[eN*nElementBoundaries_element+ebN];
5627 if (eN_ebN >= 0)
5628 for (ii=0;ii<nFreeDOF_element_r[eN];ii++)
5629 {
5630 i = freeLocal_r[eN*nDOF_test_element+
5631 ii];
5632 for (jj=0;jj<nFreeDOF_element_u[eN_ebN];jj++)
5633 {
5634 j = freeLocal_u[eN_ebN*nDOF_trial_element+
5635 jj];
5636 jacIndex = csrRowIndeces_ru[eN*nDOF_test_element+
5637 ii]
5638 +
5639 csrColumnOffsets_eb_ru[eN*nElementBoundaries_element*nDOF_test_X_trial_element+
5640 ebN*nDOF_test_X_trial_element+
5641 ii*nDOF_trial_element+
5642 jj];
5643 globalJacobian[jacIndex]
5644 +=
5645 elementJacobian_eb[eN*nElementBoundaries_element*nDOF_test_X_trial_element +
5646 ebN*nDOF_test_X_trial_element+
5647 i*nDOF_trial_element +
5648 j];
5649 }
5650 }
5651 }
5652}
5653
5657void updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_CSR(int nInteriorElementBoundaries_global,
5658 int nElementBoundaries_element,
5659 int nQuadraturePoints_elementBoundary,
5660 int nDOF_test_element,
5661 int nDOF_trial_element,
5662 int* interiorElementBoundaries,
5663 int* elementBoundaryElements,
5664 int* elementBoundaryLocalElementBoundaries,
5665 int* nFreeDOF_element_r,
5666 int* freeLocal_r,
5667 int* nFreeDOF_element_u,
5668 int* freeLocal_u,
5669 int* csrRowIndeces_ru,
5670 int* csrColumnOffsets_eb_ru,
5671 double* elementBoundaryFluxJacobian,
5672 double* w_dS,
5673 double* jac)
5674{
5675 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,ii,i,k,jj,j,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,jacIndex;
5676 for (ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
5677 {
5678 ebN = interiorElementBoundaries[ebNI];
5679 left_eN_global = elementBoundaryElements[ebN*2+0];
5680 right_eN_global = elementBoundaryElements[ebN*2+1];
5681 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
5682 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
5683 for(ii=0;ii<nFreeDOF_element_r[left_eN_global];ii++)
5684 {
5685 i = freeLocal_r[left_eN_global*nDOF_test_element+ii];
5686 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5687 {
5688 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
5689 {
5690 j = freeLocal_u[left_eN_global*nDOF_trial_element+
5691 jj];
5692 jacIndex = csrRowIndeces_ru[left_eN_global*nDOF_test_element+
5693 ii]
5694 +
5695 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element +
5696 0*2*nDOF_test_X_trial_element +
5697 0*nDOF_test_X_trial_element +
5698 ii*nDOF_trial_element +
5699 jj];
5700 jac[jacIndex]
5701 +=
5702 elementBoundaryFluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element +
5703 0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5704 k*nDOF_trial_element+
5705 j]
5706 *
5707 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
5708 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5709 k*nDOF_test_element+
5710 i];
5711 }
5712 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
5713 {
5714 j = freeLocal_u[right_eN_global*nDOF_trial_element+
5715 jj];
5716 jacIndex = csrRowIndeces_ru[left_eN_global*nDOF_test_element+
5717 ii]
5718 +
5719 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element+
5720 0*2*nDOF_test_X_trial_element+
5721 1*nDOF_test_X_trial_element+
5722 ii*nDOF_trial_element+
5723 jj];
5724 jac[jacIndex]
5725 +=
5726 elementBoundaryFluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element +
5727 1*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5728 k*nDOF_trial_element+
5729 j]
5730 *
5731 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
5732 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5733 k*nDOF_test_element+
5734 i];
5735 }
5736 }
5737 }
5738 for(ii=0;ii<nFreeDOF_element_r[right_eN_global];ii++)
5739 {
5740 i = freeLocal_r[right_eN_global*nDOF_test_element+
5741 ii];
5742 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5743 {
5744 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
5745 {
5746 j = freeLocal_u[left_eN_global*nDOF_trial_element+
5747 jj];
5748 jacIndex = csrRowIndeces_ru[right_eN_global*nDOF_test_element+
5749 ii]
5750 +
5751 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element+
5752 1*2*nDOF_test_X_trial_element+
5753 0*nDOF_test_X_trial_element+
5754 ii*nDOF_trial_element+
5755 jj];
5756 jac[jacIndex]
5757 -=
5758 elementBoundaryFluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5759 0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5760 k*nDOF_trial_element+
5761 j]
5762 *
5763 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5764 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5765 k*nDOF_test_element+
5766 i];
5767 }
5768 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
5769 {
5770 j = freeLocal_u[right_eN_global*nDOF_trial_element+
5771 jj];
5772 jacIndex = csrRowIndeces_ru[right_eN_global*nDOF_test_element+
5773 ii]
5774 +
5775 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element+
5776 1*2*nDOF_test_X_trial_element+
5777 1*nDOF_test_X_trial_element+
5778 ii*nDOF_trial_element+
5779 jj];
5780 jac[jacIndex]
5781 -=
5782 elementBoundaryFluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5783 1*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5784 k*nDOF_trial_element+
5785 j]*
5786 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5787 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5788 k*nDOF_test_element+
5789 i];
5790 }
5791 }
5792 }
5793 }
5794}
5795
5799void updateGlobalJacobianFromExteriorElementBoundaryFluxJacobian_CSR(int nExteriorElementBoundaries_global,
5800 int nElementBoundaries_element,
5801 int nQuadraturePoints_elementBoundary,
5802 int nDOF_test_element,
5803 int nDOF_trial_element,
5804 int* exteriorElementBoundaries,
5805 int* elementBoundaryElements,
5806 int* elementBoundaryLocalElementBoundaries,
5807 int* nFreeDOF_element_r,
5808 int* freeLocal_r,
5809 int* nFreeDOF_element_u,
5810 int* freeLocal_u,
5811 int* csrRowIndeces_ru,
5812 int* csrColumnOffsets_eb_ru,
5813 double* elementBoundaryFluxJacobian,
5814 double* w_dS,
5815 double* jac)
5816{
5817 int ebNE,ebN,eN_global,ebN_element,ii,i,k,jj,j,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,jacIndex;
5818 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
5819 {
5820 ebN = exteriorElementBoundaries[ebNE];
5821 eN_global = elementBoundaryElements[ebN*2+0];
5822 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
5823 for(ii=0;ii<nFreeDOF_element_r[eN_global];ii++)
5824 {
5825 i = freeLocal_r[eN_global*nDOF_test_element+ii];
5826 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5827 {
5828 for(jj=0;jj<nFreeDOF_element_u[eN_global];jj++)
5829 {
5830 j = freeLocal_u[eN_global*nDOF_trial_element+
5831 jj];
5832 jacIndex = csrRowIndeces_ru[eN_global*nDOF_test_element+
5833 ii]
5834 +
5835 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element +
5836 0*2*nDOF_test_X_trial_element +
5837 0*nDOF_test_X_trial_element +
5838 ii*nDOF_trial_element +
5839 jj];
5840 jac[jacIndex]
5841 +=
5842 elementBoundaryFluxJacobian[ebN*2*nQuadraturePoints_elementBoundary*nDOF_trial_element +
5843 0*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5844 k*nDOF_trial_element+
5845 j]
5846 *
5847 w_dS[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
5848 ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5849 k*nDOF_test_element+
5850 i];
5851 }
5852 }
5853 }
5854 }
5855}
5856
5859void updateGlobalJacobianFromGlobalExteriorElementBoundaryFluxJacobian_CSR(int nExteriorElementBoundaries_global,
5860 int nQuadraturePoints_elementBoundary,
5861 int nDOF_test_element,
5862 int nDOF_trial_element,
5863 int* exteriorElementBoundaries,
5864 int* elementBoundaryElements,
5865 int* elementBoundaryLocalElementBoundaries,
5866 int* nFreeDOF_element_r,
5867 int* freeLocal_r,
5868 int* nFreeDOF_element_u,
5869 int* freeLocal_u,
5870 int* csrRowIndeces_ru,
5871 int* csrColumnOffsets_eb_ru,
5872 double* elementBoundaryFluxJacobian,
5873 double* w_dS,
5874 double* jac)
5875{
5876 int ebNE,ebN,eN_global,ii,i,k,jj,j,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,jacIndex;
5877 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
5878 {
5879 ebN = exteriorElementBoundaries[ebNE];
5880 eN_global = elementBoundaryElements[ebN*2+0];
5881 for(ii=0;ii<nFreeDOF_element_r[eN_global];ii++)
5882 {
5883 i = freeLocal_r[eN_global*nDOF_test_element+ii];
5884 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5885 {
5886 for(jj=0;jj<nFreeDOF_element_u[eN_global];jj++)
5887 {
5888 j = freeLocal_u[eN_global*nDOF_trial_element+
5889 jj];
5890 jacIndex = csrRowIndeces_ru[eN_global*nDOF_test_element+
5891 ii]
5892 +
5893 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element +
5894 0*2*nDOF_test_X_trial_element +
5895 0*nDOF_test_X_trial_element +
5896 ii*nDOF_trial_element +
5897 jj];
5898 jac[jacIndex]
5899 +=
5900 elementBoundaryFluxJacobian[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5901 k*nDOF_trial_element+
5902 j]
5903 *
5904 w_dS[ebNE*nQuadraturePoints_elementBoundary*nDOF_test_element+
5905 k*nDOF_test_element+
5906 i];
5907 }
5908 }
5909 }
5910 }
5911}
5912
5916void updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_eb_CSR(int* elementNeighbors,
5917 int nInteriorElementBoundaries_global,
5918 int nElementBoundaries_element,
5919 int nQuadraturePoints_elementBoundary,
5920 int nDOF_test_element,
5921 int nDOF_trial_element,
5922 int* interiorElementBoundaries,
5923 int* elementBoundaryElements,
5924 int* elementBoundaryLocalElementBoundaries,
5925 int* nFreeDOF_element_r,
5926 int* freeLocal_r,
5927 int* nFreeDOF_element_u,
5928 int* freeLocal_u,
5929 int* csrRowIndeces_ru,
5930 int* csrColumnOffsets_eb_eNebN_ru,
5931 double* elementBoundaryFluxJacobian_eb,
5932 double* w_dS,
5933 double* jac)
5934{
5935 int ebNI,ebN,ebN_element,left_eN_ebN,right_eN_ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,ii,i,k,jj,j,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,jacIndex;
5936 for (ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
5937 {
5938 ebN = interiorElementBoundaries[ebNI];
5939 left_eN_global = elementBoundaryElements[ebN*2+0];
5940 right_eN_global = elementBoundaryElements[ebN*2+1];
5941 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
5942 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
5943 for(ebN_element=0;ebN_element<nElementBoundaries_element;ebN_element++)
5944 {
5945 left_eN_ebN = elementNeighbors[left_eN_global*nElementBoundaries_element+ebN_element];
5946 right_eN_ebN = elementNeighbors[right_eN_global*nElementBoundaries_element+ebN_element];
5947 for(ii=0;ii<nFreeDOF_element_r[left_eN_global];ii++)
5948 {
5949 i = freeLocal_r[left_eN_global*nDOF_test_element+ii];
5950 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
5951 {
5952 if(left_eN_ebN >= 0)
5953 for(jj=0;jj<nFreeDOF_element_u[left_eN_ebN];jj++)
5954 {
5955 j = freeLocal_u[left_eN_ebN*nDOF_trial_element+
5956 jj];
5957 jacIndex = csrRowIndeces_ru[left_eN_global*nDOF_test_element+
5958 ii]
5959 +
5960 csrColumnOffsets_eb_eNebN_ru[ebN*4*nElementBoundaries_element*nDOF_test_X_trial_element +
5961 0*2*nElementBoundaries_element*nDOF_test_X_trial_element +
5962 0*nElementBoundaries_element*nDOF_test_X_trial_element +
5963 ebN_element*nDOF_test_X_trial_element+
5964 ii*nDOF_trial_element +
5965 jj];
5966 jac[jacIndex]
5967 +=
5968 elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element +
5969 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5970 ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
5971 k*nDOF_trial_element+
5972 j]
5973 *
5974 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
5975 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
5976 k*nDOF_test_element+
5977 i];
5978/* printf("ind=%i,ebN = %i,left_eN_global=%i,left_ebN_element=%i,ebN_element=%i,i=%i,j=%i,jac=%12.5e,fjac=%12.5e,w=%12.5e\n", */
5979/* jacIndex,ebN,left_eN_global,left_ebN_element,ebN_element,i,j,jac[jacIndex], */
5980/* elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element + */
5981/* 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5982/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
5983/* k*nDOF_trial_element+ */
5984/* j], */
5985/* w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element + */
5986/* left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+ */
5987/* k*nDOF_test_element+ */
5988/* i]); */
5989 }
5990 if(right_eN_ebN >= 0)
5991 for(jj=0;jj<nFreeDOF_element_u[right_eN_ebN];jj++)
5992 {
5993 j = freeLocal_u[right_eN_ebN*nDOF_trial_element+
5994 jj];
5995 jacIndex = csrRowIndeces_ru[left_eN_global*nDOF_test_element+
5996 ii]
5997 +
5998 csrColumnOffsets_eb_eNebN_ru[ebN*4*nElementBoundaries_element*nDOF_test_X_trial_element+
5999 0*2*nElementBoundaries_element*nDOF_test_X_trial_element+
6000 1*nElementBoundaries_element*nDOF_test_X_trial_element+
6001 ebN_element*nDOF_test_X_trial_element+
6002 ii*nDOF_trial_element+
6003 jj];
6004 jac[jacIndex]
6005 +=
6006 elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element +
6007 1*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6008 ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6009 k*nDOF_trial_element+
6010 j]
6011 *
6012 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
6013 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
6014 k*nDOF_test_element+
6015 i];
6016/* printf("ind=%i,ebN = %i,left_eN_global=%i,left_ebN_element=%i,ebN_element=%i,i=%i,j=%i,jac=%12.5e,fjac=%12.5e,w=%12.5e\n", */
6017/* jacIndex,ebN,left_eN_global,left_ebN_element,ebN_element,i,j,jac[jacIndex], */
6018/* elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element + */
6019/* 1*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
6020/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
6021/* k*nDOF_trial_element+ */
6022/* j], */
6023/* w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element + */
6024/* left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+ */
6025/* k*nDOF_test_element+ */
6026/* i]); */
6027 }
6028 }
6029 }
6030 for(ii=0;ii<nFreeDOF_element_r[right_eN_global];ii++)
6031 {
6032 i = freeLocal_r[right_eN_global*nDOF_test_element+
6033 ii];
6034 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
6035 {
6036 if(left_eN_ebN >= 0)
6037 for(jj=0;jj<nFreeDOF_element_u[left_eN_ebN];jj++)
6038 {
6039 j = freeLocal_u[left_eN_ebN*nDOF_trial_element+
6040 jj];
6041 jacIndex = csrRowIndeces_ru[right_eN_global*nDOF_test_element+
6042 ii]
6043 +
6044 csrColumnOffsets_eb_eNebN_ru[ebN*4*nElementBoundaries_element*nDOF_test_X_trial_element+
6045 1*2*nElementBoundaries_element*nDOF_test_X_trial_element+
6046 0*nElementBoundaries_element*nDOF_test_X_trial_element+
6047 ebN_element*nDOF_test_X_trial_element+
6048 ii*nDOF_trial_element+
6049 jj];
6050 jac[jacIndex]
6051 -=
6052 elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6053 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6054 ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6055 k*nDOF_trial_element+
6056 j]
6057 *
6058 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
6059 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
6060 k*nDOF_test_element+
6061 i];
6062/* printf("ind=%i,ebN = %i,left_eN_global=%i,left_ebN_element=%i,ebN_element=%i,i=%i,j=%i,jac=%12.5e,fjac=%12.5e,w=%12.5e\n", */
6063/* jacIndex,ebN,right_eN_global,right_ebN_element,ebN_element,i,j,jac[jacIndex], */
6064/* elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element + */
6065/* 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
6066/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
6067/* k*nDOF_trial_element+ */
6068/* j], */
6069/* w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element + */
6070/* right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+ */
6071/* k*nDOF_test_element+ */
6072/* i]); */
6073 }
6074 if(right_eN_ebN >= 0)
6075 for(jj=0;jj<nFreeDOF_element_u[right_eN_ebN];jj++)
6076 {
6077 j = freeLocal_u[right_eN_ebN*nDOF_trial_element+
6078 jj];
6079 jacIndex = csrRowIndeces_ru[right_eN_global*nDOF_test_element+
6080 ii]
6081 +
6082 csrColumnOffsets_eb_eNebN_ru[ebN*4*nElementBoundaries_element*nDOF_test_X_trial_element+
6083 1*2*nElementBoundaries_element*nDOF_test_X_trial_element+
6084 1*nElementBoundaries_element*nDOF_test_X_trial_element+
6085 ebN_element*nDOF_test_X_trial_element+
6086 ii*nDOF_trial_element+
6087 jj];
6088 jac[jacIndex]
6089 -=
6090 elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6091 1*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6092 ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6093 k*nDOF_trial_element+
6094 j]*
6095 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
6096 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
6097 k*nDOF_test_element+
6098 i];
6099/* printf("ind=%i,ebN = %i,left_eN_global=%i,left_ebN_element=%i,ebN_element=%i,i=%i,j=%i,jac=%12.5e,fjac=%12.5e,w=%12.5e\n", */
6100/* jacIndex,ebN,right_eN_global,right_ebN_element,ebN_element,i,j,jac[jacIndex], */
6101/* elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element + */
6102/* 1*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
6103/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
6104/* k*nDOF_trial_element+ */
6105/* j], */
6106/* w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element + */
6107/* right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+ */
6108/* k*nDOF_test_element+ */
6109/* i]); */
6110 }
6111 }
6112 }
6113 }
6114 }
6115}
6116
6120void updateGlobalJacobianFromExteriorElementBoundaryFluxJacobian_eb_CSR(int* elementNeighbors,
6121 int nExteriorElementBoundaries_global,
6122 int nElementBoundaries_element,
6123 int nQuadraturePoints_elementBoundary,
6124 int nDOF_test_element,
6125 int nDOF_trial_element,
6126 int* exteriorElementBoundaries,
6127 int* elementBoundaryElements,
6128 int* elementBoundaryLocalElementBoundaries,
6129 int* nFreeDOF_element_r,
6130 int* freeLocal_r,
6131 int* nFreeDOF_element_u,
6132 int* freeLocal_u,
6133 int* csrRowIndeces_ru,
6134 int* csrColumnOffsets_eb_eNebN_ru,
6135 double* elementBoundaryFluxJacobian_eb,
6136 double* w_dS,
6137 double* jac)
6138{
6139 int ebNE,ebN,ebN_eN,eN_ebN,eN_global,ebN_element,ii,i,k,jj,j,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,jacIndex;
6140 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
6141 {
6142 ebN = exteriorElementBoundaries[ebNE];
6143 eN_global = elementBoundaryElements[ebN*2+0];
6144 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
6145 for(ebN_eN=0;ebN_eN<nElementBoundaries_element;ebN_eN++)
6146 {
6147 eN_ebN = elementNeighbors[eN_global*nElementBoundaries_element+ebN_eN];
6148 for(ii=0;ii<nFreeDOF_element_r[eN_global];ii++)
6149 {
6150 i = freeLocal_r[eN_global*nDOF_test_element+ii];
6151 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
6152 {
6153 if(eN_ebN >= 0)
6154 for(jj=0;jj<nFreeDOF_element_u[eN_ebN];jj++)
6155 {
6156 j = freeLocal_u[eN_ebN*nDOF_trial_element+
6157 jj];
6158 jacIndex = csrRowIndeces_ru[eN_global*nDOF_test_element+
6159 ii]
6160 +
6161 csrColumnOffsets_eb_eNebN_ru[ebN*4*nElementBoundaries_element*nDOF_test_X_trial_element +
6162 0*2*nElementBoundaries_element*nDOF_test_X_trial_element +
6163 0*nElementBoundaries_element*nDOF_test_X_trial_element +
6164 ebN_eN*nDOF_test_X_trial_element +
6165 ii*nDOF_trial_element +
6166 jj];
6167 jac[jacIndex]
6168 +=
6169 elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element +
6170 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6171 ebN_eN*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6172 k*nDOF_trial_element+
6173 j]
6174 *
6175 w_dS[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
6176 ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
6177 k*nDOF_test_element+
6178 i];
6179/* printf("ind=%i,ebN = %i,eN_global=%i,ebN_element=%i,ebN_element=%i,i=%i,j=%i,jac=%12.5e,fjac=%12.5e,w=%12.5e\n", */
6180/* jacIndex,ebN,eN_global,ebN_element,ebN_element,i,j,jac[jacIndex], */
6181/* elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element + */
6182/* 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
6183/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
6184/* k*nDOF_trial_element+ */
6185/* j], */
6186/* w_dS[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element + */
6187/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+ */
6188/* k*nDOF_test_element+ */
6189/* i]); */
6190 }
6191 }
6192 }
6193 }
6194 }
6195}
6196
6201void updateGlobalJacobianFromGlobalExteriorElementBoundaryFluxJacobian_eb_CSR(int* elementNeighbors,
6202 int nExteriorElementBoundaries_global,
6203 int nElementBoundaries_element,
6204 int nQuadraturePoints_elementBoundary,
6205 int nDOF_test_element,
6206 int nDOF_trial_element,
6207 int* exteriorElementBoundaries,
6208 int* elementBoundaryElements,
6209 int* elementBoundaryLocalElementBoundaries,
6210 int* nFreeDOF_element_r,
6211 int* freeLocal_r,
6212 int* nFreeDOF_element_u,
6213 int* freeLocal_u,
6214 int* csrRowIndeces_ru,
6215 int* csrColumnOffsets_eb_eNebN_ru,
6216 double* elementBoundaryFluxJacobian_eb,
6217 double* w_dS,
6218 double* jac)
6219{
6220 int ebNE,ebN,ebN_eN,eN_ebN,eN_global,ebN_element,ii,i,k,jj,j,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,jacIndex;
6221 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
6222 {
6223 ebN = exteriorElementBoundaries[ebNE];
6224 eN_global = elementBoundaryElements[ebN*2+0];
6225 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
6226 for(ebN_eN=0;ebN_eN<nElementBoundaries_element;ebN_eN++)
6227 {
6228 eN_ebN = elementNeighbors[eN_global*nElementBoundaries_element+ebN_eN];
6229 for(ii=0;ii<nFreeDOF_element_r[eN_global];ii++)
6230 {
6231 i = freeLocal_r[eN_global*nDOF_test_element+ii];
6232 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
6233 {
6234 if(eN_ebN >= 0)
6235 for(jj=0;jj<nFreeDOF_element_u[eN_ebN];jj++)
6236 {
6237 j = freeLocal_u[eN_ebN*nDOF_trial_element+
6238 jj];
6239 jacIndex = csrRowIndeces_ru[eN_global*nDOF_test_element+
6240 ii]
6241 +
6242 csrColumnOffsets_eb_eNebN_ru[ebN*4*nElementBoundaries_element*nDOF_test_X_trial_element +
6243 0*2*nElementBoundaries_element*nDOF_test_X_trial_element +
6244 0*nElementBoundaries_element*nDOF_test_X_trial_element +
6245 ebN_eN*nDOF_test_X_trial_element +
6246 ii*nDOF_trial_element +
6247 jj];
6248 jac[jacIndex]
6249 +=
6250 elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element +
6251 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6252 ebN_eN*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6253 k*nDOF_trial_element+
6254 j]
6255 *
6256 w_dS[ebNE*nQuadraturePoints_elementBoundary*nDOF_test_element+
6257 k*nDOF_test_element+
6258 i];
6259/* printf("ind=%i,ebN = %i,eN_global=%i,ebN_element=%i,ebN_element=%i,i=%i,j=%i,jac=%12.5e,fjac=%12.5e,w=%12.5e\n", */
6260/* jacIndex,ebN,eN_global,ebN_element,ebN_element,i,j,jac[jacIndex], */
6261/* elementBoundaryFluxJacobian_eb[ebN*2*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element + */
6262/* 0*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
6263/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+ */
6264/* k*nDOF_trial_element+ */
6265/* j], */
6266/* w_dS[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element + */
6267/* ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+ */
6268/* k*nDOF_test_element+ */
6269/* i]); */
6270 }
6271 }
6272 }
6273 }
6274 }
6275}
6276
6279void updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_2sided_CSR(int nInteriorElementBoundaries_global,
6280 int nElementBoundaries_element,
6281 int nQuadraturePoints_elementBoundary,
6282 int nDOF_test_element,
6283 int nDOF_trial_element,
6284 int* interiorElementBoundaries,
6285 int* elementBoundaryElements,
6286 int* elementBoundaryLocalElementBoundaries,
6287 int* nFreeDOF_element_r,
6288 int* freeLocal_r,
6289 int* nFreeDOF_element_u,
6290 int* freeLocal_u,
6291 int* csrRowIndeces_ru,
6292 int* csrColumnOffsets_eb_ru,
6293 double* elementBoundaryFluxJacobian_2sided,
6294 double* w_dS,
6295 double* jac)
6296{
6297 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,ii,i,k,jj,j,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,jacIndex;
6298 for (ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
6299 {
6300 ebN = interiorElementBoundaries[ebNI];
6301 left_eN_global = elementBoundaryElements[ebN*2+0];
6302 right_eN_global = elementBoundaryElements[ebN*2+1];
6303 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
6304 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
6305 /*left flux*/
6306 for(ii=0;ii<nFreeDOF_element_r[left_eN_global];ii++)
6307 {
6308 i = freeLocal_r[left_eN_global*nDOF_test_element+ii];
6309 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
6310 {
6311 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
6312 {
6313 j = freeLocal_u[left_eN_global*nDOF_trial_element+
6314 jj];
6315 jacIndex = csrRowIndeces_ru[left_eN_global*nDOF_test_element+
6316 ii]
6317 +
6318 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element +
6319 0*2*nDOF_test_X_trial_element +
6320 0*nDOF_test_X_trial_element +
6321 ii*nDOF_trial_element +
6322 jj];
6323 jac[jacIndex]
6324 +=
6325 elementBoundaryFluxJacobian_2sided[ebN*2*2*nQuadraturePoints_elementBoundary*nDOF_trial_element +
6326 0*2*nQuadraturePoints_elementBoundary*nDOF_trial_element + /*left flux*/
6327 0*nQuadraturePoints_elementBoundary*nDOF_trial_element+ /*left neig dep*/
6328 k*nDOF_trial_element+
6329 j]
6330 *
6331 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
6332 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
6333 k*nDOF_test_element+
6334 i];
6335 }
6336 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
6337 {
6338 j = freeLocal_u[right_eN_global*nDOF_trial_element+
6339 jj];
6340 jacIndex = csrRowIndeces_ru[left_eN_global*nDOF_test_element+
6341 ii]
6342 +
6343 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element+
6344 0*2*nDOF_test_X_trial_element+
6345 1*nDOF_test_X_trial_element+
6346 ii*nDOF_trial_element+
6347 jj];
6348 jac[jacIndex]
6349 +=
6350 elementBoundaryFluxJacobian_2sided[ebN*2*2*nQuadraturePoints_elementBoundary*nDOF_trial_element +
6351 0*2*nQuadraturePoints_elementBoundary*nDOF_trial_element + /*left flux*/
6352 1*nQuadraturePoints_elementBoundary*nDOF_trial_element+ /*right neig dep*/
6353 k*nDOF_trial_element+
6354 j]
6355 *
6356 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element +
6357 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
6358 k*nDOF_test_element+
6359 i];
6360 }
6361 }
6362 }
6363 /*right flux*/
6364 for(ii=0;ii<nFreeDOF_element_r[right_eN_global];ii++)
6365 {
6366 i = freeLocal_r[right_eN_global*nDOF_test_element+
6367 ii];
6368 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
6369 {
6370 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
6371 {
6372 j = freeLocal_u[left_eN_global*nDOF_trial_element+
6373 jj];
6374 jacIndex = csrRowIndeces_ru[right_eN_global*nDOF_test_element+
6375 ii]
6376 +
6377 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element+
6378 1*2*nDOF_test_X_trial_element+
6379 0*nDOF_test_X_trial_element+
6380 ii*nDOF_trial_element+
6381 jj];
6382 jac[jacIndex]
6383 +=
6384 elementBoundaryFluxJacobian_2sided[ebN*2*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6385 1*2*nQuadraturePoints_elementBoundary*nDOF_trial_element + /*right flux*/
6386 0*nQuadraturePoints_elementBoundary*nDOF_trial_element+ /*left neig dep*/
6387 k*nDOF_trial_element+
6388 j]
6389 *
6390 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
6391 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
6392 k*nDOF_test_element+
6393 i];
6394 }
6395 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
6396 {
6397 j = freeLocal_u[right_eN_global*nDOF_trial_element+
6398 jj];
6399 jacIndex = csrRowIndeces_ru[right_eN_global*nDOF_test_element+
6400 ii]
6401 +
6402 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element+
6403 1*2*nDOF_test_X_trial_element+
6404 1*nDOF_test_X_trial_element+
6405 ii*nDOF_trial_element+
6406 jj];
6407 jac[jacIndex]
6408 +=
6409 elementBoundaryFluxJacobian_2sided[ebN*2*2*nQuadraturePoints_elementBoundary*nDOF_trial_element+
6410 1*2*nQuadraturePoints_elementBoundary*nDOF_trial_element + /*right flux*/
6411 1*nQuadraturePoints_elementBoundary*nDOF_trial_element+ /*right neig dep*/
6412 k*nDOF_trial_element+
6413 j]*
6414 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
6415 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
6416 k*nDOF_test_element+
6417 i];
6418 }
6419 }
6420 }
6421 }
6422}
6423
6427void calculateWeightedShape(int nElements_global,
6428 int nQuadraturePoints_element,
6429 int nDOF_test_element,
6430 double* dVR,
6431 double* abs_det_jac,
6432 double* w,
6433 double* w_dV)
6434{
6435 int eN,i,k;
6436 for (eN=0;eN<nElements_global;eN++)
6437 for (k=0;k<nQuadraturePoints_element;k++)
6438 for (i=0;i<nDOF_test_element;i++)
6439 w_dV[eN*nQuadraturePoints_element*nDOF_test_element+
6440 k*nDOF_test_element+
6441 i]
6442 =
6443 w[eN*nQuadraturePoints_element*nDOF_test_element+
6444 k*nDOF_test_element+
6445 i]
6446 *
6447 dVR[k]
6448 *
6449 abs_det_jac[eN*nQuadraturePoints_element+
6450 k];
6451}
6452
6456void calculateWeightedShapeGradients(int nElements_global,
6457 int nQuadraturePoints_element,
6458 int nDOF_test_element,
6459 int nSpace,
6460 double* dVR,
6461 double* abs_det_jac,
6462 double* grad_w,
6463 double* grad_w_dV)
6464{
6465 int eN,i,k,I;
6466 for (eN=0;eN<nElements_global;eN++)
6467 for (k=0;k<nQuadraturePoints_element;k++)
6468 for (i=0;i<nDOF_test_element;i++)
6469 for (I=0;I<nSpace;I++)
6470 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace+
6471 k*nDOF_test_element*nSpace+
6472 i*nSpace+
6473 I]
6474 =
6475 grad_w[eN*nQuadraturePoints_element*nDOF_test_element*nSpace+
6476 k*nDOF_test_element*nSpace+
6477 i*nSpace+
6478 I]
6479 *
6480 dVR[k]
6481 *
6482 abs_det_jac[eN*nQuadraturePoints_element+
6483 k];
6484}
6485
6487void calculateWeightedPiolaShapeGradients(int nElements_global,
6488 int nQuadraturePoints_element,
6489 int nDOF_test_element,
6490 int nSpace,
6491 double* dVR,
6492 double* abs_det_jac,
6493 double* grad_w,
6494 double* grad_w_dV)
6495{
6496 int eN,i,k,I;
6497 for (eN=0;eN<nElements_global;eN++)
6498 for (k=0;k<nQuadraturePoints_element;k++)
6499 for (i=0;i<nDOF_test_element;i++)
6500 for (I=0;I<nSpace;I++)
6501 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace+
6502 k*nDOF_test_element*nSpace+
6503 i*nSpace+
6504 I]
6505 =
6506 grad_w[eN*nQuadraturePoints_element*nDOF_test_element*nSpace+
6507 k*nDOF_test_element*nSpace+
6508 i*nSpace+
6509 I]
6510 *
6511 dVR[k]
6512 ;
6513}
6514
6515void calculateWeightedShapeHessians(int nElements_global,
6516 int nQuadraturePoints_element,
6517 int nDOF_test_element,
6518 int nSpace,
6519 double* dVR,
6520 double* abs_det_jac,
6521 double* Hess_w,
6522 double* Hess_w_dV)
6523{
6524 int eN,i,k,I,J,nSpace2=nSpace*nSpace;
6525 for (eN=0;eN<nElements_global;eN++)
6526 for (k=0;k<nQuadraturePoints_element;k++)
6527 for (i=0;i<nDOF_test_element;i++)
6528 for (I=0;I<nSpace;I++)
6529 for (J=0;J<nSpace;J++)
6530 Hess_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace2+
6531 k*nDOF_test_element*nSpace2+
6532 i*nSpace2+
6533 I*nSpace+
6534 J]
6535 =
6536 Hess_w[eN*nQuadraturePoints_element*nDOF_test_element*nSpace2+
6537 k*nDOF_test_element*nSpace2+
6538 i*nSpace2+
6539 I*nSpace+
6540 J]
6541 *
6542 dVR[k]
6543 *
6544 abs_det_jac[eN*nQuadraturePoints_element+
6545 k];
6546}
6547
6551void calculateShape_X_weightedShape(int nElements_global,
6552 int nQuadraturePoints_element,
6553 int nDOF_trial_element,
6554 int nDOF_test_element,
6555 double* v,
6556 double* w_dV,
6557 double* v_X_w_dV)
6558{
6559 int eN,k,i,j,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
6560 for (eN=0;eN<nElements_global;eN++)
6561 for (k=0;k<nQuadraturePoints_element;k++)
6562 for (i=0;i<nDOF_test_element;i++)
6563 for (j=0;j<nDOF_trial_element;j++)
6564 v_X_w_dV[eN*nQuadraturePoints_element*nDOF_test_X_trial_element +
6565 k*nDOF_test_X_trial_element+
6566 j*nDOF_test_element+
6567 i]
6568 =
6569 v[eN*nQuadraturePoints_element*nDOF_trial_element +
6570 k*nDOF_trial_element+
6571 j]
6572 *
6573 w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
6574 k*nDOF_test_element+
6575 i];
6576}
6577
6581void calculateShape_X_weightedGradShape(int nElements_global,
6582 int nQuadraturePoints_element,
6583 int nDOF_trial_element,
6584 int nDOF_test_element,
6585 int nSpace,
6586 double* v,
6587 double* grad_w_dV,
6588 double* v_X_grad_w_dV)
6589{
6590 int eN,k,i,j,I,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
6591 for (eN=0;eN<nElements_global;eN++)
6592 for (k=0;k<nQuadraturePoints_element;k++)
6593 for (i=0;i<nDOF_test_element;i++)
6594 for (j=0;j<nDOF_trial_element;j++)
6595 for (I=0;I<nSpace;I++)
6596 v_X_grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_X_trial_element*nSpace +
6597 k*nDOF_test_X_trial_element*nSpace+
6598 j*nDOF_test_element*nSpace+
6599 i*nSpace+
6600 I]
6601 =
6602 v[eN*nQuadraturePoints_element*nDOF_trial_element +
6603 k*nDOF_trial_element+
6604 j]
6605 *
6606 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
6607 k*nDOF_test_element*nSpace+
6608 i*nSpace+
6609 I];
6610}
6611
6615void calculateGradShape_X_weightedShape(int nElements_global,
6616 int nQuadraturePoints_element,
6617 int nDOF_trial_element,
6618 int nDOF_test_element,
6619 int nSpace,
6620 double* grad_v,
6621 double* w_dV,
6622 double* grad_v_X_w_dV)
6623{
6624 int eN,k,i,j,I,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
6625 for (eN=0;eN<nElements_global;eN++)
6626 for (k=0;k<nQuadraturePoints_element;k++)
6627 for (i=0;i<nDOF_test_element;i++)
6628 for (j=0;j<nDOF_trial_element;j++)
6629 for (I=0;I<nSpace;I++)
6630 grad_v_X_w_dV[eN*nQuadraturePoints_element*nDOF_test_X_trial_element*nSpace +
6631 k*nDOF_test_X_trial_element*nSpace+
6632 j*nDOF_test_element*nSpace+
6633 i*nSpace+
6634 I]
6635 =
6636 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
6637 k*nDOF_trial_element*nSpace+
6638 j*nSpace+
6639 I]
6640 *
6641 w_dV[eN*nQuadraturePoints_element*nDOF_test_element +
6642 k*nDOF_test_element+
6643 i];
6644}
6645
6649void calculateGradShape_X_weightedGradShape(int nElements_global,
6650 int nQuadraturePoints_element,
6651 int nDOF_trial_element,
6652 int nDOF_test_element,
6653 int nSpace,
6654 double* grad_v,
6655 double* grad_w_dV,
6656 double* grad_v_X_grad_w_dV)
6657{
6658 int eN,k,i,j,I,J,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,nSpace2=nSpace*nSpace;
6659 for (eN=0;eN<nElements_global;eN++)
6660 for (k=0;k<nQuadraturePoints_element;k++)
6661 for (i=0;i<nDOF_test_element;i++)
6662 for (j=0;j<nDOF_trial_element;j++)
6663 for (I=0;I<nSpace;I++)
6664 for (J=0;J<nSpace;J++)
6665 grad_v_X_grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_X_trial_element*nSpace2 +
6666 k*nDOF_test_X_trial_element*nSpace2+
6667 j*nDOF_test_element*nSpace2+
6668 i*nSpace2+
6669 I*nSpace+
6670 J]
6671 =
6672 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
6673 k*nDOF_trial_element*nSpace+
6674 j*nSpace+
6675 I]
6676 *
6677 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
6678 k*nDOF_test_element*nSpace+
6679 i*nSpace+
6680 J];
6681}
6682
6686void calculateWeightedShapeTrace(int nElements_global,
6687 int nElementBoundaries_element,
6688 int nElementBoundaryQuadraturePoints_elementBoundary,
6689 int nDOF_test_element,
6690 double* dSR,
6691 double* sqrt_det_g,
6692 double* w,
6693 double* w_dS)
6694{
6695 int eN,ebN,i,k;
6696 for (eN=0;eN<nElements_global;eN++)
6697 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
6698 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
6699 for (i=0;i<nDOF_test_element;i++)
6700 {
6701 w_dS[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element+
6702 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element +
6703 k*nDOF_test_element+
6704 i]
6705 =
6706 w[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element+
6707 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element +
6708 k*nDOF_test_element+
6709 i]
6710 *
6711 dSR[k]
6712 *
6713 sqrt_det_g[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary+
6714 ebN*nElementBoundaryQuadraturePoints_elementBoundary+
6715 k];
6716 }
6717}
6718void calculateWeightedPiolaShapeTrace(int nElements_global,
6719 int nElementBoundaries_element,
6720 int nElementBoundaryQuadraturePoints_elementBoundary,
6721 int nDOF_test_element,
6722 double* dSR,
6723 double* sqrt_det_g,
6724 double* w,
6725 double* w_dS)
6726{
6727 int eN,ebN,i,k;
6728 for (eN=0;eN<nElements_global;eN++)
6729 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
6730 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
6731 for (i=0;i<nDOF_test_element;i++)
6732 {
6733 w_dS[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element+
6734 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element +
6735 k*nDOF_test_element+
6736 i]
6737 =
6738 w[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element+
6739 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element +
6740 k*nDOF_test_element+
6741 i]
6742 *
6743 dSR[k]
6744 *
6745 sqrt_det_g[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary+
6746 ebN*nElementBoundaryQuadraturePoints_elementBoundary+
6747 k];
6748 }
6749}
6750
6754void calculateShape_X_weightedShapeTrace(int nElements_global,
6755 int nElementBoundaries_element,
6756 int nElementBoundaryQuadraturePoints_elementBoundary,
6757 int nDOF_trial_element,
6758 int nDOF_test_element,
6759 double* v,
6760 double* w_dS,
6761 double* v_X_w_dS)
6762{
6763 int eN,ebN,k,i,j,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
6764 for (eN=0;eN<nElements_global;eN++)
6765 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
6766 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
6767 for (i=0;i<nDOF_test_element;i++)
6768 for (j=0;j<nDOF_trial_element;j++)
6769 v_X_w_dS[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_X_trial_element +
6770 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_X_trial_element +
6771 k*nDOF_test_X_trial_element+
6772 j*nDOF_test_element+
6773 i]
6774 =
6775 v[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_trial_element +
6776 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_trial_element +
6777 k*nDOF_trial_element+
6778 j]
6779 *
6780 w_dS[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element +
6781 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element +
6782 k*nDOF_trial_element+
6783 i];
6784}
6785
6789void calculateGradShape_X_weightedShapeTrace(int nElements_global,
6790 int nElementBoundaries_element,
6791 int nElementBoundaryQuadraturePoints_elementBoundary,
6792 int nDOF_trial_element,
6793 int nDOF_test_element,
6794 int nSpace,
6795 double* grad_v,
6796 double* w_dS,
6797 double* grad_v_X_w_dS)
6798{
6799 int eN,ebN,k,i,j,I,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
6800 for (eN=0;eN<nElements_global;eN++)
6801 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
6802 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
6803 for (i=0;i<nDOF_test_element;i++)
6804 for (j=0;j<nDOF_trial_element;j++)
6805 for (I=0;I<nSpace;I++)
6806 grad_v_X_w_dS[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_X_trial_element*nSpace +
6807 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_X_trial_element*nSpace +
6808 k*nDOF_test_X_trial_element*nSpace+
6809 j*nDOF_test_element*nSpace+
6810 i*nSpace+
6811 I]
6812 =
6813 grad_v[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace +
6814 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace +
6815 k*nDOF_trial_element*nSpace+
6816 j*nSpace+
6817 I]
6818 *
6819 w_dS[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element +
6820 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element +
6821 k*nDOF_test_element+
6822 i];
6823}
6824
6828void calculateWeightedShapeGlobalExteriorTrace(int nElementBoundaryQuadraturePoints_elementBoundary,
6829 int nDOF_test_element,
6830 int nExteriorElementBoundaries_global,
6831 const int* exteriorElementBoundariesArray,
6832 const int* elementBoundaryElementsArray,
6833 const int* elementBoundaryLocalElementBoundariesArray,
6834 double* dSR,
6835 double* sqrt_det_g,
6836 double* w,
6837 double* w_dS)
6838{
6839 int ebNE,i,k;
6840 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
6841 {
6842 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
6843 for (i=0;i<nDOF_test_element;i++)
6844 {
6845 w_dS[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element +
6846 k*nDOF_test_element+
6847 i]
6848 =
6849 w[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element +
6850 k*nDOF_test_element+
6851 i]
6852 *
6853 dSR[k]
6854 *
6855 sqrt_det_g[ebNE*nElementBoundaryQuadraturePoints_elementBoundary+
6856 k];
6857 }
6858 }
6859}
6860
6864void calculateShape_X_weightedShapeGlobalExteriorTrace(int nElementBoundaryQuadraturePoints_elementBoundary,
6865 int nDOF_trial_element,
6866 int nDOF_test_element,
6867 int nExteriorElementBoundaries_global,
6868 const int* exteriorElementBoundariesArray,
6869 const int* elementBoundaryElementsArray,
6870 const int* elementBoundaryLocalElementBoundariesArray,
6871 double* v,
6872 double* w_dS,
6873 double* v_X_w_dS)
6874{
6875 int ebNE,k,i,j,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
6876 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
6877 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
6878 for (i=0;i<nDOF_test_element;i++)
6879 for (j=0;j<nDOF_trial_element;j++)
6880 v_X_w_dS[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_X_trial_element +
6881 k*nDOF_test_X_trial_element+
6882 j*nDOF_test_element+
6883 i]
6884 =
6885 v[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_trial_element +
6886 k*nDOF_trial_element+
6887 j]
6888 *
6889 w_dS[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element +
6890 k*nDOF_trial_element+
6891 i];
6892}
6893
6897void calculateGradShape_X_weightedShapeGlobalExteriorTrace(int nElementBoundaryQuadraturePoints_elementBoundary,
6898 int nDOF_trial_element,
6899 int nDOF_test_element,
6900 int nSpace,
6901 int nExteriorElementBoundaries_global,
6902 const int* exteriorElementBoundariesArray,
6903 const int* elementBoundaryElementsArray,
6904 const int* elementBoundaryLocalElementBoundariesArray,
6905 double* grad_v,
6906 double* w_dS,
6907 double* grad_v_X_w_dS)
6908{
6909 int ebNE,k,i,j,I,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
6910 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
6911 for (k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
6912 for (i=0;i<nDOF_test_element;i++)
6913 for (j=0;j<nDOF_trial_element;j++)
6914 for (I=0;I<nSpace;I++)
6915 grad_v_X_w_dS[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_X_trial_element*nSpace +
6916 k*nDOF_test_X_trial_element*nSpace+
6917 j*nDOF_test_element*nSpace+
6918 i*nSpace+
6919 I]
6920 =
6921 grad_v[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace +
6922 k*nDOF_trial_element*nSpace+
6923 j*nSpace+
6924 I]
6925 *
6926 w_dS[ebNE*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_test_element +
6927 k*nDOF_test_element+
6928 i];
6929}
6930
6931
6935void calculateIntegrationWeights(int nElements_global,
6936 int nQuadraturePoints_element,
6937 double* abs_det_J,
6938 double* referenceWeights,
6939 double* weights)
6940{
6941 int eN,k;
6942 for (eN=0;eN<nElements_global;eN++)
6943 for (k=0;k<nQuadraturePoints_element;k++)
6944 weights[eN*nQuadraturePoints_element+
6945 k]
6946 =
6947 abs_det_J[eN*nQuadraturePoints_element+
6948 k]
6949 *
6950 referenceWeights[k];
6951}
6952
6953void calculateElementBoundaryIntegrationWeights(int nElements_global,
6954 int nElementBoundaries_element,
6955 int nQuadraturePoints_elementBoundary,
6956 double* sqrt_det_g,
6957 double* referenceWeights,
6958 double* weights)
6959{
6960 int ebN,eN,k;
6961 for (eN=0;eN<nElements_global;eN++)
6962 for (ebN=0; ebN < nElementBoundaries_element; ebN++)
6963 for (k=0;k<nQuadraturePoints_elementBoundary;k++)
6964 weights[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
6965 ebN*nQuadraturePoints_elementBoundary +
6966 k]
6967 =
6968 sqrt_det_g[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
6969 ebN*nQuadraturePoints_elementBoundary +
6970 k]
6971 *
6972 referenceWeights[k];
6973}
6974
6975void calculateGlobalExteriorElementBoundaryIntegrationWeights(int nQuadraturePoints_elementBoundary,
6976 int nExteriorElementBoundaries_global,
6977 double* sqrt_det_g,
6978 double* referenceWeights,
6979 double* weights)
6980{
6981 int ebNE,k;
6982 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
6983 for (k=0;k<nQuadraturePoints_elementBoundary;k++)
6984 weights[ebNE*nQuadraturePoints_elementBoundary +
6985 k]
6986 =
6987 sqrt_det_g[ebNE*nQuadraturePoints_elementBoundary +
6988 k]
6989 *
6990 referenceWeights[k];
6991}
6992
6996void calculateFiniteElementFunctionValues(int nElements_global,
6997 int nQuadraturePoints_element,
6998 int nDOF_trial_element,
6999 int nComponents,
7000 int* l2g,
7001 double* dof,
7002 double* v,
7003 double* u)
7004{
7005 int eN,k,j,t;
7006 memset(u,0,sizeof(double)*nElements_global*nQuadraturePoints_element*nComponents);
7007 for (eN=0;eN<nElements_global;eN++)
7008 for (k=0;k<nQuadraturePoints_element;k++)
7009 for (j=0;j<nDOF_trial_element;j++)
7010 for (t=0;t<nComponents;t++)
7011 u[eN*nQuadraturePoints_element*nComponents+
7012 k*nComponents+
7013 t]
7014 +=
7015 dof[l2g[eN*nDOF_trial_element+
7016 j]*nComponents+
7017 t]
7018 *
7019 v[eN*nQuadraturePoints_element*nDOF_trial_element+
7020 k*nDOF_trial_element+
7021 j];
7022}
7023
7027void calculateFiniteElementFunctionGradientValues(int nElements_global,
7028 int nQuadraturePoints_element,
7029 int nDOF_trial_element,
7030 int nComponents,
7031 int nSpace,
7032 int* l2g,
7033 double* dof,
7034 double* grad_v,
7035 double* grad_u)
7036{
7037 int eN,k,j,t,I;
7038 memset(grad_u,0,sizeof(double)*nElements_global*nQuadraturePoints_element*nComponents*nSpace);
7039 for (eN=0;eN<nElements_global;eN++)
7040 for (k=0;k<nQuadraturePoints_element;k++)
7041 for (j=0;j<nDOF_trial_element;j++)
7042 for (t=0;t<nComponents;t++)
7043 for (I=0;I<nSpace;I++)
7044 grad_u[eN*nQuadraturePoints_element*nComponents*nSpace+
7045 k*nComponents*nSpace+
7046 t*nSpace+
7047 I]
7048 +=
7049 dof[l2g[eN*nDOF_trial_element+
7050 j]*nComponents+
7051 t]
7052 *
7053 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace+
7054 k*nDOF_trial_element*nSpace+
7055 j*nSpace+
7056 I];
7057}
7058
7059void calculateFiniteElementFunctionHessianValues(int nElements_global,
7060 int nQuadraturePoints_element,
7061 int nDOF_trial_element,
7062 int nComponents,
7063 int nSpace,
7064 int* l2g,
7065 double* dof,
7066 double* Hessian_v,
7067 double* Hessian_u)
7068{
7069 int eN,k,j,t,I,J,nSpace2=nSpace*nSpace;
7070 memset(Hessian_u,0,sizeof(double)*nElements_global*nQuadraturePoints_element*nComponents*nSpace2);
7071 for (eN=0;eN<nElements_global;eN++)
7072 for (k=0;k<nQuadraturePoints_element;k++)
7073 for (j=0;j<nDOF_trial_element;j++)
7074 for (t=0;t<nComponents;t++)
7075 for (I=0;I<nSpace;I++)
7076 for (J=0;J<nSpace;J++)
7077 Hessian_u[eN*nQuadraturePoints_element*nComponents*nSpace2+
7078 k*nComponents*nSpace2+
7079 t*nSpace2+
7080 I*nSpace+
7081 J]
7082 +=
7083 dof[l2g[eN*nDOF_trial_element+
7084 j]*nComponents+
7085 t]
7086 *
7087 Hessian_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace2+
7088 k*nDOF_trial_element*nSpace2+
7089 j*nSpace2+
7090 I*nSpace+
7091 J];
7092}
7093
7138void calculateFiniteElementFunctionGradientTensorValues(int nElements_global,
7139 int nQuadraturePoints_element,
7140 int nDOF_trial_element,
7141 int nDOF_test_element,
7142 int nComponents,
7143 int nSpace,
7144 int* l2g,
7145 double* dof,
7146 double* grad_v_X_grad_w_dV,
7147 double* grad_u_X_grad_w_dV)
7148{
7149 int eN,k,j,i,I,J,t,nSpace2=nSpace*nSpace;
7150 int nDOF_test_X_trial_element = nDOF_test_element*nDOF_trial_element;
7151 memset(grad_u_X_grad_w_dV,0,sizeof(double)*nElements_global*nQuadraturePoints_element*nDOF_test_element*nComponents*nSpace2);
7152 for(eN=0;eN<nElements_global;eN++)
7153 for(k=0;k<nQuadraturePoints_element;k++)
7154 for(j=0;j<nDOF_trial_element;j++)
7155 for(i=0;i<nDOF_test_element;i++)
7156 for (t=0;t<nComponents;t++)
7157 for(I=0;I<nSpace;I++)
7158 for(J=0;J<nSpace;J++)
7159 grad_u_X_grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nComponents*nSpace2+
7160 k*nDOF_test_element*nComponents*nSpace2 +
7161 i*nComponents*nSpace2 +
7162 t*nSpace2 +
7163 I*nSpace +
7164 J]
7165 +=
7166 dof[l2g[eN*nDOF_trial_element+
7167 j]*nComponents+
7168 t]
7169 *
7170 grad_v_X_grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_X_trial_element*nSpace2 +
7171 k*nDOF_test_X_trial_element*nSpace2 +
7172 j*nDOF_test_element*nSpace2 +
7173 i*nSpace2 +
7174 I*nSpace +
7175 J];
7176}
7177
7181void calculateFiniteElementFunctionValuesTrace(int nElements_global,
7182 int nElementBoundaries_element,
7183 int nQuadraturePoints_elementBoundary,
7184 int nDOF_trial_element,
7185 int nComponents,
7186 int* l2g,
7187 double* dof,
7188 double* v,
7189 double* u)
7190{
7191 int eN,ebN,k,j,t;
7192 memset(u,0,sizeof(double)*nElements_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nComponents);
7193 for(eN=0;eN<nElements_global;eN++)
7194 for(ebN=0;ebN<nElementBoundaries_element;ebN++)
7195 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
7196 for(j=0;j<nDOF_trial_element;j++)
7197 for(t=0;t<nComponents;t++)
7198 u[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nComponents+
7199 ebN*nQuadraturePoints_elementBoundary*nComponents+
7200 k*nComponents+
7201 t]
7202 +=
7203 dof[l2g[eN*nDOF_trial_element+j]*nComponents+
7204 t]
7205 *
7206 v[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
7207 ebN*nQuadraturePoints_elementBoundary*nDOF_trial_element+
7208 k*nDOF_trial_element+
7209 j];
7210}
7211
7212
7216void calculateFiniteElementFunctionGradientValuesTrace(int nElements_global,
7217 int nElementBoundaries_element,
7218 int nQuadraturePoints_elementBoundary,
7219 int nDOF_trial_element,
7220 int nComponents,
7221 int nSpace,
7222 int* l2g,
7223 double* dof,
7224 double* grad_v,
7225 double* grad_u)
7226{
7227 int eN,ebN,k,j,t,I;
7228 memset(grad_u,0,sizeof(double)*nElements_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nComponents*nSpace);
7229 for(eN=0;eN<nElements_global;eN++)
7230 for(ebN=0;ebN<nElementBoundaries_element;ebN++)
7231 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
7232 for(j=0;j<nDOF_trial_element;j++)
7233 for(t=0;t<nComponents;t++)
7234 for(I=0;I<nSpace;I++)
7235 grad_u[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nComponents*nSpace+
7236 ebN*nQuadraturePoints_elementBoundary*nComponents*nSpace+
7237 k*nComponents*nSpace+
7238 t*nSpace+
7239 I]
7240 +=
7241 dof[l2g[eN*nDOF_trial_element+j]*nComponents+
7242 t]
7243 *
7244 grad_v[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
7245 ebN*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
7246 k*nDOF_trial_element*nSpace+
7247 j*nSpace+
7248 I];
7249}
7250void calculateFiniteElementFunctionValuesGlobalExteriorTrace(int nQuadraturePoints_elementBoundary,
7251 int nDOF_trial_element,
7252 int nComponents,
7253 int nExteriorElementBoundaries_global,
7254 const int * exteriorElementBoundariesArray,
7255 const int * elementBoundaryElementsArray,
7256 const int * elementBoundaryLocalElementBoundariesArray,
7257 int* l2g,
7258 double* dof,
7259 double* v,
7260 double* u)
7261{
7262 int eN,ebN,ebNE,ebN_local,k,j,t;
7263 memset(u,0,sizeof(double)*nExteriorElementBoundaries_global*nQuadraturePoints_elementBoundary*nComponents);
7264 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
7265 {
7266 ebN = exteriorElementBoundariesArray[ebNE];
7267 eN = elementBoundaryElementsArray[ebN*2+0];
7268 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
7269 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
7270 for(j=0;j<nDOF_trial_element;j++)
7271 for(t=0;t<nComponents;t++)
7272 u[ebNE*nQuadraturePoints_elementBoundary*nComponents+
7273 k*nComponents+
7274 t]
7275 +=
7276 dof[l2g[eN*nDOF_trial_element+j]*nComponents+
7277 t]
7278 *
7279 v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
7280 k*nDOF_trial_element+
7281 j];
7282 }
7283}
7284
7285void calculateFiniteElementFunctionGradientValuesGlobalExteriorTrace(int nQuadraturePoints_elementBoundary,
7286 int nDOF_trial_element,
7287 int nComponents,
7288 int nSpace,
7289 int nExteriorElementBoundaries_global,
7290 const int * exteriorElementBoundariesArray,
7291 const int * elementBoundaryElementsArray,
7292 const int * elementBoundaryLocalElementBoundariesArray,
7293 int* l2g,
7294 double* dof,
7295 double* grad_v,
7296 double* grad_u)
7297{
7298 int eN,ebN,ebNE,ebN_local,k,j,t,I;
7299 memset(grad_u,0,sizeof(double)*nExteriorElementBoundaries_global*nQuadraturePoints_elementBoundary*nComponents*nSpace);
7300 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
7301 {
7302 ebN = exteriorElementBoundariesArray[ebNE];
7303 eN = elementBoundaryElementsArray[ebN*2+0];
7304 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
7305 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
7306 for(j=0;j<nDOF_trial_element;j++)
7307 for(t=0;t<nComponents;t++)
7308 for(I=0;I<nSpace;I++)
7309 grad_u[ebNE*nQuadraturePoints_elementBoundary*nComponents*nSpace+
7310 k*nComponents*nSpace+
7311 t*nSpace+
7312 I]
7313 +=
7314 dof[l2g[eN*nDOF_trial_element+j]*nComponents+
7315 t]
7316 *
7317 grad_v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
7318 k*nDOF_trial_element*nSpace+
7319 j*nSpace+
7320 I];
7321 }
7322}
7323
7324
7328void calculateFlowVelocity(int nElements_global,
7329 int nQuadraturePoints_element,
7330 int nSpace,
7331 double* f,
7332 double* a,
7333 double* grad_phi,
7334 double* v)
7335{
7336 int eN,k,I,J,nSpace2=nSpace*nSpace;
7337 for (eN=0;eN<nElements_global;eN++)
7338 for (k=0;k<nQuadraturePoints_element;k++)
7339 for (I=0;I<nSpace;I++)
7340 {
7341 v[eN*nQuadraturePoints_element*nSpace+
7342 k*nSpace+
7343 I]
7344 =
7345 f[eN*nQuadraturePoints_element*nSpace+
7346 k*nSpace+
7347 I];
7348 for (J=0;J<nSpace;J++)
7349 v[eN*nQuadraturePoints_element*nSpace+
7350 k*nSpace+
7351 I]
7352 -=
7353 a[eN*nQuadraturePoints_element*nSpace2+
7354 k*nSpace2+
7355 I*nSpace+
7356 J]
7357 *
7358 grad_phi[eN*nQuadraturePoints_element*nSpace+
7359 k*nSpace+
7360 J];
7361 }
7362}
7363
7367void updateAddJacobian_CSR(int jacIndex,
7368 double val,
7369 double* jac)
7370{
7371 jac[jacIndex] += val;
7372}
7373
7377void zeroJacobian_CSR(int nNonzeros,
7378 double* jac)
7379{
7380 memset(jac,0,sizeof(double)*nNonzeros);
7381}
7382
7383void calculateInteriorElementBoundaryVelocities(int nInteriorElementBoundaries_global,
7384 int nElementBoundaries_element,
7385 int nQuadraturePoints_elementBoundary,
7386 int nSpace,
7387 int* interiorElementBoundaries,
7388 int* elementBoundaryElements,
7389 int* elementBoundaryLocalElementBoundaries,
7390 double* m,
7391 double* a,
7392 double* grad_phi,
7393 double* f,
7394 double* vAverage,
7395 double* vJump,
7396 double* mAverage,
7397 double* mJump)
7398{
7399 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,I,J,nSpace2=nSpace*nSpace;
7400 register double vLeft,vRight,mLeft,mRight;
7401 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
7402 {
7403 ebN = interiorElementBoundaries[ebNI];
7404 left_eN_global = elementBoundaryElements[ebN*2+0];
7405 right_eN_global = elementBoundaryElements[ebN*2+1];
7406 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
7407 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
7408 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
7409 {
7410 mLeft
7411 =
7412 m[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
7413 left_ebN_element*nQuadraturePoints_elementBoundary+
7414 k];
7415 mRight
7416 =
7417 m[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
7418 right_ebN_element*nQuadraturePoints_elementBoundary+
7419 k];
7420 for (I=0;I<nSpace;I++)
7421 {
7422 vLeft
7423 =
7424 f[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7425 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7426 k*nSpace+
7427 I];
7428 vRight
7429 =
7430 f[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7431 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7432 k*nSpace+
7433 I];
7434 for (J=0;J<nSpace;J++)
7435 {
7436 vLeft
7437 -=
7438 a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
7439 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
7440 k*nSpace2+
7441 I*nSpace+
7442 J]
7443 *
7444 grad_phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7445 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7446 k*nSpace+
7447 J];
7448 vRight -=
7449 a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
7450 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
7451 k*nSpace2+
7452 I*nSpace+
7453 J]
7454 *
7455 grad_phi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7456 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7457 k*nSpace+
7458 J];
7459 }
7460 vAverage[ebN*nQuadraturePoints_elementBoundary*nSpace+
7461 k*nSpace+
7462 I] = 0.5*(vLeft + vRight);
7463 vJump[ebN*nQuadraturePoints_elementBoundary*nSpace+
7464 k*nSpace+
7465 I] = (vLeft - vRight);
7466 }
7467 mAverage[ebN*nQuadraturePoints_elementBoundary+
7468 k] = 0.5*(mLeft+mRight);
7469 mJump[ebN*nQuadraturePoints_elementBoundary+
7470 k] = mLeft - mRight;
7471 }
7472 }
7473}
7474
7475void calculateExteriorElementBoundaryVelocities(int nExteriorElementBoundaries_global,
7476 int nElementBoundaries_element,
7477 int nQuadraturePoints_elementBoundary,
7478 int nSpace,
7479 int* exteriorElementBoundaries,
7480 int* elementBoundaryElements,
7481 int* elementBoundaryLocalElementBoundaries,
7482 double* m,
7483 double* a,
7484 double* grad_phi,
7485 double* f,
7486 double* vAverage,
7487 double* vJump,
7488 double* mAverage,
7489 double* mJump)
7490{
7491 int ebNE,ebN,left_eN_global,left_ebN_element,k,I,J,nSpace2=nSpace*nSpace;
7492 register double vLeft,mLeft;
7493 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
7494 {
7495 ebN = exteriorElementBoundaries[ebNE];
7496 left_eN_global = elementBoundaryElements[ebN*2+0];
7497 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
7498 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
7499 {
7500 mLeft
7501 =
7502 m[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
7503 left_ebN_element*nQuadraturePoints_elementBoundary+
7504 k];
7505 for (I=0;I<nSpace;I++)
7506 {
7507 vLeft
7508 =
7509 f[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7510 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7511 k*nSpace+
7512 I];
7513 for (J=0;J<nSpace;J++)
7514 {
7515 vLeft
7516 -=
7517 a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
7518 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
7519 k*nSpace2+
7520 I*nSpace+
7521 J]
7522 *
7523 grad_phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7524 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7525 k*nSpace+
7526 J];
7527 }
7528 vAverage[ebN*nQuadraturePoints_elementBoundary*nSpace+
7529 k*nSpace+
7530 I] = vLeft;
7531 vJump[ebN*nQuadraturePoints_elementBoundary*nSpace+
7532 k*nSpace+
7533 I] = vLeft;
7534 }
7535 mAverage[ebN*nQuadraturePoints_elementBoundary+
7536 k] = mLeft;
7537 mJump[ebN*nQuadraturePoints_elementBoundary+
7538 k] = mLeft;
7539 }
7540 }
7541}
7542
7543/*mwf hack
7544 load in boundary condition velocity values directy into velocity vector
7545*/
7546void setExteriorGlobalElementBoundaryVelocityValues(int updateFluxValues,
7547 int nExteriorElementBoundaries_global,
7548 int nQuadraturePoints_elementBoundary,
7549 int nSpace,
7550 int* exteriorElementBoundaries,
7551 int* elementBoundaryElements,
7552 int* elementBoundaryLocalElementBoundaries,
7553 double* n,
7554 double* vn_in,
7555 double* v_out)
7556{
7557 int ebNE,ebN,k,I;
7558 double multiple = 0.0;
7559 if (updateFluxValues > 0)
7560 multiple = 1.0;
7561 /*mwf debug*/
7562 printf("setExteriorGlobalElementBoundaryVelocityValues update= %d nExtElmBndr_global= %d nQuadElmBndr= %d nSpace=%d \n",
7563 updateFluxValues,nExteriorElementBoundaries_global,nQuadraturePoints_elementBoundary,nSpace);
7564 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
7565 {
7566 ebN = exteriorElementBoundaries[ebNE];
7567 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
7568 for (I=0;I<nSpace;I++)
7569 {
7570 v_out[ebN*nQuadraturePoints_elementBoundary*nSpace+
7571 k*nSpace+
7572 I] =
7573 multiple*v_out[ebN*nQuadraturePoints_elementBoundary*nSpace+
7574 k*nSpace+
7575 I]
7576 +
7577 n[ebN*nQuadraturePoints_elementBoundary*nSpace+
7578 k*nSpace+
7579 I]
7580 *
7581 vn_in[ebN*nQuadraturePoints_elementBoundary+
7582 k];
7583
7584 /*mwf debug*/
7585 printf("setExtGlobElmVel ebN=%d k=%d I=%d vn_in=%g v_out=%g \n",
7586 ebN,k,I,
7587 vn_in[ebN*nQuadraturePoints_elementBoundary+
7588 k],
7589 v_out[ebN*nQuadraturePoints_elementBoundary*nSpace+
7590 k*nSpace+
7591 I]);
7592
7593 }
7594 }
7595
7596}
7597
7598
7602void calculateDimensionlessNumbersADR(int nElements_global,
7603 int nQuadraturePoints_element,
7604 int nSpace,
7605 int computeDiffusiveTimeStepLimit,
7606 double* elementDiameter,
7607 double* df,
7608 double* a,
7609 double* dphi,
7610 double* dr,
7611 double* dmt,
7612 double* pe,
7613 double* cfl)
7614{
7615 int eN,k,I,nSpace2=nSpace*nSpace;
7616 double h,Vlin,Alin,A_II,num,den,cfl1,cfl2;
7617 for(eN=0;eN<nElements_global;eN++)
7618 {
7619 h = elementDiameter[eN];
7620 for (k=0;k<nQuadraturePoints_element;k++)
7621 {
7622 Vlin = 0.0;
7623 Alin = 0.0;
7624 for(I=0;I<nSpace;I++)
7625 Vlin
7626 +=
7627 df[eN*nQuadraturePoints_element*nSpace +
7628 k*nSpace +
7629 I]
7630 *
7631 df[eN*nQuadraturePoints_element*nSpace +
7632 k*nSpace +
7633 I];
7634 Vlin = sqrt(Vlin);
7635 /*max diagonal entry for A. This choice needs to be looked into*/
7636 for(I=0;I<nSpace;I++)
7637 {
7638 A_II = a[eN*nQuadraturePoints_element*nSpace2 +
7639 k*nSpace2 +
7640 I*nSpace +
7641 I];
7642 Alin = (A_II > Alin) ? A_II : Alin;
7643 }
7644 Alin*=dphi[eN*nQuadraturePoints_element +
7645 k];
7646 cfl1 = Vlin/h;
7647 cfl2 = Alin/(h*h);
7648 if (computeDiffusiveTimeStepLimit)
7649 cfl[eN*nQuadraturePoints_element +
7650 k] = cfl2;
7651 else
7652 cfl[eN*nQuadraturePoints_element +
7653 k] = cfl1;
7654 num = 0.5*Vlin*h + 1.0e-8;
7655 den = Alin + num*1.0e-8;
7656 pe[eN*nQuadraturePoints_element + k] = num/den;
7657 }
7658 }
7659}
7660
7661void calculateDimensionlessNumbersADR_sd(int nElements_global,
7662 int nQuadraturePoints_element,
7663 int nSpace,
7664 int computeDiffusiveTimeStepLimit,
7665 int* rowptr,
7666 int* colind,
7667 double* elementDiameter,
7668 double* df,
7669 double* a,
7670 double* dphi,
7671 double* dr,
7672 double* dmt,
7673 double* pe,
7674 double* cfl)
7675{
7676 int eN,k,I,m,nnz=rowptr[nSpace];
7677 double h,Vlin,Alin,A_II,num,den,cfl1,cfl2;
7678 for(eN=0;eN<nElements_global;eN++)
7679 {
7680 h = elementDiameter[eN];
7681 for (k=0;k<nQuadraturePoints_element;k++)
7682 {
7683 Vlin = 0.0;
7684 Alin = 0.0;
7685 for(I=0;I<nSpace;I++)
7686 {
7687 Vlin
7688 +=
7689 df[eN*nQuadraturePoints_element*nSpace +
7690 k*nSpace +
7691 I]
7692 *
7693 df[eN*nQuadraturePoints_element*nSpace +
7694 k*nSpace +
7695 I];
7696 }
7697 Vlin = sqrt(Vlin);
7698 /*max diagonal entry for A. This choice needs to be looked into*/
7699 for(I=0;I<nSpace;I++)
7700 {
7701 for(m=rowptr[I];m<rowptr[I+1];m++)
7702 {
7703 if (I == colind[m])
7704 {
7705 A_II = a[eN*nQuadraturePoints_element*nnz+
7706 k*nnz+
7707 m];
7708 Alin = (A_II > Alin) ? A_II : Alin;
7709 }
7710 }
7711 }
7712 Alin*=dphi[eN*nQuadraturePoints_element +
7713 k];
7714 cfl1 = Vlin/h;
7715 cfl2 = Alin/(h*h);
7716 if (computeDiffusiveTimeStepLimit)
7717 cfl[eN*nQuadraturePoints_element +
7718 k] = cfl2;
7719 else
7720 cfl[eN*nQuadraturePoints_element +
7721 k] = cfl1;
7722 num = 0.5*Vlin*h + 1.0e-8;
7723 den = Alin + num*1.0e-8;
7724 pe[eN*nQuadraturePoints_element + k] = num/den;
7725 }
7726 }
7727}
7728
7729/*just compute CFL*/
7730void calculateCFLADR(int nElements_global,
7731 int nQuadraturePoints_element,
7732 int nSpace,
7733 double* elementDiameter,
7734 double* dm,
7735 double* df,
7736 double* cfl)
7737{
7738 int eN,k,I;
7739 double h,Vlin,dmdu,cfl1;
7740 for(eN=0;eN<nElements_global;eN++)
7741 {
7742 h = elementDiameter[eN];
7743 for (k=0;k<nQuadraturePoints_element;k++)
7744 {
7745 dmdu = dm[eN*nQuadraturePoints_element + k];
7746 Vlin = 0.0;
7747 for(I=0;I<nSpace;I++)
7748 Vlin
7749 +=
7750 df[eN*nQuadraturePoints_element*nSpace +
7751 k*nSpace +
7752 I]
7753 *
7754 df[eN*nQuadraturePoints_element*nSpace +
7755 k*nSpace +
7756 I];
7757 Vlin = sqrt(Vlin)/(dmdu+1.0e-10);
7758 cfl1 = Vlin/h;
7759 cfl[eN*nQuadraturePoints_element +
7760 k] = cfl1;
7761
7762 }
7763 }
7764}
7765/*not really likely but in case have two separate characteristic speeds to add?*/
7766void calculateCFLADR2speeds(int nElements_global,
7767 int nQuadraturePoints_element,
7768 int nSpace,
7769 double* elementDiameter,
7770 double* dm,
7771 double* df1,
7772 double* df2,
7773 double* cfl)
7774{
7775 int eN,k,I;
7776 double h,Vlin,dmdu,cfl1;
7777 for(eN=0;eN<nElements_global;eN++)
7778 {
7779 h = elementDiameter[eN];
7780 for (k=0;k<nQuadraturePoints_element;k++)
7781 {
7782 dmdu = dm[eN*nQuadraturePoints_element + k];
7783 Vlin = 0.0;
7784 for(I=0;I<nSpace;I++)
7785 Vlin
7786 +=
7787 df1[eN*nQuadraturePoints_element*nSpace +
7788 k*nSpace +
7789 I]
7790 *
7791 df1[eN*nQuadraturePoints_element*nSpace +
7792 k*nSpace +
7793 I]
7794 +
7795 df2[eN*nQuadraturePoints_element*nSpace +
7796 k*nSpace +
7797 I]
7798 *
7799 df2[eN*nQuadraturePoints_element*nSpace +
7800 k*nSpace +
7801 I];
7802
7803 Vlin = sqrt(Vlin)/(dmdu+1.0e-10);
7804 cfl1 = Vlin/h;
7805 cfl[eN*nQuadraturePoints_element +
7806 k] = cfl1;
7807
7808 }
7809 }
7810}
7811
7812
7816void updateInteriorElementBoundaryDiffusiveVelocity(int nInteriorElementBoundaries_global,
7817 int nElementBoundaries_element,
7818 int nQuadraturePoints_elementBoundary,
7819 int nSpace,
7820 int* interiorElementBoundaries,
7821 int* elementBoundaryElements,
7822 int* elementBoundaryLocalElementBoundaries,
7823 double* a,
7824 double* grad_phi,
7825 double* velocity)
7826{
7827 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,J,I,nSpace2=nSpace*nSpace;
7828 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
7829 {
7830 ebN = interiorElementBoundaries[ebNI];
7831 left_eN_global = elementBoundaryElements[ebN*2+0];
7832 right_eN_global = elementBoundaryElements[ebN*2+1];
7833 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
7834 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
7835 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
7836 for(I=0;I<nSpace;I++)
7837 for(J=0;J<nSpace;J++)
7838 {
7839 velocity[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7840 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7841 k*nSpace+I]
7842 -=
7843 a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
7844 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
7845 k*nSpace2+
7846 I*nSpace+
7847 J]
7848 *
7849 grad_phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7850 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7851 k*nSpace+J];
7852 velocity[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7853 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7854 k*nSpace+I]
7855 -=
7856 a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
7857 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
7858 k*nSpace2+
7859 I*nSpace+
7860 J]
7861 *
7862 grad_phi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7863 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7864 k*nSpace+J];
7865 }
7866 }
7867}
7868
7869void updateInteriorElementBoundaryDiffusiveVelocity_sd(int nInteriorElementBoundaries_global,
7870 int nElementBoundaries_element,
7871 int nQuadraturePoints_elementBoundary,
7872 int nSpace,
7873 int* rowptr,
7874 int* colind,
7875 int* interiorElementBoundaries,
7876 int* elementBoundaryElements,
7877 int* elementBoundaryLocalElementBoundaries,
7878 double* a,
7879 double* grad_phi,
7880 double* velocity)
7881{
7882 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,m,I,nnz=rowptr[nSpace];
7883 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
7884 {
7885 ebN = interiorElementBoundaries[ebNI];
7886 left_eN_global = elementBoundaryElements[ebN*2+0];
7887 right_eN_global = elementBoundaryElements[ebN*2+1];
7888 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
7889 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
7890 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
7891 for(I=0;I<nSpace;I++)
7892 for(m=rowptr[I];m<rowptr[I+1];m++)
7893 {
7894 velocity[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7895 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7896 k*nSpace+I]
7897 -=
7898 a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
7899 left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
7900 k*nnz+
7901 m]
7902 *
7903 grad_phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7904 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7905 k*nSpace+colind[m]];
7906 velocity[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7907 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7908 k*nSpace+I]
7909 -=
7910 a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
7911 right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
7912 k*nnz+
7913 m]
7914 *
7915 grad_phi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7916 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7917 k*nSpace+colind[m]];
7918 }
7919 }
7920}
7921
7925void updateExteriorElementBoundaryDiffusiveVelocity(int nExteriorElementBoundaries_global,
7926 int nElementBoundaries_element,
7927 int nQuadraturePoints_elementBoundary,
7928 int nSpace,
7929 int* exteriorElementBoundaries,
7930 int* elementBoundaryElements,
7931 int* elementBoundaryLocalElementBoundaries,
7932 double* a,
7933 double* grad_phi,
7934 double* velocity)
7935{
7936 int ebNE,ebN,eN_global,ebN_element,k,J,I,nSpace2=nSpace*nSpace;
7937 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
7938 {
7939 ebN = exteriorElementBoundaries[ebNE];
7940 eN_global = elementBoundaryElements[ebN*2+0];
7941 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
7942 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
7943 for(I=0;I<nSpace;I++)
7944 {
7945 for(J=0;J<nSpace;J++)
7946 {
7947 velocity[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7948 ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7949 k*nSpace+I]
7950 -=
7951 a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
7952 ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
7953 k*nSpace2+
7954 I*nSpace+
7955 J]
7956 *
7957 grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7958 ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7959 k*nSpace+J];
7960 }
7961 }/*I*/
7962 }
7963}
7964
7965void updateExteriorElementBoundaryDiffusiveVelocity_sd(int nExteriorElementBoundaries_global,
7966 int nElementBoundaries_element,
7967 int nQuadraturePoints_elementBoundary,
7968 int nSpace,
7969 int* rowptr,
7970 int* colind,
7971 int* exteriorElementBoundaries,
7972 int* elementBoundaryElements,
7973 int* elementBoundaryLocalElementBoundaries,
7974 double* a,
7975 double* grad_phi,
7976 double* velocity)
7977{
7978 int ebNE,ebN,eN_global,ebN_element,k,m,I,nnz=rowptr[nSpace];
7979 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
7980 {
7981 ebN = exteriorElementBoundaries[ebNE];
7982 eN_global = elementBoundaryElements[ebN*2+0];
7983 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
7984 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
7985 for(I=0;I<nSpace;I++)
7986 {
7987 for(m=rowptr[I];m<rowptr[I+1];m++)
7988 {
7989 velocity[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7990 ebN_element*nQuadraturePoints_elementBoundary*nSpace+
7991 k*nSpace+I]
7992 -=
7993 a[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
7994 ebN_element*nQuadraturePoints_elementBoundary*nnz+
7995 k*nnz+
7996 m]
7997 *
7998 grad_phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
7999 ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8000 k*nSpace+colind[m]];
8001 }
8002 }/*I*/
8003 }
8004}
8005
8009void updateGlobalExteriorElementBoundaryDiffusiveVelocity(int nExteriorElementBoundaries_global,
8010 int nQuadraturePoints_elementBoundary,
8011 int nSpace,
8012 int* exteriorElementBoundaries,
8013 int* elementBoundaryElements,
8014 int* elementBoundaryLocalElementBoundaries,
8015 double* a,
8016 double* grad_phi,
8017 double* velocity)
8018{
8019 int ebNE,k,J,I,nSpace2=nSpace*nSpace;
8020 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
8021 {
8022 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8023 for(I=0;I<nSpace;I++)
8024 {
8025 for(J=0;J<nSpace;J++)
8026 {
8027 velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
8028 k*nSpace+I]
8029 -=
8030 a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
8031 k*nSpace2+
8032 I*nSpace+
8033 J]
8034 *
8035 grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
8036 k*nSpace+J];
8037 }
8038 }/*I*/
8039 }
8040}
8041
8042void updateGlobalExteriorElementBoundaryDiffusiveVelocity_sd(int nExteriorElementBoundaries_global,
8043 int nQuadraturePoints_elementBoundary,
8044 int nSpace,
8045 int* rowptr,
8046 int* colind,
8047 int* exteriorElementBoundaries,
8048 int* elementBoundaryElements,
8049 int* elementBoundaryLocalElementBoundaries,
8050 double* a,
8051 double* grad_phi,
8052 double* velocity)
8053{
8054 int ebNE,k,m,I,nnz=rowptr[nSpace];
8055 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
8056 {
8057 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8058 for(I=0;I<nSpace;I++)
8059 {
8060 for(m=rowptr[I];m<rowptr[I+1];m++)
8061 {
8062 velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
8063 k*nSpace+I]
8064 -=
8065 a[ebNE*nQuadraturePoints_elementBoundary*nnz+
8066 k*nnz+
8067 m]
8068 *
8069 grad_phi[ebNE*nQuadraturePoints_elementBoundary*nSpace+
8070 k*nSpace+colind[m]];
8071 }
8072 }/*I*/
8073 }
8074}
8075
8076
8080void updateInteriorElementBoundaryAdvectiveVelocity(int nInteriorElementBoundaries_global,
8081 int nElementBoundaries_element,
8082 int nQuadraturePoints_elementBoundary,
8083 int nSpace,
8084 int* interiorElementBoundaries,
8085 int* elementBoundaryElements,
8086 int* elementBoundaryLocalElementBoundaries,
8087 double* f,
8088 double* velocity)
8089{
8090 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,J;
8091 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
8092 {
8093 ebN = interiorElementBoundaries[ebNI];
8094 left_eN_global = elementBoundaryElements[ebN*2+0];
8095 right_eN_global = elementBoundaryElements[ebN*2+1];
8096 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
8097 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
8098 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8099 for (J=0;J<nSpace;J++)
8100 {
8101 velocity[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8102 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8103 k*nSpace+
8104 J]
8105 +=
8106 f[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8107 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8108 k*nSpace+
8109 J];
8110 velocity[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8111 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8112 k*nSpace+
8113 J]
8114 +=
8115 f[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8116 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8117 k*nSpace+
8118 J];
8119 }
8120 }
8121}
8122
8123
8127void updateExteriorElementBoundaryAdvectiveVelocity(int nExteriorElementBoundaries_global,
8128 int nElementBoundaries_element,
8129 int nQuadraturePoints_elementBoundary,
8130 int nSpace,
8131 int* exteriorElementBoundaries,
8132 int* elementBoundaryElements,
8133 int* elementBoundaryLocalElementBoundaries,
8134 double* f,
8135 double* velocity)
8136{
8137 int ebNE,ebN,eN_global,ebN_element,k,J;
8138 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
8139 {
8140 ebN = exteriorElementBoundaries[ebNE];
8141 eN_global = elementBoundaryElements[ebN*2+0];
8142 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
8143 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8144 for(J=0;J<nSpace;J++)
8145 {
8146 velocity[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8147 ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8148 k*nSpace+
8149 J]
8150 +=
8151 f[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8152 ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8153 k*nSpace+
8154 J];
8155 }
8156 }
8157}
8158
8161void updateGlobalExteriorElementBoundaryAdvectiveVelocity(int nExteriorElementBoundaries_global,
8162 int nQuadraturePoints_elementBoundary,
8163 int nSpace,
8164 int* exteriorElementBoundaries,
8165 int* elementBoundaryElements,
8166 int* elementBoundaryLocalElementBoundaries,
8167 double* f,
8168 double* velocity)
8169{
8170 int ebNE,k,J;
8171 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
8172 {
8173 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8174 for(J=0;J<nSpace;J++)
8175 {
8176 velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
8177 k*nSpace+
8178 J]
8179 +=
8180 f[ebNE*nQuadraturePoints_elementBoundary*nSpace+
8181 k*nSpace+
8182 J];
8183 }
8184 }
8185}
8186
8190void updateInteriorElementBoundaryShockCapturingVelocity(int nInteriorElementBoundaries_global,
8191 int nElementBoundaries_element,
8192 int nQuadraturePoints_elementBoundary,
8193 int nQuadraturePoints_element,
8194 int nSpace,
8195 int* interiorElementBoundaries,
8196 int* elementBoundaryElements,
8197 int* elementBoundaryLocalElementBoundaries,
8198 double* numDiff,
8199 double* grad_u,
8200 double* velocity)
8201{
8202 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,I;
8203 double numDiffAvg_left,numDiffAvg_right;
8204 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
8205 {
8206 ebN = interiorElementBoundaries[ebNI];
8207 left_eN_global = elementBoundaryElements[ebN*2+0];
8208 right_eN_global = elementBoundaryElements[ebN*2+1];
8209 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
8210 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
8211 /*get scalar numDiff coefficient from the left and right assuming constant*/
8212 numDiffAvg_left = numDiff[left_eN_global*nQuadraturePoints_element+0];
8213 numDiffAvg_right = numDiff[right_eN_global*nQuadraturePoints_element+0];
8214 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8215 for(I=0;I<nSpace;I++)
8216 {
8217 velocity[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8218 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8219 k*nSpace+I]
8220 -=
8221 numDiffAvg_left
8222 *
8223 grad_u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8224 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8225 k*nSpace+I];
8226 velocity[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8227 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8228 k*nSpace+I]
8229 -=
8230 numDiffAvg_right
8231 *
8232 grad_u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8233 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8234 k*nSpace+I];
8235 }
8236 }
8237}
8238
8242void updateExteriorElementBoundaryShockCapturingVelocity(int nExteriorElementBoundaries_global,
8243 int nElementBoundaries_element,
8244 int nQuadraturePoints_elementBoundary,
8245 int nQuadraturePoints_element,
8246 int nSpace,
8247 int* exteriorElementBoundaries,
8248 int* elementBoundaryElements,
8249 int* elementBoundaryLocalElementBoundaries,
8250 double* numDiff,
8251 double* grad_u,
8252 double* velocity)
8253{
8254 int ebNE,ebN,eN_global,ebN_element,k,I;
8255 double numDiffAvg;
8256 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
8257 {
8258 ebN = exteriorElementBoundaries[ebNE];
8259 eN_global = elementBoundaryElements[ebN*2+0];
8260 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
8261 /*get scalar numDiff coefficient from the left and right assuming constant*/
8262 numDiffAvg = numDiff[eN_global*nQuadraturePoints_element+0];
8263 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8264 for(I=0;I<nSpace;I++)
8265 {
8266 velocity[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8267 ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8268 k*nSpace+I]
8269 -=
8270 numDiffAvg
8271 *
8272 grad_u[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8273 ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8274 k*nSpace+I];
8275
8276 }/*I*/
8277 }/*ebN*/
8278}
8279
8280
8284void updateGlobalExteriorElementBoundaryShockCapturingVelocity(int nExteriorElementBoundaries_global,
8285 int nQuadraturePoints_elementBoundary,
8286 int nSpace,
8287 int* exteriorElementBoundaries,
8288 int* elementBoundaryElements,
8289 int* elementBoundaryLocalElementBoundaries,
8290 double* numDiff,
8291 double* grad_u,
8292 double* velocity)
8293{
8294 int ebNE,k,I;
8295 double numDiffAvg;
8296 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
8297 {
8298 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8299 for(I=0;I<nSpace;I++)
8300 {
8301 numDiffAvg = numDiff[ebNE*nQuadraturePoints_elementBoundary+k];
8302 velocity[ebNE*nQuadraturePoints_elementBoundary*nSpace+
8303 k*nSpace+I]
8304 -=
8305 numDiffAvg
8306 *
8307 grad_u[ebNE*nQuadraturePoints_elementBoundary*nSpace+
8308 k*nSpace+I];
8309
8310 }/*I*/
8311 }/*ebN*/
8312}
8313void calculateInteriorElementBoundaryAverageVelocity(int nInteriorElementBoundaries_global,
8314 int nElementBoundaries_element,
8315 int nQuadraturePoints_elementBoundary,
8316 int nSpace,
8317 int* interiorElementBoundaries,
8318 int* elementBoundaryElements,
8319 int* elementBoundaryLocalElementBoundaries,
8320 double* v,
8321 double* vAverage)
8322{
8323 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k,I;
8324 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
8325 {
8326 ebN = interiorElementBoundaries[ebNI];
8327 left_eN_global = elementBoundaryElements[ebN*2+0];
8328 right_eN_global = elementBoundaryElements[ebN*2+1];
8329 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
8330 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
8331 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8332 for (I=0;I<nSpace;I++)
8333 vAverage[ebN*nQuadraturePoints_elementBoundary*nSpace+
8334 k*nSpace+
8335 I]
8336 = 0.5*(v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8337 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8338 k*nSpace+
8339 I]
8340 +
8341 v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8342 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8343 k*nSpace+
8344 I]);
8345 }
8346}
8347
8348void calculateExteriorElementBoundaryAverageVelocity(int nExteriorElementBoundaries_global,
8349 int nElementBoundaries_element,
8350 int nQuadraturePoints_elementBoundary,
8351 int nSpace,
8352 int* exteriorElementBoundaries,
8353 int* elementBoundaryElements,
8354 int* elementBoundaryLocalElementBoundaries,
8355 double* v,
8356 double* vAverage)
8357{
8358 int ebNE,ebN,left_eN_global,left_ebN_element,k,I;
8359 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
8360 {
8361 ebN = exteriorElementBoundaries[ebNE];
8362 left_eN_global = elementBoundaryElements[ebN*2+0];
8363 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
8364 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8365 for (I=0;I<nSpace;I++)
8366 {
8367
8368 vAverage[ebN*nQuadraturePoints_elementBoundary*nSpace+
8369 k*nSpace+
8370 I]
8371 = v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8372 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8373 k*nSpace+
8374 I];
8375 /*mwf debug
8376 printf("vfem.ext.vavg ebN=%d eN=%d ebN_element=%d k=%d v[%d]= %g \n",ebN,left_eN_global,
8377 left_ebN_element,k,I,
8378 v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8379 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8380 k*nSpace+
8381 I]);
8382 */
8383 }
8384 }
8385}
8386
8387
8388
8389
8390void calculateConservationResidualDG(int nElements_global,
8391 int nDOF_test_element,
8392 double * elementResidual,
8393 double * conservationResidual)
8394{
8395 int eN,i;
8396 for (eN = 0; eN < nElements_global; eN++)
8397 {
8398 conservationResidual[eN] = 0.0;
8399 for (i = 0; i < nDOF_test_element; i++)
8400 conservationResidual[eN] += elementResidual[eN*nDOF_test_element + i];
8401 }
8402}
8403
8411void calculateConservationResidual(int nElements_global,
8412 int nDOF_test_element,
8413 int nElementBoundaries_element,
8414 int nQuadraturePoints_elementBoundary,
8415 int nSpace,
8416 double * n,
8417 double * dS_u,
8418 double * elementResidual,
8419 double * velocity,
8420 double * conservationResidual)
8421{
8422 int eN,ebN,i,k,I;
8423 double boundaryFlux;
8424 for (eN = 0; eN < nElements_global; eN++)
8425 {
8426 conservationResidual[eN] = 0.0;
8427
8428 for (i = 0; i < nDOF_test_element; i++)
8429 conservationResidual[eN] += elementResidual[eN*nDOF_test_element + i];
8430
8431 boundaryFlux = 0.0;
8432 for (ebN = 0; ebN < nElementBoundaries_element; ebN++)
8433 {
8434 for (k = 0; k < nQuadraturePoints_elementBoundary; k++)
8435 {
8436 for (I = 0; I < nSpace; I++)
8437 {
8438 boundaryFlux +=
8439 n[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace +
8440 ebN*nQuadraturePoints_elementBoundary*nSpace +
8441 k*nSpace +
8442 I]
8443 *
8444 velocity[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace +
8445 ebN*nQuadraturePoints_elementBoundary*nSpace +
8446 k*nSpace +
8447 I]
8448 *
8449 dS_u[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary +
8450 ebN*nQuadraturePoints_elementBoundary +
8451 k];
8452 }/*I*/
8453 }/*k*/
8454 }/*ebN*/
8455 /*mwf debug
8456 printf("calcConsRes eN=%d accum= %g boundaryFlux= %g diff=%g \n",eN,conservationResidual[eN],boundaryFlux,
8457 conservationResidual[eN] -boundaryFlux);
8458
8459 */
8460 conservationResidual[eN] += boundaryFlux;
8461
8462 }/*eN*/
8463}
8464/* void calculateConservationResidualGlobalBoundaries(int nElements_global, */
8465/* int nInteriorElementBoundaries_global, */
8466/* int nExteriorElementBoundaries_global, */
8467/* int nElementBoundaries_element, */
8468/* int nQuadraturePoints_elementBoundary, */
8469/* int nNodes_element, */
8470/* int nSpace, */
8471/* int* interiorElementBoundaries, */
8472/* int* exteriorElementBoundaries, */
8473/* int* elementBoundaryElements, */
8474/* int* elementBoundaryLocalElementBoundaries, */
8475/* double* dS, */
8476/* double* normal, */
8477/* double* elementResidual, */
8478/* double* velocity, */
8479/* double* conservationResidual) */
8480/* { */
8481/* int ebNI,ebNE,ebN,eN,nN,left_eN,right_eN,ebN_element,left_ebN_element,right_ebN_element,k,I; */
8482/* register double flux,ds; */
8483/* /\* /\\*mwf debug*\\/ *\/ */
8484/* /\* register double signDebug = -1.0; *\/ */
8485/* /\*first loop through and get element residual sums*\/ */
8486/* for (eN = 0; eN < nElements_global; eN++) */
8487/* { */
8488/* for (nN = 0; nN < nNodes_element; nN++) */
8489/* { */
8490/* conservationResidual[eN] += elementResidual[eN*nNodes_element + nN]; */
8491/* } */
8492/* } */
8493/* /\*now loop through element boundaries and update element sums*\/ */
8494/* /\*interior*\/ */
8495/* for (ebNI = 0; ebNI < nInteriorElementBoundaries_global; ebNI++) */
8496/* { */
8497/* ebN = interiorElementBoundaries[ebNI]; */
8498/* left_eN = elementBoundaryElements[ebN*2+0]; */
8499/* right_eN = elementBoundaryElements[ebN*2+1]; */
8500/* left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0]; */
8501/* right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1]; */
8502
8503/* flux = 0.0; */
8504/* for(k=0;k<nQuadraturePoints_elementBoundary;k++) */
8505/* { */
8506/* ds = dS[left_eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary+ */
8507/* left_ebN_element*nQuadraturePoints_elementBoundary+ */
8508/* k]; */
8509/* for (I = 0; I < nSpace; I++) */
8510/* { */
8511/* flux+= velocity[ebN*nQuadraturePoints_elementBoundary*nSpace+ */
8512/* k*nSpace+ */
8513/* I] */
8514/* * */
8515/* normal[ebN*nQuadraturePoints_elementBoundary*nSpace+ */
8516/* k*nSpace+ */
8517/* I] */
8518/* * */
8519/* ds; */
8520/* } */
8521/* }/\*k*\/ */
8522/* conservationResidual[left_eN] += flux; */
8523/* conservationResidual[right_eN]-= flux; */
8524
8525/* }/\*ebNI*\/ */
8526/* /\*exterior*\/ */
8527/* for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++) */
8528/* { */
8529/* ebN = exteriorElementBoundaries[ebNE]; */
8530/* eN = elementBoundaryElements[ebN*2+0]; */
8531/* ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0]; */
8532/* flux = 0.0; */
8533/* for(k=0;k<nQuadraturePoints_elementBoundary;k++) */
8534/* { */
8535/* ds = dS[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary+ */
8536/* ebN_element*nQuadraturePoints_elementBoundary+ */
8537/* k]; */
8538/* for (I = 0; I < nSpace; I++) */
8539/* { */
8540/* flux+= velocity[ebN*nQuadraturePoints_elementBoundary*nSpace+ */
8541/* k*nSpace+ */
8542/* I] */
8543/* * */
8544/* normal[ebN*nQuadraturePoints_elementBoundary*nSpace+ */
8545/* k*nSpace+ */
8546/* I] */
8547/* * */
8548/* ds; */
8549/* } */
8550/* }/\*k*\/ */
8551/* conservationResidual[eN] += flux; */
8552/* }/\*ebNE*\/ */
8553/* } */
8554
8555
8556void copyGlobalElementBoundaryVelocityToElementBoundary(int nElements_global,
8557 int nInteriorElementBoundaries_global,
8558 int nExteriorElementBoundaries_global,
8559 int nElementBoundaries_global,
8560 int nElementBoundaries_element,
8561 int nQuadraturePoints_elementBoundary,
8562 int nSpace,
8563 int * interiorElementBoundaries,
8564 int * exteriorElementBoundaries,
8565 int * elementBoundaryElementsArray,
8566 int * elementBoundaryLocalElementBoundariesArray,
8567 double * velocityBoundary_global,
8568 double * velocityBoundary_element)
8569{
8570 int ebN,ebNE,ebNI,eN_left,eN_right,ebN_left_element,ebN_right_element,k,I;
8571
8572 for (ebNI = 0; ebNI < nInteriorElementBoundaries_global; ebNI++)
8573 {
8574 ebN = interiorElementBoundaries[ebNI];
8575 eN_left = elementBoundaryElementsArray[ebN*2 + 0];
8576 eN_right= elementBoundaryElementsArray[ebN*2 + 1];
8577 ebN_left_element = elementBoundaryLocalElementBoundariesArray[ebN*2 + 0];
8578 ebN_right_element= elementBoundaryLocalElementBoundariesArray[ebN*2 + 1];
8579
8580 for (k = 0; k < nQuadraturePoints_elementBoundary; k++)
8581 for (I = 0; I < nSpace; I++)
8582 {
8583 velocityBoundary_element[eN_left*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace +
8584 ebN_left_element*nQuadraturePoints_elementBoundary*nSpace +
8585 k*nSpace +
8586 I] =
8587 velocityBoundary_global[ebN*nQuadraturePoints_elementBoundary*nSpace +
8588 k*nSpace +
8589 I];
8590 velocityBoundary_element[eN_right*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace +
8591 ebN_right_element*nQuadraturePoints_elementBoundary*nSpace +
8592 k*nSpace +
8593 I] =
8594 velocityBoundary_global[ebN*nQuadraturePoints_elementBoundary*nSpace +
8595 k*nSpace +
8596 I];
8597
8598 }
8599 }/*ebNI*/
8600
8601 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
8602 {
8603 ebN = exteriorElementBoundaries[ebNE];
8604 eN_left = elementBoundaryElementsArray[ebN*2 + 0];
8605 ebN_left_element = elementBoundaryLocalElementBoundariesArray[ebN*2 + 0];
8606
8607 for (k = 0; k < nQuadraturePoints_elementBoundary; k++)
8608 for (I = 0; I < nSpace; I++)
8609 {
8610 velocityBoundary_element[eN_left*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace +
8611 ebN_left_element*nQuadraturePoints_elementBoundary*nSpace +
8612 k*nSpace +
8613 I] =
8614 velocityBoundary_global[ebN*nQuadraturePoints_elementBoundary*nSpace +
8615 k*nSpace +
8616 I];
8617 }
8618 }/*ebNE*/
8619}
8620void loadBoundaryFluxIntoGlobalElementBoundaryVelocity(int nExteriorElementBoundaries_global,
8621 int nQuadraturePoints_elementBoundary,
8622 int nSpace,
8623 int* exteriorElementBoundaries,
8624 int* fluxElementBoundaries,
8625 double* normal,
8626 double* flux,
8627 double updateCoef,
8628 double* velocity)
8629{
8630 int ebNE,ebN,I,k;
8631 double val;
8632 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
8633 {
8634 ebN = exteriorElementBoundaries[ebNE];
8635 if (fluxElementBoundaries[ebNE] > 0)
8636 {
8637 for (k = 0; k < nQuadraturePoints_elementBoundary; k++)
8638 {
8639 for (I=0; I < nSpace; I++)
8640 {
8641 val = velocity[ebN*nQuadraturePoints_elementBoundary*nSpace +
8642 k*nSpace + I];
8643 velocity[ebN*nQuadraturePoints_elementBoundary*nSpace +
8644 k*nSpace + I]
8645 = val*updateCoef +
8646 flux[ebN*nQuadraturePoints_elementBoundary +
8647 k]
8648 *
8649 normal[ebN*nQuadraturePoints_elementBoundary*nSpace +
8650 k*nSpace + I];
8651 /*mwf debug
8652 printf("load fluxes ebNE=%d ebN=%d k=%d I=%d val=%g flux=%g n=%g vel=%g\n",
8653 ebNE,ebN,k,I,val,
8654 flux[ebN*nQuadraturePoints_elementBoundary+k],
8655 normal[ebN*nQuadraturePoints_elementBoundary*nSpace + k*nSpace + I],
8656 velocity[ebN*nQuadraturePoints_elementBoundary*nSpace +
8657 k*nSpace + I]);
8658 */
8659 }
8660 }
8661 }
8662 }
8663
8664}
8665
8666#define TR_ALPHA 0.5
8667#define TR_ALPHA_EXT 1.0
8668
8672void calculateInteriorNumericalTrace_Potential(int nInteriorElementBoundaries_global,
8673 int nElementBoundaries_element,
8674 int nQuadraturePoints_elementBoundary,
8675 int* interiorElementBoundaries,
8676 int* elementBoundaryElements,
8677 int* elementBoundaryLocalElementBoundaries,
8678 double* phi,
8679 double* dphi,
8680 double* phi_trace,
8681 double* dphi_trace_left,
8682 double* dphi_trace_right)
8683{
8684 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,k;
8685 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
8686 {
8687 ebN = interiorElementBoundaries[ebNI];
8688 left_eN_global = elementBoundaryElements[ebN*2+0];
8689 right_eN_global = elementBoundaryElements[ebN*2+1];
8690 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
8691 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
8692 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8693 {
8694 phi_trace[ebN*nQuadraturePoints_elementBoundary+
8695 k]
8696 = (1.0-TR_ALPHA)*phi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
8697 left_ebN_element*nQuadraturePoints_elementBoundary+
8698 k]
8699 +
8700 TR_ALPHA*phi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
8701 right_ebN_element*nQuadraturePoints_elementBoundary+
8702 k];
8703 dphi_trace_left[ebN*nQuadraturePoints_elementBoundary+
8704 k]
8705 = (1.0-TR_ALPHA)*
8706 dphi[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
8707 left_ebN_element*nQuadraturePoints_elementBoundary+
8708 k];
8709 dphi_trace_right[ebN*nQuadraturePoints_elementBoundary+
8710 k]
8711 = TR_ALPHA*dphi[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
8712 right_ebN_element*nQuadraturePoints_elementBoundary+
8713 k];
8714 }
8715 }
8716}
8717
8721void calculateExteriorNumericalTrace_Potential(int* isDOFBoundary,
8722 int nExteriorElementBoundaries_global,
8723 int nElementBoundaries_element,
8724 int nQuadraturePoints_elementBoundary,
8725 int* exteriorElementBoundaries,
8726 int* elementBoundaryElements,
8727 int* elementBoundaryLocalElementBoundaries,
8728 double* phi_bc,
8729 double* phi,
8730 double* dphi,
8731 double* phi_trace,
8732 double* dphi_trace_left)
8733{
8734 int ebNE,ebN,eN_global,ebN_element,k;
8735 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
8736 {
8737 ebN = exteriorElementBoundaries[ebNE];
8738 eN_global = elementBoundaryElements[ebN*2+0];
8739 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
8740 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8741 {
8742 phi_trace[ebN*nQuadraturePoints_elementBoundary+
8743 k]
8744 = (1.0-TR_ALPHA_EXT)*phi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
8745 ebN_element*nQuadraturePoints_elementBoundary+
8746 k]
8747 +
8748 TR_ALPHA_EXT*phi_bc[ebNE*nQuadraturePoints_elementBoundary+
8749 k];
8750 if(isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k] == 1)
8751 dphi_trace_left[ebN*nQuadraturePoints_elementBoundary+
8752 k]
8753 = (1.0-TR_ALPHA_EXT)*dphi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
8754 ebN_element*nQuadraturePoints_elementBoundary+
8755 k];
8756 else
8757 dphi_trace_left[ebN*nQuadraturePoints_elementBoundary+
8758 k]
8759 = dphi[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
8760 ebN_element*nQuadraturePoints_elementBoundary+
8761 k];
8762 }
8763 }
8764}
8765
8768void updateInteriorElementBoundary_MixedForm_weak(int nInteriorElementBoundaries_global,
8769 int nElementBoundaries_element,
8770 int nQuadraturePoints_elementBoundary,
8771 int nDOF_test_element,
8772 int nSpace,
8773 int* interiorElementBoundaries,
8774 int* elementBoundaryElements,
8775 int* elementBoundaryLocalElementBoundaries,
8776 double* n,
8777 double* phi_trace,
8778 double* w_dS,
8779 double* b)
8780{
8781 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,i,k,I;
8782 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
8783 {
8784 ebN = interiorElementBoundaries[ebNI];
8785 left_eN_global = elementBoundaryElements[ebN*2+0];
8786 right_eN_global = elementBoundaryElements[ebN*2+1];
8787 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
8788 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
8789 for(i=0;i<nDOF_test_element;i++)
8790 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8791 for(I=0;I<nSpace;I++)
8792 {
8793 b[left_eN_global*nDOF_test_element*nSpace+
8794 I*nDOF_test_element+
8795 i]
8796 -=
8797 phi_trace[ebN*nQuadraturePoints_elementBoundary+
8798 k]
8799 *
8800 n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8801 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8802 k*nSpace+
8803 I]
8804 *
8805 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8806 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8807 k*nDOF_test_element+
8808 i];
8809 b[right_eN_global*nDOF_test_element*nSpace+
8810 I*nDOF_test_element+
8811 i]
8812 -=
8813 phi_trace[ebN*nQuadraturePoints_elementBoundary+
8814 k]
8815 *
8816 n[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8817 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8818 k*nSpace+
8819 I]
8820 *
8821 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8822 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8823 k*nDOF_test_element+
8824 i];
8825 }
8826 }
8827}
8828
8832void updateInteriorElementBoundary_MixedForm_weakJacobian(int nInteriorElementBoundaries_global,
8833 int nElementBoundaries_element,
8834 int nQuadraturePoints_elementBoundary,
8835 int nDOF_test_element,
8836 int nSpace,
8837 int* interiorElementBoundaries,
8838 int* elementBoundaryElements,
8839 int* elementBoundaryLocalElementBoundaries,
8840 double* n,
8841 double* dphi_trace_left,
8842 double* dphi_trace_right,
8843 double* v,
8844 double* w_dS,
8845 double* db,
8846 double* db_eb)
8847{
8848 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,i,j,k,I,nDOF_test_element2=nDOF_test_element*nDOF_test_element;
8849 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
8850 {
8851 ebN = interiorElementBoundaries[ebNI];
8852 left_eN_global = elementBoundaryElements[ebN*2+0];
8853 right_eN_global = elementBoundaryElements[ebN*2+1];
8854 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
8855 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
8856 for(i=0;i<nDOF_test_element;i++)
8857 for(j=0;j<nDOF_test_element;j++)
8858 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8859 for(I=0;I<nSpace;I++)
8860 {
8861 db[left_eN_global*nDOF_test_element2*nSpace+
8862 I*nDOF_test_element2+
8863 i*nDOF_test_element+
8864 j]
8865 -=
8866 dphi_trace_left[ebN*nQuadraturePoints_elementBoundary+
8867 k]*
8868
8869 v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8870 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8871 k*nDOF_test_element+
8872 j]
8873 *
8874 n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8875 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8876 k*nSpace+
8877 I]
8878 *
8879 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8880 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8881 k*nDOF_test_element+
8882 i];
8883 db_eb[left_eN_global*nElementBoundaries_element*nDOF_test_element2*nSpace+
8884 left_ebN_element*nDOF_test_element2*nSpace+
8885 I*nDOF_test_element2+
8886 i*nDOF_test_element+
8887 j]
8888 -=
8889 dphi_trace_right[ebN*nQuadraturePoints_elementBoundary+
8890 k]
8891 *
8892 v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8893 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8894 k*nDOF_test_element+
8895 j]
8896 *
8897 n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8898 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8899 k*nSpace+
8900 I]
8901 *
8902 w_dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8903 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8904 k*nDOF_test_element+
8905 i];
8906 db_eb[right_eN_global*nElementBoundaries_element*nDOF_test_element2*nSpace+
8907 right_ebN_element*nDOF_test_element2*nSpace+
8908 I*nDOF_test_element2+
8909 i*nDOF_test_element+
8910 j]
8911 -=
8912 dphi_trace_left[ebN*nQuadraturePoints_elementBoundary+
8913 k]*
8914
8915 v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8916 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8917 k*nDOF_test_element+
8918 j]
8919 *
8920 n[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8921 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8922 k*nSpace+
8923 I]
8924 *
8925 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8926 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8927 k*nDOF_test_element+
8928 i];
8929 db[right_eN_global*nDOF_test_element2*nSpace+
8930 I*nDOF_test_element2+
8931 i*nDOF_test_element+
8932 j]
8933 -=
8934 dphi_trace_right[ebN*nQuadraturePoints_elementBoundary+
8935 k]
8936 *
8937 v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8938 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8939 k*nDOF_test_element+
8940 j]
8941 *
8942 n[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8943 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8944 k*nSpace+
8945 I]
8946 *
8947 w_dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8948 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8949 k*nDOF_test_element+
8950 i];
8951 }
8952 }
8953}
8954
8958void updateExteriorElementBoundary_MixedForm_weak(int nExteriorElementBoundaries_global,
8959 int nElementBoundaries_element,
8960 int nQuadraturePoints_elementBoundary,
8961 int nDOF_test_element,
8962 int nSpace,
8963 int* exteriorElementBoundaries,
8964 int* elementBoundaryElements,
8965 int* elementBoundaryLocalElementBoundaries,
8966 double* n,
8967 double* phi_trace,
8968 double* w_dS,
8969 double* b)
8970{
8971 int ebNE,ebN,eN_global,ebN_element,i,k,I;
8972 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
8973 {
8974 ebN = exteriorElementBoundaries[ebNE];
8975 eN_global = elementBoundaryElements[ebN*2+0];
8976 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
8977 for(i=0;i<nDOF_test_element;i++)
8978 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
8979 for (I=0;I<nSpace;I++)
8980 b[eN_global*nDOF_test_element*nSpace+
8981 I*nDOF_test_element+
8982 i]
8983 -=
8984 phi_trace[ebN*nQuadraturePoints_elementBoundary+
8985 k]
8986 *
8987 n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
8988 ebN_element*nQuadraturePoints_elementBoundary*nSpace+
8989 k*nSpace+
8990 I]
8991 *
8992 w_dS[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8993 ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
8994 k*nDOF_test_element+
8995 i];
8996 }
8997}
8998
9002void updateExteriorElementBoundary_MixedForm_weakJacobian(int nExteriorElementBoundaries_global,
9003 int nElementBoundaries_element,
9004 int nQuadraturePoints_elementBoundary,
9005 int nDOF_test_element,
9006 int nSpace,
9007 int* exteriorElementBoundaries,
9008 int* elementBoundaryElements,
9009 int* elementBoundaryLocalElementBoundaries,
9010 double* n,
9011 double* dphi_trace_left,
9012 double* v,
9013 double* w_dS,
9014 double* db,
9015 double* db_eb)
9016{
9017 int ebNE,ebN,eN_global,ebN_element,i,j,k,I,nDOF_test_element2=nDOF_test_element*nDOF_test_element;
9018 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
9019 {
9020 ebN = exteriorElementBoundaries[ebNE];
9021 eN_global = elementBoundaryElements[ebN*2+0];
9022 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
9023 for(i=0;i<nDOF_test_element;i++)
9024 for(j=0;j<nDOF_test_element;j++)
9025 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
9026 for(I=0;I<nSpace;I++)
9027 {
9028 db[eN_global*nDOF_test_element2*nSpace+
9029 I*nDOF_test_element2+
9030 i*nDOF_test_element+
9031 j]
9032 -=
9033 dphi_trace_left[ebN*nQuadraturePoints_elementBoundary+
9034 k]
9035 *
9036 v[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
9037 ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
9038 k*nDOF_test_element+
9039 j]
9040 *
9041 n[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
9042 ebN_element*nQuadraturePoints_elementBoundary*nSpace+
9043 k*nSpace+
9044 I]
9045 *
9046 w_dS[eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
9047 ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element+
9048 k*nDOF_test_element+
9049 i];
9050 }
9051 }
9052}
9053
9054void updatePotential_MixedForm_weak(int nElements_global,
9055 int nQuadraturePoints_element,
9056 int nDOF_test_element,
9057 int nSpace,
9058 double* phi,
9059 double* grad_w_dV,
9060 double* b)
9061{
9062 int eN,i,k,I;
9063 for(eN=0;eN<nElements_global;eN++)
9064 for (I=0;I<nSpace;I++)
9065 for (i=0;i<nDOF_test_element;i++)
9066 for (k=0;k<nQuadraturePoints_element;k++)
9067 b[eN*nDOF_test_element*nSpace +
9068 I*nDOF_test_element+
9069 i]
9070 +=
9071 phi[eN*nQuadraturePoints_element+
9072 k]
9073 *
9074 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
9075 k*nDOF_test_element*nSpace +
9076 i*nSpace +
9077 I];
9078}
9079
9080void updatePotential_MixedForm_weak_gwvd(int nElements_global,
9081 int nQuadraturePoints_element,
9082 int nDOF_test_element,
9083 int nSpace,
9084 double epsilon,
9085 double* phi,
9086 double* w_dV,
9087 double* grad_w_dV,
9088 double* b,
9089 double* mf)
9090{
9091 int eN,i,k,I;
9092 for(eN=0;eN<nElements_global;eN++)
9093 for (I=0;I<nSpace;I++)
9094 for (i=0;i<nDOF_test_element;i++)
9095 for (k=0;k<nQuadraturePoints_element;k++)
9096 {
9097 b[eN*nDOF_test_element*nSpace +
9098 I*nDOF_test_element+i]
9099 +=
9100 phi[eN*nQuadraturePoints_element+
9101 k]
9102 *
9103 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
9104 k*nDOF_test_element*nSpace +
9105 i*nSpace +
9106 I];
9107 if (I==nSpace-1)
9108 {
9109 b[eN*nDOF_test_element*nSpace +
9110 I*nDOF_test_element+i]
9111 -= epsilon*mf[eN*nQuadraturePoints_element+
9112 k ]*w_dV[eN*nQuadraturePoints_element*nDOF_test_element+ k*nDOF_test_element + i ];
9113 }
9114 }
9115}
9116
9117void updatePotential_MixedForm_weakJacobian(int nElements_global,
9118 int nQuadraturePoints_element,
9119 int nDOF_test_element,
9120 int nSpace,
9121 double* dphi,
9122 double* v,
9123 double* grad_w_dV,
9124 double* db)
9125{
9126 int eN,i,j,k,I,nDOF_test_element2=nDOF_test_element*nDOF_test_element;
9127 for(eN=0;eN<nElements_global;eN++)
9128 for (I=0;I<nSpace;I++)
9129 for (i=0;i<nDOF_test_element;i++)
9130 for (j=0;j<nDOF_test_element;j++)
9131 for (k=0;k<nQuadraturePoints_element;k++)
9132 db[eN*nDOF_test_element2*nSpace +
9133 I*nDOF_test_element2+
9134 i*nDOF_test_element+
9135 j]
9136 +=
9137 dphi[eN*nQuadraturePoints_element+
9138 k]
9139 *
9140 v[eN*nQuadraturePoints_element*nDOF_test_element+
9141 k*nDOF_test_element+
9142 j]
9143 *
9144 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
9145 k*nDOF_test_element*nSpace +
9146 i*nSpace +
9147 I];
9148}
9149
9150void calculateVelocityQuadrature_MixedForm(int nElements_global,
9151 int nElementBoundaries_element,
9152 int nElementBoundaryQuadraturePoints_elementBoundary,
9153 int nDOF_element,
9154 int nSpace,
9155 int nQuadraturePoints_element,
9156 double* A_inv,
9157 double* b,
9158 double* v,
9159 double* V,
9160 double* qv,
9161 double* qV)
9162{
9163 int eN,ebN,k,i,j,I,nDOF_element2=nDOF_element*nDOF_element;
9164 double V_dof[nSpace][nDOF_element];
9165 memset(V,0,sizeof(double)*
9166 nElements_global*
9167 nElementBoundaries_element*
9168 nElementBoundaryQuadraturePoints_elementBoundary*
9169 nSpace);
9170 memset(qV,0,sizeof(double)*
9171 nElements_global*
9172 nQuadraturePoints_element*
9173 nSpace);
9174 for(eN=0;eN<nElements_global;eN++)
9175 {
9176 /* velocity DOF */
9177 for(I=0;I<nSpace;I++)
9178 for(i=0;i<nDOF_element;i++)
9179 {
9180 V_dof[I][i]=0.0;
9181 for(j=0;j<nDOF_element;j++)
9182 V_dof[I][i]
9183 +=
9184 A_inv[eN*nDOF_element2+
9185 i*nDOF_element+
9186 j]
9187 *
9188 b[eN*nSpace*nDOF_element+
9189 I*nDOF_element+
9190 j];
9191 }
9192 /* evaluate at element quadrature */
9193 for(k=0;k<nQuadraturePoints_element;k++)
9194 for(j=0;j<nDOF_element;j++)
9195 for(I=0;I<nSpace;I++)
9196 qV[eN*nQuadraturePoints_element*nSpace+
9197 k*nSpace+
9198 I]
9199 +=
9200 V_dof[I][j]
9201 *
9202 qv[eN*nQuadraturePoints_element*nDOF_element+
9203 k*nDOF_element+
9204 j];
9205 /* evaluate at element boundary quadrature*/
9206 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
9207 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
9208 for(j=0;j<nDOF_element;j++)
9209 for(I=0;I<nSpace;I++)
9210 V[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace+
9211 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace+
9212 k*nSpace+
9213 I]
9214 +=
9215 V_dof[I][j]
9216 *
9217 v[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9218 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9219 k*nDOF_element+
9220 j];
9221 }
9222}
9223
9224void calculateVelocityQuadrature_MixedForm2(int nElements_global,
9225 int nElementBoundaries_element,
9226 int nElementBoundaryQuadraturePoints_elementBoundary,
9227 int nDOF_element,
9228 int nSpace,
9229 int nQuadraturePoints_element,
9230 double* qa,
9231 double* qw_dV,
9232 double* b,
9233 double* v,
9234 double* V,
9235 double* qv,
9236 double* qV)
9237{
9238 int eN,ebN,k,i,j,I,nDOF_element2=nDOF_element*nDOF_element,nSpace2=nSpace*nSpace;
9239 PROTEUS_LAPACK_INTEGER ipiv[nDOF_element],lwork=((PROTEUS_LAPACK_INTEGER)nDOF_element),dim=((PROTEUS_LAPACK_INTEGER)nDOF_element),info=0;
9240 double work[nDOF_element],A_inv[nDOF_element2];
9241 double V_dof[nSpace][nDOF_element];
9242 memset(V,0,sizeof(double)*
9243 nElements_global*
9244 nElementBoundaries_element*
9245 nElementBoundaryQuadraturePoints_elementBoundary*
9246 nSpace);
9247 memset(qV,0,sizeof(double)*
9248 nElements_global*
9249 nQuadraturePoints_element*
9250 nSpace);
9251 for(eN=0;eN<nElements_global;eN++)
9252 {
9253 for(I=0;I<nSpace;I++)
9254 {
9255 memset(A_inv,0,sizeof(double)*nDOF_element2);
9256 for(i=0;i<nDOF_element;i++)
9257 for(j=0;j<nDOF_element;j++)
9258 {
9259 for(k=0;k<nQuadraturePoints_element;k++)
9260 {
9261 //cek hack do diagonal only for now
9262 A_inv[i*nDOF_element+j] += (1.0/qa[eN*nQuadraturePoints_element*nSpace2+
9263 k*nSpace2+
9264 I*nSpace+
9265 I])
9266 *qv[eN*nQuadraturePoints_element*nDOF_element+
9267 k*nDOF_element+
9268 j]
9269 *
9270 qw_dV[eN*nQuadraturePoints_element*nDOF_element+
9271 k*nDOF_element+
9272 i];
9273 }
9274 }
9275 info=0;
9276 dgetrf_(&dim,&dim,A_inv,&dim,ipiv,&info);
9277 dgetri_(&dim,A_inv,&dim,ipiv,work,&lwork,&info);
9278
9279 /* velocity DOF */
9280 for(i=0;i<nDOF_element;i++)
9281 {
9282 V_dof[I][i]=0.0;
9283 for(j=0;j<nDOF_element;j++)
9284 V_dof[I][i]
9285 +=
9286 A_inv[i*nDOF_element+
9287 j]
9288 *
9289 b[eN*nSpace*nDOF_element+
9290 I*nDOF_element+
9291 j];
9292 }
9293 }
9294 /* evaluate at element quadrature */
9295 for(k=0;k<nQuadraturePoints_element;k++)
9296 for(j=0;j<nDOF_element;j++)
9297 for(I=0;I<nSpace;I++)
9298 qV[eN*nQuadraturePoints_element*nSpace+
9299 k*nSpace+
9300 I]
9301 +=
9302 V_dof[I][j]
9303 *
9304 qv[eN*nQuadraturePoints_element*nDOF_element+
9305 k*nDOF_element+
9306 j];
9307 /* evaluate at element boundary quadrature*/
9308 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
9309 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
9310 for(j=0;j<nDOF_element;j++)
9311 for(I=0;I<nSpace;I++)
9312 V[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace+
9313 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace+
9314 k*nSpace+
9315 I]
9316 +=
9317 V_dof[I][j]
9318 *
9319 v[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9320 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9321 k*nDOF_element+
9322 j];
9323 }
9324}
9325
9326void calculateVelocityQuadrature_MixedForm2_sd(int nElements_global,
9327 int nElementBoundaries_element,
9328 int nElementBoundaryQuadraturePoints_elementBoundary,
9329 int nDOF_element,
9330 int nSpace,
9331 int nQuadraturePoints_element,
9332 const int * rowptr,
9333 const int * colind,
9334 double* qa,
9335 double* qw_dV,
9336 double* b,
9337 double* v,
9338 double* V,
9339 double* qv,
9340 double* qV)
9341{
9342 int eN,ebN,k,i,j,I,nDOF_element2=nDOF_element*nDOF_element,nSpace2=nSpace*nSpace;
9343 int m,nnz=rowptr[nSpace];
9344 PROTEUS_LAPACK_INTEGER ipiv[nDOF_element],lwork=((PROTEUS_LAPACK_INTEGER)nDOF_element),dim=((PROTEUS_LAPACK_INTEGER)nDOF_element),info=0;
9345 double work[nDOF_element],A_inv[nDOF_element2];
9346 double V_dof[nSpace][nDOF_element];
9347 memset(V,0,sizeof(double)*
9348 nElements_global*
9349 nElementBoundaries_element*
9350 nElementBoundaryQuadraturePoints_elementBoundary*
9351 nSpace);
9352 memset(qV,0,sizeof(double)*
9353 nElements_global*
9354 nQuadraturePoints_element*
9355 nSpace);
9356 for(eN=0;eN<nElements_global;eN++)
9357 {
9358 for(I=0;I<nSpace;I++)
9359 {
9360 memset(A_inv,0,sizeof(double)*nDOF_element2);
9361 for(i=0;i<nDOF_element;i++)
9362 for(j=0;j<nDOF_element;j++)
9363 {
9364 for(k=0;k<nQuadraturePoints_element;k++)
9365 {
9366 //cek hack do diagonal only for now
9367 for (m=rowptr[I]; m < rowptr[I+1];m++)
9368 if (colind[m] == I)
9369 {
9370 /*mwf debug
9371 printf("mixedform2 eN=%d I=%d m=%d colind[m]=%d a=%g \n",
9372 eN,I,m,colind[m],qa[eN*nQuadraturePoints_element*nnz+
9373 k*nnz + m]);
9374 */
9375 A_inv[i*nDOF_element+j] += (1.0/qa[eN*nQuadraturePoints_element*nnz+
9376 k*nnz + m])
9377 *qv[eN*nQuadraturePoints_element*nDOF_element+
9378 k*nDOF_element+
9379 j]
9380 *
9381 qw_dV[eN*nQuadraturePoints_element*nDOF_element+
9382 k*nDOF_element+
9383 i];
9384 }
9385 }
9386 }
9387 info=0;
9388 dgetrf_(&dim,&dim,A_inv,&dim,ipiv,&info);
9389 dgetri_(&dim,A_inv,&dim,ipiv,work,&lwork,&info);
9390
9391 /* velocity DOF */
9392 for(i=0;i<nDOF_element;i++)
9393 {
9394 V_dof[I][i]=0.0;
9395 for(j=0;j<nDOF_element;j++)
9396 V_dof[I][i]
9397 +=
9398 A_inv[i*nDOF_element+
9399 j]
9400 *
9401 b[eN*nSpace*nDOF_element+
9402 I*nDOF_element+
9403 j];
9404 }
9405 }
9406 /* evaluate at element quadrature */
9407 for(k=0;k<nQuadraturePoints_element;k++)
9408 for(j=0;j<nDOF_element;j++)
9409 for(I=0;I<nSpace;I++)
9410 qV[eN*nQuadraturePoints_element*nSpace+
9411 k*nSpace+
9412 I]
9413 +=
9414 V_dof[I][j]
9415 *
9416 qv[eN*nQuadraturePoints_element*nDOF_element+
9417 k*nDOF_element+
9418 j];
9419 /* evaluate at element boundary quadrature*/
9420 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
9421 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
9422 for(j=0;j<nDOF_element;j++)
9423 for(I=0;I<nSpace;I++)
9424 V[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace+
9425 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace+
9426 k*nSpace+
9427 I]
9428 +=
9429 V_dof[I][j]
9430 *
9431 v[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9432 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9433 k*nDOF_element+
9434 j];
9435 }
9436}
9437
9438/* Velocity Quadrature_MixedForm2 function that saves the velocity degrees of freedom, tjp added*/
9439
9440void calculateVelocityQuadrature_MixedForm2_vdof_sd(int nElements_global,
9441 int nElementBoundaries_element,
9442 int nElementBoundaryQuadraturePoints_elementBoundary,
9443 int nDOF_element,
9444 int nSpace,
9445 int nQuadraturePoints_element,
9446 const int * rowptr,
9447 const int * colind,
9448 double* qa,
9449 double* qw_dV,
9450 double* b,
9451 double* v,
9452 double* V,
9453 double* qv,
9454 double* qV,
9455 double* vel_dofs)
9456{
9457 int eN,ebN,k,i,j,I,nDOF_element2=nDOF_element*nDOF_element,nSpace2=nSpace*nSpace;
9458 int m,nnz=rowptr[nSpace];
9459 PROTEUS_LAPACK_INTEGER ipiv[nDOF_element],lwork=((PROTEUS_LAPACK_INTEGER)nDOF_element),dim=((PROTEUS_LAPACK_INTEGER)nDOF_element),info=0;
9460 double work[nDOF_element],A_inv[nDOF_element2];
9461 double V_dof[nSpace][nDOF_element];
9462 double vel_dofs_temp[nElements_global][nSpace][nDOF_element];
9463 memset(V,0,sizeof(double)*
9464 nElements_global*
9465 nElementBoundaries_element*
9466 nElementBoundaryQuadraturePoints_elementBoundary*
9467 nSpace);
9468 memset(qV,0,sizeof(double)*
9469 nElements_global*
9470 nQuadraturePoints_element*
9471 nSpace);
9472 for(eN=0;eN<nElements_global;eN++)
9473 {
9474 for(I=0;I<nSpace;I++)
9475 {
9476 memset(A_inv,0,sizeof(double)*nDOF_element2);
9477 for(i=0;i<nDOF_element;i++)
9478 for(j=0;j<nDOF_element;j++)
9479 {
9480 for(k=0;k<nQuadraturePoints_element;k++)
9481 {
9482 //cek hack do diagonal only for now
9483 for (m=rowptr[I]; m < rowptr[I+1];m++)
9484 if (colind[m] == I)
9485 {
9486 /*mwf debug
9487 printf("mixedform2 eN=%d I=%d m=%d colind[m]=%d a=%g \n",
9488 eN,I,m,colind[m],qa[eN*nQuadraturePoints_element*nnz+
9489 k*nnz + m]);
9490 */
9491 A_inv[i*nDOF_element+j] += (1.0/qa[eN*nQuadraturePoints_element*nnz+
9492 k*nnz + m])
9493 *qv[eN*nQuadraturePoints_element*nDOF_element+
9494 k*nDOF_element+
9495 j]
9496 *
9497 qw_dV[eN*nQuadraturePoints_element*nDOF_element+
9498 k*nDOF_element+
9499 i];
9500 }
9501 }
9502 }
9503 info=0;
9504 dgetrf_(&dim,&dim,A_inv,&dim,ipiv,&info);
9505 dgetri_(&dim,A_inv,&dim,ipiv,work,&lwork,&info);
9506
9507 /* velocity DOF */
9508 for(i=0;i<nDOF_element;i++)
9509 {
9510 V_dof[I][i]=0.0;
9511 vel_dofs_temp[eN][I][i]=0.0;
9512 for(j=0;j<nDOF_element;j++)
9513 {
9514 V_dof[I][i]
9515 +=
9516 A_inv[i*nDOF_element+
9517 j]
9518 *
9519 b[eN*nSpace*nDOF_element+
9520 I*nDOF_element+
9521 j];
9522 vel_dofs_temp[eN][I][i]
9523 += A_inv[i*nDOF_element+
9524 j]
9525 *
9526 b[eN*nSpace*nDOF_element+
9527 I*nDOF_element+
9528 j];
9529 }
9530 }
9531 }
9532
9533 /* Change the shape of the velocity degrees of freedom */
9534 for(j=0;j<nDOF_element;j++)
9535 for(I=0;I<nSpace;I++)
9536 vel_dofs[eN*nDOF_element*nSpace+
9537 j*nSpace+
9538 I]
9539 =vel_dofs_temp[eN][I][j];
9540
9541 /* evaluate at element quadrature */
9542 for(k=0;k<nQuadraturePoints_element;k++)
9543 for(j=0;j<nDOF_element;j++)
9544 for(I=0;I<nSpace;I++)
9545 qV[eN*nQuadraturePoints_element*nSpace+
9546 k*nSpace+
9547 I]
9548 +=
9549 V_dof[I][j]
9550 *
9551 qv[eN*nQuadraturePoints_element*nDOF_element+
9552 k*nDOF_element+
9553 j];
9554
9555
9556 /* evaluate at element boundary quadrature*/
9557 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
9558 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
9559 for(j=0;j<nDOF_element;j++)
9560 for(I=0;I<nSpace;I++)
9561 V[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nSpace+
9562 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nSpace+
9563 k*nSpace+
9564 I]
9565 +=
9566 V_dof[I][j]
9567 *
9568 v[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9569 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9570 k*nDOF_element+
9571 j];
9572 }
9573}
9574
9575
9576void calculateVelocityQuadrature_MixedForm_Jacobian(int nElements_global,
9577 int nElementBoundaries_element,
9578 int nElementBoundaryQuadraturePoints_elementBoundary,
9579 int nDOF_element,
9580 int nSpace,
9581 int nQuadraturePoints_element,
9582 double* A_inv,
9583 double* db,
9584 double* db_eb,
9585 double* v,
9586 double* DV,
9587 double* DV_eb,
9588 double* qv,
9589 double* qDV,
9590 double* qDV_eb)
9591{
9592 int eN,ebN,ebN_ebN,k,i,j,jj,I,nDOF_element2=nDOF_element*nDOF_element;
9593 double DV_dof[nSpace][nDOF_element][nDOF_element];
9594 memset(DV,0,sizeof(double)*
9595 nElements_global*
9596 nElementBoundaries_element*
9597 nElementBoundaryQuadraturePoints_elementBoundary*
9598 nDOF_element*
9599 nSpace);
9600 memset(DV_eb,0,sizeof(double)*
9601 nElements_global*
9602 nElementBoundaries_element*
9603 nElementBoundaries_element*
9604 nElementBoundaryQuadraturePoints_elementBoundary*
9605 nDOF_element*
9606 nSpace);
9607 memset(qDV,0,sizeof(double)*
9608 nElements_global*
9609 nQuadraturePoints_element*
9610 nDOF_element*
9611 nSpace);
9612 memset(qDV_eb,0,sizeof(double)*
9613 nElements_global*
9614 nElementBoundaries_element*
9615 nQuadraturePoints_element*
9616 nDOF_element*
9617 nSpace);
9618 for(eN=0;eN<nElements_global;eN++)
9619 {
9620 /* get derivatives of velocity DOF w.r.t. u DOF*/
9621 for(I=0;I<nSpace;I++)
9622 for(jj=0;jj<nDOF_element;jj++)
9623 for(i=0;i<nDOF_element;i++)
9624 {
9625 DV_dof[I][i][jj]=0.0;
9626 for(j=0;j<nDOF_element;j++)
9627 DV_dof[I][i][jj]
9628 +=
9629 A_inv[eN*nDOF_element2+
9630 i*nDOF_element+
9631 j]
9632 *
9633 db[eN*nSpace*nDOF_element2+
9634 I*nDOF_element2+
9635 j*nDOF_element+
9636 jj];
9637 }
9638 /* get derivatives of velocity at element quadrature w.r.t u DOF on element*/
9639 for(k=0;k<nQuadraturePoints_element;k++)
9640 for(j=0;j<nDOF_element;j++)
9641 for(jj=0;jj<nDOF_element;jj++)
9642 for(I=0;I<nSpace;I++)
9643 qDV[eN*nQuadraturePoints_element*nDOF_element*nSpace+
9644 k*nDOF_element*nSpace+
9645 jj*nSpace+
9646 I]
9647 +=
9648 DV_dof[I][j][jj]
9649 *
9650 qv[eN*nQuadraturePoints_element*nDOF_element+
9651 k*nDOF_element+
9652 j];
9653 /* get derivatives of velocity at element boundary quadrature w.r.t. u DOF on element */
9654 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
9655 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
9656 for(j=0;j<nDOF_element;j++)
9657 for(jj=0;jj<nDOF_element;jj++)
9658 for(I=0;I<nSpace;I++)
9659 DV[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
9660 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
9661 k*nDOF_element*nSpace+
9662 jj*nSpace+
9663 I]
9664 +=
9665 DV_dof[I][j][jj]
9666 *
9667 v[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9668 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9669 k*nDOF_element+
9670 j];
9671 /* get derivatives at element neighbors */
9672 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
9673 {
9674 /* DOF calculations */
9675 for(I=0;I<nSpace;I++)
9676 for(jj=0;jj<nDOF_element;jj++)
9677 for(i=0;i<nDOF_element;i++)
9678 {
9679 DV_dof[I][i][jj] = 0.0;
9680 for(j=0;j<nDOF_element;j++)
9681 DV_dof[I][i][jj]
9682 +=
9683 A_inv[eN*nDOF_element2+
9684 i*nDOF_element+
9685 j]
9686 *
9687 db_eb[eN*nElementBoundaries_element*nSpace*nDOF_element2+
9688 ebN*nSpace*nDOF_element2+
9689 I*nDOF_element2+
9690 j*nDOF_element+
9691 jj];
9692 }
9693 /* quadrature calculations */
9694 for(k=0;k<nQuadraturePoints_element;k++)
9695 for(j=0;j<nDOF_element;j++)
9696 for(jj=0;jj<nDOF_element;jj++)
9697 for(I=0;I<nSpace;I++)
9698 {
9699 qDV_eb[eN*nElementBoundaries_element*nQuadraturePoints_element*nDOF_element*nSpace+
9700 ebN*nQuadraturePoints_element*nDOF_element*nSpace+
9701 k*nDOF_element*nSpace+
9702 jj*nSpace+
9703 I]
9704 +=
9705 DV_dof[I][j][jj]
9706 *
9707 qv[eN*nQuadraturePoints_element*nDOF_element+
9708 k*nDOF_element+
9709 j];
9710 }
9711 for (ebN_ebN=0;ebN_ebN<nElementBoundaries_element;ebN_ebN++)
9712 {
9713 /* element boundary quadrature calculations */
9714 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
9715 for(j=0;j<nDOF_element;j++)
9716 for(jj=0;jj<nDOF_element;jj++)
9717 for(I=0;I<nSpace;I++)
9718 {
9719 DV_eb[eN*nElementBoundaries_element*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
9720 ebN_ebN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
9721 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
9722 k*nDOF_element*nSpace+
9723 jj*nSpace+
9724 I]
9725 +=
9726 DV_dof[I][j][jj]
9727 *
9728 v[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9729 ebN_ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9730 k*nDOF_element+
9731 j];
9732 }
9733 }
9734 }
9735 }
9736}
9737void calculateVelocityQuadrature_MixedForm2_Jacobian(int nElements_global,
9738 int nElementBoundaries_element,
9739 int nElementBoundaryQuadraturePoints_elementBoundary,
9740 int nDOF_element,
9741 int nSpace,
9742 int nQuadraturePoints_element,
9743 double* qa,
9744 double* qw_dV,
9745 double* db,
9746 double* db_eb,
9747 double* v,
9748 double* DV,
9749 double* DV_eb,
9750 double* qv,
9751 double* qDV,
9752 double* qDV_eb)
9753{
9754 int eN,ebN,ebN_ebN,k,i,j,jj,I,nDOF_element2=nDOF_element*nDOF_element,nSpace2=nSpace*nSpace;
9755 PROTEUS_LAPACK_INTEGER ipiv[nDOF_element],lwork=((PROTEUS_LAPACK_INTEGER)nDOF_element),dim=((PROTEUS_LAPACK_INTEGER)nDOF_element),info=0;
9756 double work[nDOF_element],A_inv[nSpace][nDOF_element2];
9757 double DV_dof[nSpace][nDOF_element][nDOF_element];
9758 memset(DV,0,sizeof(double)*
9759 nElements_global*
9760 nElementBoundaries_element*
9761 nElementBoundaryQuadraturePoints_elementBoundary*
9762 nDOF_element*
9763 nSpace);
9764 memset(DV_eb,0,sizeof(double)*
9765 nElements_global*
9766 nElementBoundaries_element*
9767 nElementBoundaries_element*
9768 nElementBoundaryQuadraturePoints_elementBoundary*
9769 nDOF_element*
9770 nSpace);
9771 memset(qDV,0,sizeof(double)*
9772 nElements_global*
9773 nQuadraturePoints_element*
9774 nDOF_element*
9775 nSpace);
9776 memset(qDV_eb,0,sizeof(double)*
9777 nElements_global*
9778 nElementBoundaries_element*
9779 nQuadraturePoints_element*
9780 nDOF_element*
9781 nSpace);
9782 for(eN=0;eN<nElements_global;eN++)
9783 {
9784 for(I=0;I<nSpace;I++)
9785 {
9786 memset(A_inv[I],0,sizeof(double)*nDOF_element2);
9787 for(i=0;i<nDOF_element;i++)
9788 for(j=0;j<nDOF_element;j++)
9789 {
9790 for(k=0;k<nQuadraturePoints_element;k++)
9791 {
9792 //cek hack do diagonal only for now
9793 A_inv[I][i*nDOF_element+j] += (1.0/qa[eN*nQuadraturePoints_element*nSpace2+
9794 k*nSpace2+
9795 I*nSpace+
9796 I])
9797 *qv[eN*nQuadraturePoints_element*nDOF_element+
9798 k*nDOF_element+
9799 j]
9800 *
9801 qw_dV[eN*nQuadraturePoints_element*nDOF_element+
9802 k*nDOF_element+
9803 i];
9804 }
9805 }
9806 info=0;
9807 dgetrf_(&dim,&dim,A_inv[I],&dim,ipiv,&info);
9808 dgetri_(&dim,A_inv[I],&dim,ipiv,work,&lwork,&info);
9809 /* get derivatives of velocity DOF w.r.t. u DOF*/
9810 for(jj=0;jj<nDOF_element;jj++)
9811 for(i=0;i<nDOF_element;i++)
9812 {
9813 DV_dof[I][i][jj]=0.0;
9814 for(j=0;j<nDOF_element;j++)
9815 DV_dof[I][i][jj]
9816 +=
9817 A_inv[I][i*nDOF_element+
9818 j]
9819 *
9820 db[eN*nSpace*nDOF_element2+
9821 I*nDOF_element2+
9822 j*nDOF_element+
9823 jj];
9824 }
9825 }
9826 /* get derivatives of velocity at element quadrature w.r.t u DOF on element*/
9827 for(k=0;k<nQuadraturePoints_element;k++)
9828 for(j=0;j<nDOF_element;j++)
9829 for(jj=0;jj<nDOF_element;jj++)
9830 for(I=0;I<nSpace;I++)
9831 qDV[eN*nQuadraturePoints_element*nDOF_element*nSpace+
9832 k*nDOF_element*nSpace+
9833 jj*nSpace+
9834 I]
9835 +=
9836 DV_dof[I][j][jj]
9837 *
9838 qv[eN*nQuadraturePoints_element*nDOF_element+
9839 k*nDOF_element+
9840 j];
9841 /* get derivatives of velocity at element boundary quadrature w.r.t. u DOF on element */
9842 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
9843 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
9844 for(j=0;j<nDOF_element;j++)
9845 for(jj=0;jj<nDOF_element;jj++)
9846 for(I=0;I<nSpace;I++)
9847 DV[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
9848 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
9849 k*nDOF_element*nSpace+
9850 jj*nSpace+
9851 I]
9852 +=
9853 DV_dof[I][j][jj]
9854 *
9855 v[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9856 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9857 k*nDOF_element+
9858 j];
9859 /* get derivatives at element neighbors */
9860 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
9861 {
9862 /* DOF calculations */
9863 for(I=0;I<nSpace;I++)
9864 for(jj=0;jj<nDOF_element;jj++)
9865 for(i=0;i<nDOF_element;i++)
9866 {
9867 DV_dof[I][i][jj] = 0.0;
9868 for(j=0;j<nDOF_element;j++)
9869 DV_dof[I][i][jj]
9870 +=
9871 A_inv[I][i*nDOF_element+
9872 j]
9873 *
9874 db_eb[eN*nElementBoundaries_element*nSpace*nDOF_element2+
9875 ebN*nSpace*nDOF_element2+
9876 I*nDOF_element2+
9877 j*nDOF_element+
9878 jj];
9879 }
9880 /* quadrature calculations */
9881 for(k=0;k<nQuadraturePoints_element;k++)
9882 for(j=0;j<nDOF_element;j++)
9883 for(jj=0;jj<nDOF_element;jj++)
9884 for(I=0;I<nSpace;I++)
9885 {
9886 qDV_eb[eN*nElementBoundaries_element*nQuadraturePoints_element*nDOF_element*nSpace+
9887 ebN*nQuadraturePoints_element*nDOF_element*nSpace+
9888 k*nDOF_element*nSpace+
9889 jj*nSpace+
9890 I]
9891 +=
9892 DV_dof[I][j][jj]
9893 *
9894 qv[eN*nQuadraturePoints_element*nDOF_element+
9895 k*nDOF_element+
9896 j];
9897 }
9898 for (ebN_ebN=0;ebN_ebN<nElementBoundaries_element;ebN_ebN++)
9899 {
9900 /* element boundary quadrature calculations */
9901 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
9902 for(j=0;j<nDOF_element;j++)
9903 for(jj=0;jj<nDOF_element;jj++)
9904 for(I=0;I<nSpace;I++)
9905 {
9906 DV_eb[eN*nElementBoundaries_element*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
9907 ebN_ebN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
9908 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
9909 k*nDOF_element*nSpace+
9910 jj*nSpace+
9911 I]
9912 +=
9913 DV_dof[I][j][jj]
9914 *
9915 v[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9916 ebN_ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
9917 k*nDOF_element+
9918 j];
9919 }
9920 }
9921 }
9922 }
9923}
9924
9925void calculateVelocityQuadrature_MixedForm2_Jacobian_sd(int nElements_global,
9926 int nElementBoundaries_element,
9927 int nElementBoundaryQuadraturePoints_elementBoundary,
9928 int nDOF_element,
9929 int nSpace,
9930 int nQuadraturePoints_element,
9931 const int *rowptr,
9932 const int *colind,
9933 double* qa,
9934 double* qw_dV,
9935 double* db,
9936 double* db_eb,
9937 double* v,
9938 double* DV,
9939 double* DV_eb,
9940 double* qv,
9941 double* qDV,
9942 double* qDV_eb)
9943{
9944 int eN,ebN,ebN_ebN,k,i,j,jj,I,nDOF_element2=nDOF_element*nDOF_element,nSpace2=nSpace*nSpace;
9945 int m,nnz=rowptr[nSpace];
9946 PROTEUS_LAPACK_INTEGER ipiv[nDOF_element],lwork=((PROTEUS_LAPACK_INTEGER)nDOF_element),dim=((PROTEUS_LAPACK_INTEGER)nDOF_element),info=0;
9947 double work[nDOF_element],A_inv[nSpace][nDOF_element2];
9948 double DV_dof[nSpace][nDOF_element][nDOF_element];
9949 memset(DV,0,sizeof(double)*
9950 nElements_global*
9951 nElementBoundaries_element*
9952 nElementBoundaryQuadraturePoints_elementBoundary*
9953 nDOF_element*
9954 nSpace);
9955 memset(DV_eb,0,sizeof(double)*
9956 nElements_global*
9957 nElementBoundaries_element*
9958 nElementBoundaries_element*
9959 nElementBoundaryQuadraturePoints_elementBoundary*
9960 nDOF_element*
9961 nSpace);
9962 memset(qDV,0,sizeof(double)*
9963 nElements_global*
9964 nQuadraturePoints_element*
9965 nDOF_element*
9966 nSpace);
9967 memset(qDV_eb,0,sizeof(double)*
9968 nElements_global*
9969 nElementBoundaries_element*
9970 nQuadraturePoints_element*
9971 nDOF_element*
9972 nSpace);
9973 for(eN=0;eN<nElements_global;eN++)
9974 {
9975 for(I=0;I<nSpace;I++)
9976 {
9977 memset(A_inv[I],0,sizeof(double)*nDOF_element2);
9978 for(i=0;i<nDOF_element;i++)
9979 for(j=0;j<nDOF_element;j++)
9980 {
9981 for(k=0;k<nQuadraturePoints_element;k++)
9982 {
9983 //cek hack do diagonal only for now
9984 for (m=rowptr[I]; m < rowptr[I+1]; m++)
9985 if (colind[m] == I)
9986 {
9987 A_inv[I][i*nDOF_element+j] += (1.0/qa[eN*nQuadraturePoints_element*nnz+
9988 k*nnz+m])
9989 *qv[eN*nQuadraturePoints_element*nDOF_element+
9990 k*nDOF_element+
9991 j]
9992 *
9993 qw_dV[eN*nQuadraturePoints_element*nDOF_element+
9994 k*nDOF_element+
9995 i];
9996 }
9997 }
9998 }
9999 info=0;
10000 dgetrf_(&dim,&dim,A_inv[I],&dim,ipiv,&info);
10001 dgetri_(&dim,A_inv[I],&dim,ipiv,work,&lwork,&info);
10002 /* get derivatives of velocity DOF w.r.t. u DOF*/
10003 for(jj=0;jj<nDOF_element;jj++)
10004 {
10005 for(i=0;i<nDOF_element;i++)
10006 {
10007 DV_dof[I][i][jj]=0.0;
10008 for(j=0;j<nDOF_element;j++)
10009 DV_dof[I][i][jj]
10010 +=
10011 A_inv[I][i*nDOF_element+
10012 j]
10013 *
10014 db[eN*nSpace*nDOF_element2+
10015 I*nDOF_element2+
10016 j*nDOF_element+
10017 jj];
10018 }
10019 }
10020 }
10021 for(k=0;k<nQuadraturePoints_element;k++)
10022 for(j=0;j<nDOF_element;j++)
10023 for(jj=0;jj<nDOF_element;jj++)
10024 for(I=0;I<nSpace;I++)
10025 qDV[eN*nQuadraturePoints_element*nDOF_element*nSpace+
10026 k*nDOF_element*nSpace+
10027 jj*nSpace+
10028 I]
10029 +=
10030 DV_dof[I][j][jj]
10031 *
10032 qv[eN*nQuadraturePoints_element*nDOF_element+
10033 k*nDOF_element+
10034 j];
10035 /* get derivatives of velocity at element boundary quadrature w.r.t. u DOF on element */
10036 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
10037 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
10038 for(j=0;j<nDOF_element;j++)
10039 for(jj=0;jj<nDOF_element;jj++)
10040 for(I=0;I<nSpace;I++)
10041 DV[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
10042 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
10043 k*nDOF_element*nSpace+
10044 jj*nSpace+
10045 I]
10046 +=
10047 DV_dof[I][j][jj]
10048 *
10049 v[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
10050 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
10051 k*nDOF_element+
10052 j];
10053 /* get derivatives at element neighbors */
10054 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
10055 {
10056 /* DOF calculations */
10057 for(I=0;I<nSpace;I++)
10058 for(jj=0;jj<nDOF_element;jj++)
10059 {
10060 for(i=0;i<nDOF_element;i++)
10061 {
10062 DV_dof[I][i][jj] = 0.0;
10063 for(j=0;j<nDOF_element;j++)
10064 DV_dof[I][i][jj]
10065 +=
10066 A_inv[I][i*nDOF_element+
10067 j]
10068 *
10069 db_eb[eN*nElementBoundaries_element*nSpace*nDOF_element2+
10070 ebN*nSpace*nDOF_element2+
10071 I*nDOF_element2+
10072 j*nDOF_element+
10073 jj];
10074 }
10075 }
10076 /* quadrature calculations */
10077 for(k=0;k<nQuadraturePoints_element;k++)
10078 for(j=0;j<nDOF_element;j++)
10079 for(jj=0;jj<nDOF_element;jj++)
10080 for(I=0;I<nSpace;I++)
10081 {
10082 qDV_eb[eN*nElementBoundaries_element*nQuadraturePoints_element*nDOF_element*nSpace+
10083 ebN*nQuadraturePoints_element*nDOF_element*nSpace+
10084 k*nDOF_element*nSpace+
10085 jj*nSpace+
10086 I]
10087 +=
10088 DV_dof[I][j][jj]
10089 *
10090 qv[eN*nQuadraturePoints_element*nDOF_element+
10091 k*nDOF_element+
10092 j];
10093 }
10094 for (ebN_ebN=0;ebN_ebN<nElementBoundaries_element;ebN_ebN++)
10095 {
10096 /* element boundary quadrature calculations */
10097 for(k=0;k<nElementBoundaryQuadraturePoints_elementBoundary;k++)
10098 for(j=0;j<nDOF_element;j++)
10099 for(jj=0;jj<nDOF_element;jj++)
10100 for(I=0;I<nSpace;I++)
10101 {
10102 DV_eb[eN*nElementBoundaries_element*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
10103 ebN_ebN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
10104 ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element*nSpace+
10105 k*nDOF_element*nSpace+
10106 jj*nSpace+
10107 I]
10108 +=
10109 DV_dof[I][j][jj]
10110 *
10111 v[eN*nElementBoundaries_element*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
10112 ebN_ebN*nElementBoundaryQuadraturePoints_elementBoundary*nDOF_element+
10113 k*nDOF_element+
10114 j];
10115 }
10116 }
10117 }
10118 }
10119}
10120
10121
10122
10123void calculateVelocityProjectionMatrixLDG(int nElements_global,
10124 int nQuadraturePoints_element,
10125 int nDOF_element,
10126 double* vXw_dV,
10127 double* A_inv)
10128{
10129 int eN,i,j,k,nDOF_element2=nDOF_element*nDOF_element;
10130 PROTEUS_LAPACK_INTEGER ipiv[nDOF_element],lwork=((PROTEUS_LAPACK_INTEGER)nDOF_element),dim=((PROTEUS_LAPACK_INTEGER)nDOF_element),info=0;
10131 double work[nDOF_element];
10132 memset(A_inv,0,sizeof(double)*nElements_global*nDOF_element2);
10133 for(eN=0;eN<nElements_global;eN++)
10134 {
10135 for(i=0;i<nDOF_element;i++)
10136 for(j=0;j<nDOF_element;j++)
10137 {
10138 for(k=0;k<nQuadraturePoints_element;k++)
10139 {
10140 A_inv[eN*nDOF_element2+i*nDOF_element+j] += vXw_dV[eN*nQuadraturePoints_element*nDOF_element2+
10141 k*nDOF_element2+
10142 j*nDOF_element+
10143 i];
10144 }
10145 }
10146 dgetrf_(&dim,&dim,&A_inv[eN*nDOF_element2],&dim,ipiv,&info);
10147 dgetri_(&dim,&A_inv[eN*nDOF_element2],&dim,ipiv,work,&lwork,&info);
10148 }
10149}
10150
10151void updateDiffusion_MixedForm_weak(int nElements_global,
10152 int nQuadraturePoints_element,
10153 int nDOF_test_element,
10154 int nSpace,
10155 double* a,
10156 double* qV,
10157 double* grad_w_dV,
10158 double* weak_residual)
10159{
10160 int eN,i,k,I,J,nSpace2=nSpace*nSpace;
10161 for(eN=0;eN<nElements_global;eN++)
10162 for (i=0;i<nDOF_test_element;i++)
10163 for (k=0;k<nQuadraturePoints_element;k++)
10164 for (I=0;I<nSpace;I++)
10165 for (J=0;J<nSpace;J++)
10166 weak_residual[eN*nDOF_test_element + i]
10167 -=
10168 a[eN*nQuadraturePoints_element*nSpace2 +
10169 k*nSpace2 +
10170 I*nSpace +
10171 J]
10172 *
10173 qV[eN*nQuadraturePoints_element*nSpace +
10174 k*nSpace +
10175 J]
10176 *
10177 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
10178 k*nDOF_test_element*nSpace +
10179 i*nSpace+
10180 I];
10181}
10182
10183void updateDiffusion_MixedForm_weak_sd(int nElements_global,
10184 int nQuadraturePoints_element,
10185 int nDOF_test_element,
10186 int nSpace,
10187 int rho_split,
10188 int* rowptr,
10189 int* colind,
10190 double* a,
10191 double* qV,
10192 double* grad_w_dV,
10193 double* velocity, /* added for ldg coupling */
10194 double* weak_residual)
10195{
10196 int eN,i,k,I,m,nnz=rowptr[nSpace];
10197 for(eN=0;eN<nElements_global;eN++)
10198 for (i=0;i<nDOF_test_element;i++)
10199 for (k=0;k<nQuadraturePoints_element;k++)
10200 for (I=0;I<nSpace;I++)
10201 for (m=rowptr[I];m<rowptr[I+1];m++)
10202 {
10203 weak_residual[eN*nDOF_test_element + i]
10204 -=
10205 a[eN*nQuadraturePoints_element*nnz+
10206 k*nnz+
10207 m]
10208 *
10209 qV[eN*nQuadraturePoints_element*nSpace +
10210 k*nSpace +
10211 colind[m]]
10212 *
10213 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
10214 k*nDOF_test_element*nSpace +
10215 i*nSpace+
10216 I];
10217 }
10218
10219 for(eN=0;eN<nElements_global;eN++)
10220 for (k=0;k<nQuadraturePoints_element;k++)
10221 for (I=0;I<nSpace;I++)
10222 if (rho_split==0)
10223 {
10224 for (m=rowptr[I];m<rowptr[I+1];m++)
10225 {
10226 velocity[eN*nQuadraturePoints_element*nSpace +
10227 k*nSpace + I]
10228 += a[eN*nQuadraturePoints_element*nnz+
10229 k*nnz+ m]
10230 *
10231 qV[eN*nQuadraturePoints_element*nSpace +
10232 k*nSpace + colind[m]];
10233 }
10234 }
10235 else if (rho_split==1)
10236 {
10237 velocity[eN*nQuadraturePoints_element*nSpace +
10238 k*nSpace + I]
10239 =
10240 qV[eN*nQuadraturePoints_element*nSpace +
10241 k*nSpace + I];
10242 }
10243}
10244
10245void updateDiffusionJacobian_MixedForm_weak(int nElements_global,
10246 int nElementBoundaries_element,
10247 int nQuadraturePoints_element,
10248 int nDOF_trial_element,
10249 int nDOF_test_element,
10250 int nSpace,
10251 double* a,
10252 double* da,
10253 double* qV,
10254 double* qDV,
10255 double* qDV_eb,
10256 double* grad_w_dV,
10257 double* v,
10258 double* jacobian_weak_residual,
10259 double* jacobian_weak_residual_eb)
10260{
10261 int eN,ebN,i,j,k,I,J,nSpace2=nSpace*nSpace,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element;
10262 double daProduct,dphiProduct;
10263 for(eN=0;eN<nElements_global;eN++)
10264 {
10265 for (i=0;i<nDOF_test_element;i++)
10266 for (k=0;k<nQuadraturePoints_element;k++)
10267 {
10268 daProduct=0.0;
10269 for (I=0;I<nSpace;I++)
10270 for (J=0;J<nSpace;J++)
10271 daProduct
10272 -=
10273 da[eN*nQuadraturePoints_element*nSpace2 +
10274 k*nSpace2 +
10275 I*nSpace +
10276 J]
10277 *
10278 qV[eN*nQuadraturePoints_element*nSpace +
10279 k*nSpace +
10280 J]
10281 *
10282 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
10283 k*nDOF_test_element*nSpace +
10284 i*nSpace+
10285 I];
10286 for (j=0;j<nDOF_trial_element;j++)
10287 {
10288 dphiProduct=0.0;
10289 for (I=0;I<nSpace;I++)
10290 for (J=0;J<nSpace;J++)
10291 dphiProduct
10292 -=
10293 a[eN*nQuadraturePoints_element*nSpace2 +
10294 k*nSpace2+
10295 I*nSpace +
10296 J]
10297 *
10298 qDV[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
10299 k*nDOF_trial_element*nSpace +
10300 j*nSpace+
10301 J]
10302 *
10303 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
10304 k*nDOF_test_element*nSpace +
10305 i*nSpace+
10306 I];
10307 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
10308 i*nDOF_trial_element +
10309 j]
10310 +=
10311 daProduct
10312 *
10313 v[eN*nQuadraturePoints_element*nDOF_trial_element+
10314 k*nDOF_trial_element+
10315 j]
10316 +
10317 dphiProduct;
10318 }
10319 }
10320 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
10321 for (i=0;i<nDOF_test_element;i++)
10322 for (k=0;k<nQuadraturePoints_element;k++)
10323 {
10324 for (j=0;j<nDOF_trial_element;j++)
10325 {
10326 dphiProduct=0.0;
10327 for (I=0;I<nSpace;I++)
10328 for (J=0;J<nSpace;J++)
10329 dphiProduct
10330 -=
10331 a[eN*nQuadraturePoints_element*nSpace2 +
10332 k*nSpace2+
10333 I*nSpace +
10334 J]
10335 *
10336 qDV_eb[eN*nElementBoundaries_element*nQuadraturePoints_element*nDOF_trial_element*nSpace +
10337 ebN*nQuadraturePoints_element*nDOF_trial_element*nSpace+
10338 k*nDOF_trial_element*nSpace +
10339 j*nSpace+
10340 J]
10341 *
10342 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
10343 k*nDOF_test_element*nSpace +
10344 i*nSpace+
10345 I];
10346 jacobian_weak_residual_eb[eN*nElementBoundaries_element*nDOF_test_X_trial_element +
10347 ebN*nDOF_test_X_trial_element +
10348 i*nDOF_trial_element +
10349 j]
10350 +=
10351 dphiProduct;
10352 }
10353 }
10354 }
10355}
10356
10357void updateDiffusionJacobian_MixedForm_weak_sd(int nElements_global,
10358 int nElementBoundaries_element,
10359 int nQuadraturePoints_element,
10360 int nDOF_trial_element,
10361 int nDOF_test_element,
10362 int nSpace,
10363 int* rowptr,
10364 int* colind,
10365 double* a,
10366 double* da,
10367 double* qV,
10368 double* qDV,
10369 double* qDV_eb,
10370 double* grad_w_dV,
10371 double* v,
10372 double* jacobian_weak_residual,
10373 double* jacobian_weak_residual_eb)
10374{
10375 int eN,ebN,i,j,k,I,m,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,nnz=rowptr[nSpace];
10376 double daProduct,dphiProduct;
10377 for(eN=0;eN<nElements_global;eN++)
10378 {
10379 for (i=0;i<nDOF_test_element;i++)
10380 for (k=0;k<nQuadraturePoints_element;k++)
10381 {
10382 daProduct=0.0;
10383 for (I=0;I<nSpace;I++)
10384 for (m=rowptr[I];m<rowptr[I+1];m++)
10385 daProduct
10386 -=
10387 da[eN*nQuadraturePoints_element*nnz+
10388 k*nnz+
10389 m]
10390 *
10391 qV[eN*nQuadraturePoints_element*nSpace +
10392 k*nSpace +
10393 colind[m]]
10394 *
10395 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
10396 k*nDOF_test_element*nSpace +
10397 i*nSpace+
10398 I];
10399 for (j=0;j<nDOF_trial_element;j++)
10400 {
10401 dphiProduct=0.0;
10402 for (I=0;I<nSpace;I++)
10403 for(m=rowptr[I];m<rowptr[I+1];m++)
10404 dphiProduct
10405 -=
10406 a[eN*nQuadraturePoints_element*nnz+
10407 k*nnz+
10408 m]
10409 *
10410 qDV[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
10411 k*nDOF_trial_element*nSpace +
10412 j*nSpace+
10413 colind[m]]
10414 *
10415 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
10416 k*nDOF_test_element*nSpace +
10417 i*nSpace+
10418 I];
10419 jacobian_weak_residual[eN*nDOF_test_X_trial_element +
10420 i*nDOF_trial_element +
10421 j]
10422 +=
10423 daProduct
10424 *
10425 v[eN*nQuadraturePoints_element*nDOF_trial_element+
10426 k*nDOF_trial_element+
10427 j]
10428 +
10429 dphiProduct;
10430 }
10431 }
10432 for (ebN=0;ebN<nElementBoundaries_element;ebN++)
10433 for (i=0;i<nDOF_test_element;i++)
10434 for (k=0;k<nQuadraturePoints_element;k++)
10435 {
10436 for (j=0;j<nDOF_trial_element;j++)
10437 {
10438 dphiProduct=0.0;
10439 for (I=0;I<nSpace;I++)
10440 for(m=rowptr[I];m<rowptr[I+1];m++)
10441 dphiProduct
10442 -=
10443 a[eN*nQuadraturePoints_element*nnz+
10444 k*nnz+
10445 m]
10446 *
10447 qDV_eb[eN*nElementBoundaries_element*nQuadraturePoints_element*nDOF_trial_element*nSpace +
10448 ebN*nQuadraturePoints_element*nDOF_trial_element*nSpace+
10449 k*nDOF_trial_element*nSpace +
10450 j*nSpace+
10451 colind[m]]
10452 *
10453 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
10454 k*nDOF_test_element*nSpace +
10455 i*nSpace+
10456 I];
10457 jacobian_weak_residual_eb[eN*nElementBoundaries_element*nDOF_test_X_trial_element +
10458 ebN*nDOF_test_X_trial_element +
10459 i*nDOF_trial_element +
10460 j]
10461 +=
10462 dphiProduct;
10463 }
10464 }
10465 }
10466}
10467
10468void estimate_mt(int nElements_global,
10469 int nQuadraturePoints_element,
10470 int nDOF_element,
10471 double* v,
10472 double* vXw_dV,
10473 double* elementSpatialResidual,
10474 double* mt)
10475{
10476 int eN,i,j,k,nDOF_element2=nDOF_element*nDOF_element;
10477 char trans='N';
10478 PROTEUS_LAPACK_INTEGER nrhs=1,dim=((PROTEUS_LAPACK_INTEGER)nDOF_element),info=0,ipiv[nDOF_element];
10479 double massMatrix[nDOF_element2],b[nDOF_element];
10480 /* loop over elements and solve for the local polynomial \pi(mt) such that (\pi(mt),w) = - elementSpatialResidual = b(u,w) -a(u,w) */
10481 /* then evaluate \pi(mt) at the quadrature points to recover the mt estimate */
10482 memset(mt,0,sizeof(double)*nElements_global*nQuadraturePoints_element);
10483 for(eN=0;eN<nElements_global;eN++)
10484 {
10485 memset(massMatrix,0,sizeof(double)*nDOF_element2);
10486 memset(ipiv,0,sizeof(PROTEUS_LAPACK_INTEGER)*nDOF_element);
10487 for(i=0;i<nDOF_element;i++)
10488 for(j=0;j<nDOF_element;j++)
10489 {
10490 for(k=0;k<nQuadraturePoints_element;k++)
10491 {
10492 mt[eN*nQuadraturePoints_element+
10493 k] = 0.0;
10494 massMatrix[i*nDOF_element+j] += vXw_dV[eN*nQuadraturePoints_element*nDOF_element2+
10495 k*nDOF_element2+
10496 j*nDOF_element+
10497 i];
10498 }
10499 b[j] = -elementSpatialResidual[eN*nDOF_element+j];
10500 }
10501 dgetrf_(&dim,&dim,massMatrix,&dim,ipiv,&info);
10502 dgetrs_(&trans,&dim,&nrhs,massMatrix,&dim,ipiv,b,&dim,&info);
10503 for (j=0;j<nDOF_element;j++)
10504 for(k=0;k<nQuadraturePoints_element;k++)
10505 mt[eN*nQuadraturePoints_element+
10506 k] += b[j]*v[eN*nQuadraturePoints_element*nDOF_element+
10507 k*nDOF_element+
10508 j];
10509 }
10510}
10511void estimate_mt_lowmem(int nElements_global,
10512 int nQuadraturePoints_element,
10513 int nDOF_element,
10514 double* v,
10515 double* w_dV,
10516 double* elementSpatialResidual,
10517 double* mt)
10518{
10519 int eN,i,j,k,nDOF_element2=nDOF_element*nDOF_element;
10520 char trans='N';
10521 PROTEUS_LAPACK_INTEGER nrhs=1,dim=((PROTEUS_LAPACK_INTEGER)nDOF_element),info=0,ipiv[nDOF_element];
10522 double massMatrix[nDOF_element2],b[nDOF_element];
10523 /* loop over elements and solve for the local polynomial \pi(mt) such that (\pi(mt),w) = - elementSpatialResidual = b(u,w) -a(u,w) */
10524 /* then evaluate \pi(mt) at the quadrature points to recover the mt estimate */
10525 for(eN=0;eN<nElements_global;eN++)
10526 {
10527 memset(massMatrix,0,sizeof(double)*nDOF_element2);
10528 memset(ipiv,0,sizeof(PROTEUS_LAPACK_INTEGER)*nDOF_element);
10529 for(i=0;i<nDOF_element;i++)
10530 for(j=0;j<nDOF_element;j++)
10531 {
10532 for(k=0;k<nQuadraturePoints_element;k++)
10533 {
10534 mt[eN*nQuadraturePoints_element+
10535 k] = 0.0;
10536 massMatrix[i*nDOF_element+j] +=
10537 v[eN*nQuadraturePoints_element*nDOF_element+
10538 k*nDOF_element+
10539 j]
10540 *w_dV[eN*nQuadraturePoints_element*nDOF_element+
10541 k*nDOF_element+
10542 i];
10543 }
10544 b[j] = -elementSpatialResidual[eN*nDOF_element+j];
10545 }
10546 dgetrf_(&dim,&dim,massMatrix,&dim,ipiv,&info);
10547 dgetrs_(&trans,&dim,&nrhs,massMatrix,&dim,ipiv,b,&dim,&info);
10548 for (j=0;j<nDOF_element;j++)
10549 for(k=0;k<nQuadraturePoints_element;k++)
10550 mt[eN*nQuadraturePoints_element+
10551 k] += b[j]*v[eN*nQuadraturePoints_element*nDOF_element+
10552 k*nDOF_element+
10553 j];
10554 }
10555}
10556
10559void copyExteriorElementBoundaryValuesFromElementBoundaryValues(int nExteriorElementBoundaries_global,
10560 int nElements_global,
10561 int nElementBoundaries_element,
10562 int nQuadraturePoints_elementBoundary,
10563 int nValuesPerQuadraturePoint,
10564 const int * exteriorElementBoundaries,
10565 const int* elementBoundaryElements,
10566 const int * elementBoundaryLocalElementBoundaries,
10567 const double * ebq_val,
10568 double * ebqe_val)
10569{
10570 int ebNE,ebN,eN,ebN_element,k,i;
10571 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
10572 {
10573 ebN = exteriorElementBoundaries[ebNE];
10574 eN = elementBoundaryElements[ebN*2+0];
10575 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
10576 for (k = 0; k < nQuadraturePoints_elementBoundary; k++)
10577 for (i=0; i < nValuesPerQuadraturePoint; i++)
10578 {
10579 ebqe_val[ebNE*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint +
10580 k*nValuesPerQuadraturePoint + i]
10581 =
10582 ebq_val[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint+
10583 ebN_element*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint+
10584 k*nValuesPerQuadraturePoint+
10585 i];
10586 }/*i,k*/
10587 }/*ebNE*/
10588}
10589
10592void copyExteriorElementBoundaryValuesToElementBoundaryValues(int nExteriorElementBoundaries_global,
10593 int nElements_global,
10594 int nElementBoundaries_element,
10595 int nQuadraturePoints_elementBoundary,
10596 int nValuesPerQuadraturePoint,
10597 const int * exteriorElementBoundaries,
10598 const int* elementBoundaryElements,
10599 const int * elementBoundaryLocalElementBoundaries,
10600 const double * ebqe_val,
10601 double * ebq_val)
10602{
10603 int ebNE,ebN,eN,ebN_element,k,i;
10604 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
10605 {
10606 ebN = exteriorElementBoundaries[ebNE];
10607 eN = elementBoundaryElements[ebN*2+0];
10608 ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
10609 for (k = 0; k < nQuadraturePoints_elementBoundary; k++)
10610 for (i=0; i < nValuesPerQuadraturePoint; i++)
10611 {
10612 ebq_val[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint+
10613 ebN_element*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint+
10614 k*nValuesPerQuadraturePoint+
10615 i]
10616 =
10617 ebqe_val[ebNE*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint +
10618 k*nValuesPerQuadraturePoint + i];
10619 }/*i,k*/
10620 }/*ebNE*/
10621}
10622
10625void copyExteriorElementBoundaryValuesToGlobalElementBoundaryValues(int nExteriorElementBoundaries_global,
10626 int nQuadraturePoints_elementBoundary,
10627 int nValuesPerQuadraturePoint,
10628 const int * exteriorElementBoundaries,
10629 const int* elementBoundaryElements,
10630 const int * elementBoundaryLocalElementBoundaries,
10631 const double * ebqe_val,
10632 double * ebq_global_val)
10633{
10634 int ebNE,ebN,eN,k,i;
10635 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
10636 {
10637 ebN = exteriorElementBoundaries[ebNE];
10638 eN = elementBoundaryElements[ebN*2+0];
10639 for (k = 0; k < nQuadraturePoints_elementBoundary; k++)
10640 for (i=0; i < nValuesPerQuadraturePoint; i++)
10641 {
10642 ebq_global_val[ebN*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint+
10643 k*nValuesPerQuadraturePoint+
10644 i]
10645 =
10646 ebqe_val[ebNE*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint +
10647 k*nValuesPerQuadraturePoint + i];
10648 }/*i,k*/
10649 }/*ebNE*/
10650}
10651
10655void copyExteriorElementBoundaryValuesFromGlobalElementBoundaryValues(int nExteriorElementBoundaries_global,
10656 int nQuadraturePoints_elementBoundary,
10657 int nValuesPerQuadraturePoint,
10658 const int * exteriorElementBoundaries,
10659 const int* elementBoundaryElements,
10660 const int * elementBoundaryLocalElementBoundaries,
10661 const double * ebq_global_val,
10662 double * ebqe_val)
10663{
10664 int ebNE,ebN,eN,k,i;
10665 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
10666 {
10667 ebN = exteriorElementBoundaries[ebNE];
10668 eN = elementBoundaryElements[ebN*2+0];
10669 for (k = 0; k < nQuadraturePoints_elementBoundary; k++)
10670 for (i=0; i < nValuesPerQuadraturePoint; i++)
10671 {
10672 ebqe_val[ebNE*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint +
10673 k*nValuesPerQuadraturePoint + i]
10674 =
10675 ebq_global_val[ebN*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint+
10676 k*nValuesPerQuadraturePoint+
10677 i];
10678 }/*i,k*/
10679 }/*ebNE*/
10680}
10681
10682double scalarDomainIntegral(int nElements,
10683 int nQuadraturePoints_element,
10684 double* dV,
10685 double* nValueArray)
10686{
10687 int eN,k;
10688 register double integral=0.0;
10689 for(eN=0;eN<nElements;eN++)
10690 for(k=0;k<nQuadraturePoints_element;k++)
10691 {
10692 integral += nValueArray[eN*nQuadraturePoints_element + k]*
10693 dV[eN*nQuadraturePoints_element+k];
10694 }
10695 return integral;
10696}
10697
10698double scalarHeavisideDomainIntegral(int nElements,
10699 int nQuadraturePoints_element,
10700 double* dV,
10701 double* nValueArray)
10702{
10703 int eN,k;
10704 register double integral=0.0;
10705 for(eN=0;eN<nElements;eN++)
10706 for(k=0;k<nQuadraturePoints_element;k++)
10707 {
10708 if(nValueArray[eN*nQuadraturePoints_element + k] > 0.0)
10709 integral += dV[eN*nQuadraturePoints_element+k];
10710 else if (nValueArray[eN*nQuadraturePoints_element + k] == 0.0)
10711 integral += 0.5*dV[eN*nQuadraturePoints_element+k];
10712 }
10713 return integral;
10714}
10715
10716double scalarSmoothedHeavisideDomainIntegral(int nElements,
10717 int nQuadraturePoints_element,
10718 double epsFact,
10719 double* elementDiameter,
10720 double* dV,
10721 double* nValueArray)
10722{
10723 int eN,k;
10724 register double integral=0.0,eps,H,phi;
10725 for(eN=0;eN<nElements;eN++)
10726 {
10727 eps = elementDiameter[eN]*epsFact;
10728 for(k=0;k<nQuadraturePoints_element;k++)
10729 {
10730 phi = nValueArray[eN*nQuadraturePoints_element + k];
10731 if (phi > eps)
10732 H=1.0;
10733 else if (phi < -eps)
10734 H=0.0;
10735 else if (phi==0.0)
10736 H=0.5;
10737 else
10738 H = 0.5*(1.0 + phi/eps + sin(M_PI*phi/eps)/M_PI);
10739 integral += H*dV[eN*nQuadraturePoints_element+k];
10740 }
10741 }
10742 return integral;
10743}
10744
10745double fluxDomainBoundaryIntegral(int nExteriorElementBoundaries,
10746 int nElementBoundaries_owned,
10747 int nQuadraturePoints_elementBoundary,
10748 int* flag,
10749 int* exteriorElementBoundariesArray,
10750 double* dS,
10751 double* nValueArray)
10752{
10753 int ebNE,ebN,k;
10754 register double integral=0.0;
10755 for(ebNE=0;ebNE<nExteriorElementBoundaries;ebNE++)
10756 {
10757 ebN = exteriorElementBoundariesArray[ebNE];
10758 if (ebN < nElementBoundaries_owned && flag[ebN] > 0)
10759 {
10760 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
10761 {
10762 integral += nValueArray[ebNE*nQuadraturePoints_elementBoundary + k]*
10763 dS[ebNE*nQuadraturePoints_elementBoundary+k];
10764 }
10765 }
10766 }
10767 return integral;
10768}
10769
10770double fluxDomainBoundaryIntegralFromVector(int nExteriorElementBoundaries,
10771 int nElementBoundaries_owned,
10772 int nQuadraturePoints_elementBoundary,
10773 int nSpace,
10774 int* flag,
10775 int* exteriorElementBoundaries,
10776 double* dS,
10777 double* nValueArray,
10778 double* normal)
10779{
10780 int ebNE,ebN,k,I;
10781 register double integral=0.0,flux=0.0;
10782 for(ebNE=0;ebNE<nExteriorElementBoundaries;ebNE++)
10783 {
10784 ebN = exteriorElementBoundaries[ebNE];
10785 if (ebN < nElementBoundaries_owned && flag[ebN] > 0)
10786 {
10787 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
10788 {
10789 flux=0.0;
10790 for (I=0;I<nSpace;I++)
10791 {
10792 flux += nValueArray[ebNE*nQuadraturePoints_elementBoundary*nSpace + k*nSpace+I]*
10793 normal[ebNE*nQuadraturePoints_elementBoundary*nSpace + k*nSpace+I];
10794 }
10795 integral += flux*dS[ebNE*nQuadraturePoints_elementBoundary+k];
10796 }
10797 }
10798 }
10799 return integral;
10800}
10801
10802
10803void computeC0P1InterpolantDGP12(int nElements_global,
10804 int nNodes_global,
10805 int nNodes_element,
10806 int nDOF_element,
10807 int dim_dof,
10808 const int* elementNodesArray,
10809 const int* nodeElementOffsets,
10810 const int* nodeElementsArray,
10811 const int* l2g,
10812 const double * dof,
10813 double* nodalAverage)
10814{
10815 int eN,nN,i,ig,iv;
10816 int nElements_nN;
10817 memset(nodalAverage,0,sizeof(double)*nNodes_global*dim_dof);
10818 for (iv = 0; iv < dim_dof; iv++)
10819 {
10820 for (eN = 0; eN < nElements_global; eN++)
10821 {
10822 for (i = 0; i < nNodes_element; i++)
10823 {
10824 nN = elementNodesArray[eN*nNodes_element + i];
10825 ig = l2g[eN*nDOF_element + i];
10826 nodalAverage[nN*dim_dof + iv] += dof[ig*dim_dof + iv];
10827 }
10828 }
10829 for (nN = 0; nN < nNodes_global; nN++)
10830 {
10831 nElements_nN = nodeElementOffsets[nN+1] - nodeElementOffsets[nN];
10832 nodalAverage[nN*dim_dof + iv] /= nElements_nN;
10833 }
10834 }/*iv*/
10835}
10836
10837void computeC0P1InterpolantDGP0(int nElements_global,
10838 int nNodes_global,
10839 int nNodes_element,
10840 int nDOF_element,
10841 int dim_dof,
10842 const int* elementNodesArray,
10843 const int* nodeElementOffsets,
10844 const int* nodeElementsArray,
10845 const int* l2g,
10846 const double * dof,
10847 double* nodalAverage)
10848{
10849 int eN,nN,i,ig,iv;
10850 int nElements_nN;
10851 memset(nodalAverage,0,sizeof(double)*nNodes_global*dim_dof);
10852 for (iv = 0; iv < dim_dof; iv++)
10853 {
10854 for (eN = 0; eN < nElements_global; eN++)
10855 {
10856 ig = l2g[eN*nDOF_element+0];
10857 for (i = 0; i < nNodes_element; i++)
10858 {
10859 nN = elementNodesArray[eN*nNodes_element+i];
10860 nodalAverage[nN*dim_dof + iv] += dof[ig*dim_dof + iv];
10861 }
10862 }
10863 for (nN = 0; nN < nNodes_global; nN++)
10864 {
10865 nElements_nN = nodeElementOffsets[nN+1] - nodeElementOffsets[nN];
10866 nodalAverage[nN*dim_dof + iv] /= nElements_nN;
10867 }
10868 }
10869}
10870
10871void computeC0P1InterpolantNCP1(int nElements_global,
10872 int nNodes_global,
10873 int nNodes_element,
10874 int nDOF_element,
10875 int dim_dof,
10876 const int* elementNodesArray,
10877 const int* nodeElementOffsets,
10878 const int* nodeElementsArray,
10879 const int* l2g,
10880 const double * dof,
10881 double* nodalAverage)
10882{
10883 int eN,nN,i,j,ig,jg,iv;
10884 int nElements_nN;
10885 double val,nd;
10886 memset(nodalAverage,0,sizeof(double)*nNodes_global*dim_dof);
10887 nd = nNodes_element - 1.0;
10888 for (iv = 0; iv < dim_dof; iv++)
10889 {
10890 for (eN = 0; eN < nElements_global; eN++)
10891 {
10892 /*
10893 recall N_i = n_d(1/n_d - \lambda_i)
10894 lambda_i = barycentric coord for node i
10895
10896 */
10897 for (i = 0; i < nNodes_element; i++)
10898 {
10899 val = 0.0;
10900 for (j=0; j < i; j++)
10901 {
10902 jg = l2g[eN*nDOF_element+j];
10903 val += dof[jg*dim_dof + iv];
10904 }
10905 for (j=i+1; j < nNodes_element; j++)
10906 {
10907 jg = l2g[eN*nDOF_element+j];
10908 val += dof[jg*dim_dof + iv];
10909 }
10910 ig = l2g[eN*nDOF_element+i];
10911 val += (1.0-nd)*dof[ig*dim_dof + iv];
10912 nN = elementNodesArray[eN*nNodes_element+i];
10913 nodalAverage[nN*dim_dof + iv] += val;
10914 }
10915 }
10916 for (nN = 0; nN < nNodes_global; nN++)
10917 {
10918 nElements_nN = nodeElementOffsets[nN+1] - nodeElementOffsets[nN];
10919 nodalAverage[nN*dim_dof + iv] /= nElements_nN;
10920 }
10921 }/*iv*/
10922}
10923
10927int checkElementBoundaryAndExteriorElementBoundaryArraysSame(int nElementBoundaries_element,
10928 int nExteriorElementBoundaries_global,
10929 int nQuadraturePoints_elementBoundary,
10930 int nValuesPerQuadraturePoint,
10931 double tolerance,
10932 const int * exteriorElementBoundariesArray,
10933 const int * elementBoundaryElementsArray,
10934 const int * elementBoundaryLocalElementBoundariesArray,
10935 const double * ebq_val,
10936 const double * ebqe_val,
10937 int* firstBadIndex)
10938{
10939 int eN,ebN,ebN_local,ebNE,k,i;
10940 double val1,val2;
10941 int failed = 0;
10942 *firstBadIndex = -1;
10943
10944 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
10945 {
10946 ebN = exteriorElementBoundariesArray[ebNE];
10947 eN = elementBoundaryElementsArray[ebN*2+0];
10948 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
10949
10950 for (i=0; i < nValuesPerQuadraturePoint; i++)
10951 {
10952 val1 = ebq_val[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint +
10953 ebN_local*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint +
10954 k*nValuesPerQuadraturePoint +
10955 i];
10956 val2 = ebqe_val[ebNE*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint +
10957 k*nValuesPerQuadraturePoint +
10958 i];
10959 if (fabs(val1-val2) > tolerance)
10960 {
10961 failed = 1;
10962 *firstBadIndex = ebNE;
10963 return failed;
10964 }
10965 }
10966 }
10967 return failed;
10968}
10969
10973int checkGlobalElementBoundaryAndExteriorElementBoundaryArraysSame(int nExteriorElementBoundaries_global,
10974 int nQuadraturePoints_elementBoundary,
10975 int nValuesPerQuadraturePoint,
10976 double tolerance,
10977 const int * exteriorElementBoundariesArray,
10978 const int * elementBoundaryElementsArray,
10979 const int * elementBoundaryLocalElementBoundariesArray,
10980 const double * ebq_global_val,
10981 const double * ebqe_val,
10982 int* firstBadIndex)
10983{
10984 int eN,ebN,ebNE,k,i;
10985 double val1,val2;
10986 int failed = 0;
10987 *firstBadIndex = -1;
10988
10989 for (ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
10990 {
10991 ebN = exteriorElementBoundariesArray[ebNE];
10992 eN = elementBoundaryElementsArray[ebN*2+0];
10993
10994 for (i=0; i < nValuesPerQuadraturePoint; i++)
10995 {
10996 val1 = ebq_global_val[ebN*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint +
10997 k*nValuesPerQuadraturePoint +
10998 i];
10999 val2 = ebqe_val[ebNE*nQuadraturePoints_elementBoundary*nValuesPerQuadraturePoint +
11000 k*nValuesPerQuadraturePoint +
11001 i];
11002 if (fabs(val1-val2) > tolerance)
11003 {
11004 failed = 1;
11005 *firstBadIndex = ebNE;
11006 return failed;
11007 }
11008 }
11009 }
11010 return failed;
11011}
11012
11013void copyFreeUnknownsToGlobalUnknowns(int nDOF2set,
11014 int offset,
11015 int stride,
11016 const int* globalDOFids,
11017 const int* freeDOFids,
11018 const double * free_u,
11019 double * u)
11020{
11021 int i,dofN,free_dofN;
11022 for (i = 0; i < nDOF2set; i++)
11023 {
11024 dofN = globalDOFids[i]; free_dofN = freeDOFids[i];
11025 u[dofN] = free_u[offset + stride*free_dofN];
11026 }
11027
11028}
11029
11030void copyGlobalUnknownsToFreeUnknowns(int nDOF2set,
11031 int offset,
11032 int stride,
11033 const int* globalDOFids,
11034 const int* freeDOFids,
11035 const double * u,
11036 double * free_u)
11037{
11038 int i,dofN,free_dofN;
11039 for (i = 0; i < nDOF2set; i++)
11040 {
11041 dofN = globalDOFids[i]; free_dofN = freeDOFids[i];
11042 free_u[offset + stride*free_dofN] = u[dofN]; /*hit multiple times*/
11043 }
11044
11045}
11046
11047void updateInteriorElementBoundaryDiffusionAdjoint(int nInteriorElementBoundaries_global,
11048 int nElementBoundaries_element,
11049 int nQuadraturePoints_elementBoundary,
11050 int nDOF_test_element,
11051 int nSpace,
11052 int* interiorElementBoundaries,
11053 int* elementBoundaryElements,
11054 int* elementBoundaryLocalElementBoundaries,
11055 double sigma,
11056 double* u,
11057 double* n,
11058 double* a,
11059 double* grad_w,
11060 double* dS,
11061 double* residual)
11062{
11063 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,i,k,I,J,nSpace2=nSpace*nSpace;
11064 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
11065 {
11066 ebN = interiorElementBoundaries[ebNI];
11067 left_eN_global = elementBoundaryElements[ebN*2+0];
11068 right_eN_global = elementBoundaryElements[ebN*2+1];
11069 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
11070 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
11071 for(i=0;i<nDOF_test_element;i++)
11072 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
11073 {
11074 for (I=0;I<nSpace;I++)
11075 for (J=0;J<nSpace;J++)
11076 {
11077 residual[left_eN_global*nDOF_test_element+
11078 i]
11079 -=
11080 sigma*0.5*((u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11081 left_ebN_element*nQuadraturePoints_elementBoundary+
11082 k]
11083 -u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11084 right_ebN_element*nQuadraturePoints_elementBoundary+
11085 k])
11086 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11087 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11088 k*nSpace+I]
11089 *a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
11090 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
11091 k*nSpace2+
11092 J*nSpace+
11093 I]
11094 *grad_w[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element*nSpace+
11095 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element*nSpace+
11096 k*nDOF_test_element*nSpace+
11097 i*nSpace+
11098 I]
11099 *dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11100 left_ebN_element*nQuadraturePoints_elementBoundary+
11101 k]);
11102 residual[right_eN_global*nDOF_test_element+
11103 i]
11104 -=
11105 sigma*0.5*((u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11106 left_ebN_element*nQuadraturePoints_elementBoundary+
11107 k]
11108 -u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11109 right_ebN_element*nQuadraturePoints_elementBoundary+
11110 k])
11111 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11112 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11113 k*nSpace+I]
11114 *a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
11115 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
11116 k*nSpace2+
11117 J*nSpace+
11118 I]
11119 *grad_w[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element*nSpace+
11120 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element*nSpace+
11121 k*nDOF_test_element*nSpace+
11122 i*nSpace+
11123 I]
11124 *dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11125 right_ebN_element*nQuadraturePoints_elementBoundary+
11126 k]);
11127 }
11128 }
11129 }
11130}
11131
11132void updateExteriorElementBoundaryDiffusionAdjoint(int nExteriorElementBoundaries_global,
11133 int nQuadraturePoints_elementBoundary,
11134 int nDOF_test_element,
11135 int nSpace,
11136 int* isDOFBoundary,
11137 int* exteriorElementBoundaries,
11138 int* elementBoundaryElements,
11139 int* elementBoundaryLocalElementBoundaries,
11140 double sigma,
11141 double* u,
11142 double* ub,
11143 double* n,
11144 double* a,
11145 double* grad_w,
11146 double* dS,
11147 double* residual)
11148{
11149 int ebNE,ebN,eN_global,i,k,I,J,nSpace2=nSpace*nSpace;
11150 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
11151 {
11152 ebN = exteriorElementBoundaries[ebNE];
11153 eN_global = elementBoundaryElements[ebN*2+0];
11154 for(i=0;i<nDOF_test_element;i++)
11155 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
11156 {
11157 if (isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k])
11158 {
11159 for (I=0;I<nSpace;I++)
11160 for (J=0;J<nSpace;J++)
11161 {
11162 residual[eN_global*nDOF_test_element+
11163 i]
11164 -=
11165 sigma*((u[ebNE*nQuadraturePoints_elementBoundary+
11166 k]
11167 -ub[ebNE*nQuadraturePoints_elementBoundary+
11168 k])
11169 *n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
11170 k*nSpace+
11171 I]
11172 *a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
11173 k*nSpace2+
11174 J*nSpace+
11175 I]
11176 *grad_w[ebNE*nQuadraturePoints_elementBoundary*nDOF_test_element*nSpace+
11177 k*nDOF_test_element*nSpace+
11178 i*nSpace+
11179 I]
11180 *dS[ebNE*nQuadraturePoints_elementBoundary+
11181 k]);
11182 }
11183 }
11184 }
11185 }
11186}
11187
11188void updateGlobalJacobianFromInteriorElementBoundaryDiffusionAdjoint_dense(int nInteriorElementBoundaries_global,
11189 int nElementBoundaries_element,
11190 int nQuadraturePoints_elementBoundary,
11191 int nDOF_test_element,
11192 int nDOF_trial_element,
11193 int nSpace,
11194 int offset_r,
11195 int stride_r,
11196 int offset_u,
11197 int stride_u,
11198 int nFreeVDOF_global,
11199 int* interiorElementBoundaries,
11200 int* elementBoundaryElements,
11201 int* elementBoundaryLocalElementBoundaries,
11202 int* nFreeDOF_element_r,
11203 int* freeLocal_r,
11204 int* freeGlobal_r,
11205 int* nFreeDOF_element_u,
11206 int* freeLocal_u,
11207 int* freeGlobal_u,
11208 double sigma,
11209 double* v,
11210 double* n,
11211 double* a,
11212 double* grad_w,
11213 double* dS,
11214 double* jac)
11215{
11216 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,ii,i,k,jj,j,jacIndex,I,J,II,JJ,nSpace2=nSpace*nSpace;
11217 for (ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
11218 {
11219 ebN = interiorElementBoundaries[ebNI];
11220 left_eN_global = elementBoundaryElements[ebN*2+0];
11221 right_eN_global = elementBoundaryElements[ebN*2+1];
11222 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
11223 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
11224 /*left flux*/
11225 for(ii=0;ii<nFreeDOF_element_r[left_eN_global];ii++)
11226 {
11227 i = freeLocal_r[left_eN_global*nDOF_test_element+
11228 ii];
11229 I = offset_r + stride_r*freeGlobal_r[left_eN_global*nDOF_test_element+
11230 ii];
11231 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
11232 {
11233 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
11234 {
11235 j = freeLocal_u[left_eN_global*nDOF_trial_element+
11236 jj];
11237 J = offset_u + stride_u*freeGlobal_u[left_eN_global*nDOF_trial_element+
11238 jj];
11239 jacIndex = I+J*nFreeVDOF_global;
11240 for (II=0;II<nSpace;II++)
11241 for (JJ=0;JJ<nSpace;JJ++)
11242 jac[jacIndex]
11243 -= sigma*0.5*(v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11244 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11245 k*nDOF_trial_element+
11246 j]
11247 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11248 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11249 k*nSpace+
11250 II]
11251 *a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
11252 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+k*nSpace2+
11253 II*nSpace+
11254 JJ]
11255 *grad_w[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11256 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11257 k*nDOF_trial_element*nSpace+
11258 i*nSpace+
11259 II]
11260 *dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11261 left_ebN_element*nQuadraturePoints_elementBoundary+
11262 k]);
11263 }
11264 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
11265 {
11266 j = freeLocal_u[right_eN_global*nDOF_trial_element+
11267 jj];
11268 J = offset_u + stride_u*freeGlobal_u[right_eN_global*nDOF_trial_element+
11269 jj];
11270 jacIndex = I+J*nFreeVDOF_global;
11271 for (II=0;II<nSpace;II++)
11272 for (JJ=0;JJ<nSpace;JJ++)
11273 jac[jacIndex] += sigma*0.5*(v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11274 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11275 k*nDOF_trial_element+
11276 j]
11277 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11278 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11279 k*nSpace+
11280 II]
11281 *a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
11282 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
11283 k*nSpace2+
11284 II*nSpace+
11285 JJ]
11286 *grad_w[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11287 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11288 k*nDOF_trial_element*nSpace+
11289 i*nSpace+
11290 II]
11291 *dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11292 left_ebN_element*nQuadraturePoints_elementBoundary+
11293 k]);
11294 }
11295 }/*k*/
11296 }/*ii*/
11297 /*right flux*/
11298 for(ii=0;ii<nFreeDOF_element_r[right_eN_global];ii++)
11299 {
11300 i = freeLocal_r[right_eN_global*nDOF_test_element+
11301 ii];
11302 I = offset_r + stride_r*freeGlobal_r[right_eN_global*nDOF_test_element+
11303 ii];
11304 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
11305 {
11306 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
11307 {
11308 j = freeLocal_u[left_eN_global*nDOF_trial_element+
11309 jj];
11310 J = offset_u + stride_u*freeGlobal_u[left_eN_global*nDOF_trial_element+
11311 jj];
11312 jacIndex = I+J*nFreeVDOF_global;
11313 for (II=0;II<nSpace;II++)
11314 for (JJ=0;JJ<nSpace;JJ++)
11315 jac[jacIndex] -= sigma*0.5*(v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11316 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11317 k*nDOF_trial_element+
11318 j]
11319 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11320 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11321 k*nSpace+
11322 II]
11323 *a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
11324 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
11325 k*nSpace2+
11326 II*nSpace+
11327 JJ]
11328 *grad_w[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11329 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11330 k*nDOF_trial_element*nSpace+
11331 i*nSpace+
11332 II]
11333 *dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11334 right_ebN_element*nQuadraturePoints_elementBoundary+
11335 k]);
11336 }
11337 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
11338 {
11339 j = freeLocal_u[right_eN_global*nDOF_trial_element+
11340 jj];
11341 J = offset_u + stride_u*freeGlobal_u[right_eN_global*nDOF_trial_element+
11342 jj];
11343 jacIndex = I+J*nFreeVDOF_global;
11344 for (II=0;II<nSpace;II++)
11345 for (JJ=0;JJ<nSpace;JJ++)
11346 jac[jacIndex] += sigma*0.5*(v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11347 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11348 k*nDOF_trial_element+j]
11349 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11350 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11351 k*nSpace+
11352 II]
11353 *a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace2+
11354 right_ebN_element*nQuadraturePoints_elementBoundary*nSpace2+
11355 k*nSpace2+
11356 II*nSpace+
11357 JJ]
11358 *grad_w[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11359 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11360 k*nDOF_trial_element*nSpace+
11361 i*nSpace+
11362 II]
11363 *dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11364 right_ebN_element*nQuadraturePoints_elementBoundary+
11365 k]);
11366 }
11367 }
11368 }
11369 }
11370}
11371
11372void updateGlobalJacobianFromExteriorElementBoundaryDiffusionAdjoint_dense(int nExteriorElementBoundaries_global,
11373 int nQuadraturePoints_elementBoundary,
11374 int nDOF_test_element,
11375 int nDOF_trial_element,
11376 int nSpace,
11377 int offset_r,
11378 int stride_r,
11379 int offset_u,
11380 int stride_u,
11381 int nFreeVDOF_global,
11382 int* exteriorElementBoundaries,
11383 int* elementBoundaryElements,
11384 int* elementBoundaryLocalElementBoundaries,
11385 int* nFreeDOF_element_r,
11386 int* freeLocal_r,
11387 int* freeGlobal_r,
11388 int* nFreeDOF_element_u,
11389 int* freeLocal_u,
11390 int* freeGlobal_u,
11391 int* isDOFBoundary,
11392 double sigma,
11393 double* v,
11394 double* n,
11395 double* a,
11396 double* grad_w,
11397 double* dS,
11398 double* jac)
11399{
11400 int ebNE,ebN,eN_global,ii,i,k,jj,j,jacIndex,I,J,II,JJ,nSpace2=nSpace*nSpace;
11401 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
11402 {
11403 ebN = exteriorElementBoundaries[ebNE];
11404 eN_global = elementBoundaryElements[ebN*2+0];
11405 for(ii=0;ii<nFreeDOF_element_r[eN_global];ii++)
11406 {
11407 i = freeLocal_r[eN_global*nDOF_test_element+
11408 ii];
11409 I = offset_r + stride_r*freeGlobal_r[eN_global*nDOF_test_element+
11410 ii];
11411 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
11412 {
11413 for(jj=0;jj<nFreeDOF_element_u[eN_global];jj++)
11414 {
11415 j = freeLocal_u[eN_global*nDOF_trial_element+
11416 jj];
11417 J = offset_u + stride_u*freeGlobal_u[eN_global*nDOF_trial_element+
11418 jj];
11419 jacIndex = I+J*nFreeVDOF_global;
11420 if (isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k])
11421 {
11422 for (II=0;II<nSpace;II++)
11423 for (JJ=0;JJ<nSpace;JJ++)
11424 jac[jacIndex]
11425 -= sigma*(v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11426 k*nDOF_trial_element+
11427 j]
11428 *n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
11429 k*nSpace+
11430 II]
11431 *a[ebNE*nQuadraturePoints_elementBoundary*nSpace2+
11432 II*nSpace+
11433 JJ]
11434 *grad_w[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11435 k*nDOF_trial_element*nSpace+
11436 i*nSpace+
11437 II]
11438 *dS[ebNE*nQuadraturePoints_elementBoundary+
11439 k]);
11440 }
11441 }
11442 }
11443 }
11444 }
11445}
11446
11447void updateInteriorElementBoundaryDiffusionAdjoint_sd(int nInteriorElementBoundaries_global,
11448 int nElementBoundaries_element,
11449 int nQuadraturePoints_elementBoundary,
11450 int nDOF_test_element,
11451 int nSpace,
11452 int* rowptr,
11453 int* colind,
11454 int* interiorElementBoundaries,
11455 int* elementBoundaryElements,
11456 int* elementBoundaryLocalElementBoundaries,
11457 double sigma,
11458 double* u,
11459 double* n,
11460 double* a,
11461 double* grad_w,
11462 double* dS,
11463 double* residual)
11464{
11465 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,i,k,I,m,nnz=rowptr[nSpace];
11466 for(ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
11467 {
11468 ebN = interiorElementBoundaries[ebNI];
11469 left_eN_global = elementBoundaryElements[ebN*2+0];
11470 right_eN_global = elementBoundaryElements[ebN*2+1];
11471 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
11472 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
11473 for(i=0;i<nDOF_test_element;i++)
11474 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
11475 {
11476 for (I=0;I<nSpace;I++)
11477 for (m=rowptr[I];m<rowptr[I+1];m++)
11478 {
11479 residual[left_eN_global*nDOF_test_element+
11480 i]
11481 -=
11482 sigma*0.5*((u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11483 left_ebN_element*nQuadraturePoints_elementBoundary+
11484 k]
11485 -u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11486 right_ebN_element*nQuadraturePoints_elementBoundary+
11487 k])
11488 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11489 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11490 k*nSpace+
11491 colind[m]]
11492 *a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
11493 left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
11494 k*nnz+
11495 m]
11496 *grad_w[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element*nSpace+
11497 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element*nSpace+
11498 k*nDOF_test_element*nSpace+
11499 i*nSpace+
11500 I]
11501 *dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11502 left_ebN_element*nQuadraturePoints_elementBoundary+
11503 k]);
11504 residual[right_eN_global*nDOF_test_element+
11505 i]
11506 -=
11507 sigma*0.5*((u[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11508 left_ebN_element*nQuadraturePoints_elementBoundary+
11509 k]
11510 -u[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11511 right_ebN_element*nQuadraturePoints_elementBoundary+
11512 k])
11513 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11514 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11515 k*nSpace+
11516 colind[m]]
11517 *a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
11518 right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
11519 k*nnz+
11520 m]
11521 *grad_w[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_test_element*nSpace+
11522 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_test_element*nSpace+
11523 k*nDOF_test_element*nSpace+
11524 i*nSpace+
11525 I]
11526 *dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11527 right_ebN_element*nQuadraturePoints_elementBoundary+
11528 k]);
11529 }
11530 }
11531 }
11532}
11533
11534void updateExteriorElementBoundaryDiffusionAdjoint_sd(int nExteriorElementBoundaries_global,
11535 int nQuadraturePoints_elementBoundary,
11536 int nDOF_test_element,
11537 int nSpace,
11538 int* rowptr,
11539 int* colind,
11540 int* isDOFBoundary,
11541 int* exteriorElementBoundaries,
11542 int* elementBoundaryElements,
11543 int* elementBoundaryLocalElementBoundaries,
11544 double sigma,
11545 double* u,
11546 double* ub,
11547 double* n,
11548 double* a,
11549 double* grad_w,
11550 double* dS,
11551 double* residual)
11552{
11553 int ebNE,ebN,eN_global,i,k,I,m,nnz=rowptr[nSpace];
11554 for(ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
11555 {
11556 ebN = exteriorElementBoundaries[ebNE];
11557 eN_global = elementBoundaryElements[ebN*2+0];
11558 for(i=0;i<nDOF_test_element;i++)
11559 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
11560 {
11561 if (isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k])
11562 {
11563 for (I=0;I<nSpace;I++)
11564 for (m=rowptr[I];m<rowptr[I+1];m++)
11565 {
11566 residual[eN_global*nDOF_test_element+
11567 i]
11568 -=
11569 sigma*((u[ebNE*nQuadraturePoints_elementBoundary+
11570 k]
11571 -ub[ebNE*nQuadraturePoints_elementBoundary+
11572 k])
11573 *n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
11574 k*nSpace+
11575 colind[m]]
11576 *a[ebNE*nQuadraturePoints_elementBoundary*nnz+
11577 k*nnz+
11578 m]
11579 *grad_w[ebNE*nQuadraturePoints_elementBoundary*nDOF_test_element*nSpace+
11580 k*nDOF_test_element*nSpace+
11581 i*nSpace+
11582 I]
11583 *dS[ebNE*nQuadraturePoints_elementBoundary+
11584 k]);
11585 }
11586 }
11587 }
11588 }
11589}
11590
11591void updateGlobalJacobianFromInteriorElementBoundaryDiffusionAdjoint_dense_sd(int nInteriorElementBoundaries_global,
11592 int nElementBoundaries_element,
11593 int nQuadraturePoints_elementBoundary,
11594 int nDOF_test_element,
11595 int nDOF_trial_element,
11596 int nSpace,
11597 int* rowptr,
11598 int* colind,
11599 int offset_r,
11600 int stride_r,
11601 int offset_u,
11602 int stride_u,
11603 int nFreeVDOF_global,
11604 int* interiorElementBoundaries,
11605 int* elementBoundaryElements,
11606 int* elementBoundaryLocalElementBoundaries,
11607 int* nFreeDOF_element_r,
11608 int* freeLocal_r,
11609 int* freeGlobal_r,
11610 int* nFreeDOF_element_u,
11611 int* freeLocal_u,
11612 int* freeGlobal_u,
11613 double sigma,
11614 double* v,
11615 double* n,
11616 double* a,
11617 double* grad_w,
11618 double* dS,
11619 double* jac)
11620{
11621 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,ii,i,k,jj,j,jacIndex,I,J,II,m,nnz=rowptr[nSpace];
11622 for (ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
11623 {
11624 ebN = interiorElementBoundaries[ebNI];
11625 left_eN_global = elementBoundaryElements[ebN*2+0];
11626 right_eN_global = elementBoundaryElements[ebN*2+1];
11627 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
11628 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
11629 /*left flux*/
11630 for(ii=0;ii<nFreeDOF_element_r[left_eN_global];ii++)
11631 {
11632 i = freeLocal_r[left_eN_global*nDOF_test_element+
11633 ii];
11634 I = offset_r + stride_r*freeGlobal_r[left_eN_global*nDOF_test_element+
11635 ii];
11636 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
11637 {
11638 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
11639 {
11640 j = freeLocal_u[left_eN_global*nDOF_trial_element+
11641 jj];
11642 J = offset_u + stride_u*freeGlobal_u[left_eN_global*nDOF_trial_element+
11643 jj];
11644 jacIndex = I+J*nFreeVDOF_global;
11645 for (II=0;II<nSpace;II++)
11646 for(m=rowptr[II];m<rowptr[II+1];m++)
11647 {
11648 jac[jacIndex]
11649 -= sigma*0.5*(v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11650 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11651 k*nDOF_trial_element+
11652 j]
11653 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11654 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11655 k*nSpace+
11656 colind[II]]
11657 *a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
11658 left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
11659 k*nnz+
11660 m]
11661 *grad_w[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11662 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11663 k*nDOF_trial_element*nSpace+
11664 i*nSpace+
11665 II]
11666 *dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11667 left_ebN_element*nQuadraturePoints_elementBoundary+
11668 k]);
11669 }
11670 }
11671 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
11672 {
11673 j = freeLocal_u[right_eN_global*nDOF_trial_element+
11674 jj];
11675 J = offset_u + stride_u*freeGlobal_u[right_eN_global*nDOF_trial_element+
11676 jj];
11677 jacIndex = I+J*nFreeVDOF_global;
11678 for (II=0;II<nSpace;II++)
11679 for (m=rowptr[II];m<rowptr[II+1];m++)
11680 {
11681 jac[jacIndex] += sigma*0.5*(v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11682 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11683 k*nDOF_trial_element+
11684 j]
11685 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11686 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11687 k*nSpace+
11688 colind[m]]
11689 *a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
11690 left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
11691 k*nnz+
11692 m]
11693 *grad_w[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11694 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11695 k*nDOF_trial_element*nSpace+
11696 i*nSpace+
11697 II]
11698 *dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11699 left_ebN_element*nQuadraturePoints_elementBoundary+
11700 k]);
11701 }
11702 }
11703 }/*k*/
11704 }/*ii*/
11705 /*right flux*/
11706 for(ii=0;ii<nFreeDOF_element_r[right_eN_global];ii++)
11707 {
11708 i = freeLocal_r[right_eN_global*nDOF_test_element+
11709 ii];
11710 I = offset_r + stride_r*freeGlobal_r[right_eN_global*nDOF_test_element+
11711 ii];
11712 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
11713 {
11714 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
11715 {
11716 j = freeLocal_u[left_eN_global*nDOF_trial_element+
11717 jj];
11718 J = offset_u + stride_u*freeGlobal_u[left_eN_global*nDOF_trial_element+
11719 jj];
11720 jacIndex = I+J*nFreeVDOF_global;
11721 for (II=0;II<nSpace;II++)
11722 for (m=rowptr[II];m<rowptr[II+1];m++)
11723 {
11724 jac[jacIndex] -= sigma*0.5*(v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11725 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11726 k*nDOF_trial_element+
11727 j]
11728 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11729 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11730 k*nSpace+
11731 colind[m]]
11732 *a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
11733 right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
11734 k*nnz+
11735 m]
11736 *grad_w[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11737 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11738 k*nDOF_trial_element*nSpace+
11739 i*nSpace+
11740 II]
11741 *dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11742 right_ebN_element*nQuadraturePoints_elementBoundary+
11743 k]);
11744 }
11745 }
11746 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
11747 {
11748 j = freeLocal_u[right_eN_global*nDOF_trial_element+
11749 jj];
11750 J = offset_u + stride_u*freeGlobal_u[right_eN_global*nDOF_trial_element+
11751 jj];
11752 jacIndex = I+J*nFreeVDOF_global;
11753 for (II=0;II<nSpace;II++)
11754 for (m=rowptr[II];m<rowptr[II+1];m++)
11755 {
11756 jac[jacIndex] += sigma*0.5*(v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11757 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11758 k*nDOF_trial_element+j]
11759 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11760 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11761 k*nSpace+
11762 colind[m]]
11763 *a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
11764 right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
11765 k*nnz+
11766 m]
11767 *grad_w[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11768 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11769 k*nDOF_trial_element*nSpace+
11770 i*nSpace+
11771 II]
11772 *dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11773 right_ebN_element*nQuadraturePoints_elementBoundary+
11774 k]);
11775 }
11776 }
11777 }
11778 }
11779 }
11780}
11781
11782void updateGlobalJacobianFromExteriorElementBoundaryDiffusionAdjoint_dense_sd(int nExteriorElementBoundaries_global,
11783 int nQuadraturePoints_elementBoundary,
11784 int nDOF_test_element,
11785 int nDOF_trial_element,
11786 int nSpace,
11787 int* rowptr,
11788 int* colind,
11789 int offset_r,
11790 int stride_r,
11791 int offset_u,
11792 int stride_u,
11793 int nFreeVDOF_global,
11794 int* exteriorElementBoundaries,
11795 int* elementBoundaryElements,
11796 int* elementBoundaryLocalElementBoundaries,
11797 int* nFreeDOF_element_r,
11798 int* freeLocal_r,
11799 int* freeGlobal_r,
11800 int* nFreeDOF_element_u,
11801 int* freeLocal_u,
11802 int* freeGlobal_u,
11803 int* isDOFBoundary,
11804 double sigma,
11805 double* v,
11806 double* n,
11807 double* a,
11808 double* grad_w,
11809 double* dS,
11810 double* jac)
11811{
11812 int ebNE,ebN,eN_global,ii,i,k,jj,j,jacIndex,I,J,II,m,nnz=rowptr[nSpace];
11813 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
11814 {
11815 ebN = exteriorElementBoundaries[ebNE];
11816 eN_global = elementBoundaryElements[ebN*2+0];
11817 for(ii=0;ii<nFreeDOF_element_r[eN_global];ii++)
11818 {
11819 i = freeLocal_r[eN_global*nDOF_test_element+
11820 ii];
11821 I = offset_r + stride_r*freeGlobal_r[eN_global*nDOF_test_element+
11822 ii];
11823 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
11824 {
11825 for(jj=0;jj<nFreeDOF_element_u[eN_global];jj++)
11826 {
11827 j = freeLocal_u[eN_global*nDOF_trial_element+
11828 jj];
11829 J = offset_u + stride_u*freeGlobal_u[eN_global*nDOF_trial_element+
11830 jj];
11831 jacIndex = I+J*nFreeVDOF_global;
11832 if (isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k])
11833 {
11834 for (II=0;II<nSpace;II++)
11835 for (m=rowptr[II];m<rowptr[II+1];m++)
11836 jac[jacIndex]
11837 -= sigma*(v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11838 k*nDOF_trial_element+
11839 j]
11840 *n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
11841 k*nSpace+
11842 colind[m]]
11843 *a[ebNE*nQuadraturePoints_elementBoundary*nnz+
11844 k*nnz+
11845 m]
11846 *grad_w[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11847 k*nDOF_trial_element*nSpace+
11848 i*nSpace+
11849 II]
11850 *dS[ebNE*nQuadraturePoints_elementBoundary+
11851 k]);
11852 }
11853 }
11854 }
11855 }
11856 }
11857}
11858void updateGlobalJacobianFromInteriorElementBoundaryDiffusionAdjoint_CSR_sd(int nInteriorElementBoundaries_global,
11859 int nElementBoundaries_element,
11860 int nQuadraturePoints_elementBoundary,
11861 int nDOF_test_element,
11862 int nDOF_trial_element,
11863 int nSpace,
11864 int* rowptr,
11865 int* colind,
11866 int offset_r,
11867 int stride_r,
11868 int offset_u,
11869 int stride_u,
11870 int nFreeVDOF_global,
11871 int* interiorElementBoundaries,
11872 int* elementBoundaryElements,
11873 int* elementBoundaryLocalElementBoundaries,
11874 int* nFreeDOF_element_r,
11875 int* freeLocal_r,
11876 int* freeGlobal_r,
11877 int* nFreeDOF_element_u,
11878 int* freeLocal_u,
11879 int* freeGlobal_u,
11880 int* csrRowIndeces_ru,
11881 int* csrColumnOffsets_eb_ru,
11882 double sigma,
11883 double* v,
11884 double* n,
11885 double* a,
11886 double* grad_w,
11887 double* dS,
11888 double* jac)
11889{
11890 int ebNI,ebN,left_eN_global,right_eN_global,left_ebN_element,right_ebN_element,ii,i,k,jj,j,jacIndex,II,m,nnz=rowptr[nSpace],nDOF_test_X_trial_element=nDOF_trial_element*nDOF_test_element;
11891 for (ebNI=0;ebNI<nInteriorElementBoundaries_global;ebNI++)
11892 {
11893 ebN = interiorElementBoundaries[ebNI];
11894 left_eN_global = elementBoundaryElements[ebN*2+0];
11895 right_eN_global = elementBoundaryElements[ebN*2+1];
11896 left_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+0];
11897 right_ebN_element = elementBoundaryLocalElementBoundaries[ebN*2+1];
11898 /*left flux*/
11899 for(ii=0;ii<nFreeDOF_element_r[left_eN_global];ii++)
11900 {
11901 i = freeLocal_r[left_eN_global*nDOF_test_element+
11902 ii];
11903 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
11904 {
11905 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
11906 {
11907 j = freeLocal_u[left_eN_global*nDOF_trial_element+
11908 jj];
11909 jacIndex = csrRowIndeces_ru[left_eN_global*nDOF_test_element+
11910 ii]
11911 +
11912 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element +
11913 0*2*nDOF_test_X_trial_element +
11914 0*nDOF_test_X_trial_element +
11915 ii*nDOF_trial_element +
11916 jj];
11917 for (II=0;II<nSpace;II++)
11918 for(m=rowptr[II];m<rowptr[II+1];m++)
11919 jac[jacIndex] -= sigma*0.5*(v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11920 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11921 k*nDOF_trial_element+
11922 j]
11923 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11924 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11925 k*nSpace+
11926 colind[m]]
11927 *a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
11928 left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
11929 k*nnz+
11930 m]
11931 *grad_w[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11932 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11933 k*nDOF_trial_element*nSpace+
11934 i*nSpace+
11935 II]
11936 *dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11937 left_ebN_element*nQuadraturePoints_elementBoundary+
11938 k]);
11939 }
11940 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
11941 {
11942 j = freeLocal_u[right_eN_global*nDOF_trial_element+
11943 jj];
11944 jacIndex = csrRowIndeces_ru[left_eN_global*nDOF_test_element+
11945 ii]
11946 +
11947 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element+
11948 0*2*nDOF_test_X_trial_element+
11949 1*nDOF_test_X_trial_element+
11950 ii*nDOF_trial_element+
11951 jj];
11952 for (II=0;II<nSpace;II++)
11953 for (m=rowptr[II];m<rowptr[II+1];m++)
11954 jac[jacIndex] += sigma*0.5*(v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11955 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11956 k*nDOF_trial_element+
11957 j]
11958 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
11959 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
11960 k*nSpace+
11961 colind[m]]
11962 *a[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
11963 left_ebN_element*nQuadraturePoints_elementBoundary*nnz+
11964 k*nnz+
11965 m]
11966 *grad_w[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11967 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
11968 k*nDOF_trial_element*nSpace+
11969 i*nSpace+
11970 II]
11971 *dS[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
11972 left_ebN_element*nQuadraturePoints_elementBoundary+
11973 k]);
11974 }
11975 }/*k*/
11976 }/*ii*/
11977 /*right flux*/
11978 for(ii=0;ii<nFreeDOF_element_r[right_eN_global];ii++)
11979 {
11980 i = freeLocal_r[right_eN_global*nDOF_test_element+
11981 ii];
11982 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
11983 {
11984 for(jj=0;jj<nFreeDOF_element_u[left_eN_global];jj++)
11985 {
11986 j = freeLocal_u[left_eN_global*nDOF_trial_element+
11987 jj];
11988 jacIndex = csrRowIndeces_ru[right_eN_global*nDOF_test_element+
11989 ii]
11990 +
11991 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element+
11992 1*2*nDOF_test_X_trial_element+
11993 0*nDOF_test_X_trial_element+
11994 ii*nDOF_trial_element+
11995 jj];
11996 for (II=0;II<nSpace;II++)
11997 for (m=rowptr[II];m<rowptr[II+1];m++)
11998 jac[jacIndex] -= sigma*0.5*(v[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
11999 left_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
12000 k*nDOF_trial_element+
12001 j]
12002 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
12003 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
12004 k*nSpace+
12005 colind[m]]
12006 *a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
12007 right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
12008 k*nnz+
12009 m]
12010 *grad_w[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
12011 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
12012 k*nDOF_trial_element*nSpace+
12013 i*nSpace+
12014 II]
12015 *dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
12016 right_ebN_element*nQuadraturePoints_elementBoundary+
12017 k]);
12018 }
12019 for(jj=0;jj<nFreeDOF_element_u[right_eN_global];jj++)
12020 {
12021 j = freeLocal_u[right_eN_global*nDOF_trial_element+
12022 jj];
12023 jacIndex = csrRowIndeces_ru[right_eN_global*nDOF_test_element+
12024 ii]
12025 +
12026 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element+
12027 1*2*nDOF_test_X_trial_element+
12028 1*nDOF_test_X_trial_element+
12029 ii*nDOF_trial_element+
12030 jj];
12031 for (II=0;II<nSpace;II++)
12032 for (m=rowptr[II];m<rowptr[II+1];m++)
12033 jac[jacIndex] += sigma*0.5*(v[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
12034 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element+
12035 k*nDOF_trial_element+j]
12036 *n[left_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace+
12037 left_ebN_element*nQuadraturePoints_elementBoundary*nSpace+
12038 k*nSpace+
12039 colind[m]]
12040 *a[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nnz+
12041 right_ebN_element*nQuadraturePoints_elementBoundary*nnz+
12042 k*nnz+
12043 m]
12044 *grad_w[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
12045 right_ebN_element*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
12046 k*nDOF_trial_element*nSpace+
12047 i*nSpace+
12048 II]
12049 *dS[right_eN_global*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
12050 right_ebN_element*nQuadraturePoints_elementBoundary+
12051 k]);
12052 }
12053 }
12054 }
12055 }
12056}
12057
12058void updateGlobalJacobianFromExteriorElementBoundaryDiffusionAdjoint_CSR_sd(int nExteriorElementBoundaries_global,
12059 int nQuadraturePoints_elementBoundary,
12060 int nDOF_test_element,
12061 int nDOF_trial_element,
12062 int nSpace,
12063 int* rowptr,
12064 int* colind,
12065 int offset_r,
12066 int stride_r,
12067 int offset_u,
12068 int stride_u,
12069 int nFreeVDOF_global,
12070 int* exteriorElementBoundaries,
12071 int* elementBoundaryElements,
12072 int* elementBoundaryLocalElementBoundaries,
12073 int* nFreeDOF_element_r,
12074 int* freeLocal_r,
12075 int* freeGlobal_r,
12076 int* nFreeDOF_element_u,
12077 int* freeLocal_u,
12078 int* freeGlobal_u,
12079 int* csrRowIndeces_ru,
12080 int* csrColumnOffsets_eb_ru,
12081 int* isDOFBoundary,
12082 double sigma,
12083 double* v,
12084 double* n,
12085 double* a,
12086 double* grad_w,
12087 double* dS,
12088 double* jac)
12089{
12090 int ebNE,ebN,eN_global,ii,i,k,jj,j,jacIndex,II,m,nnz=rowptr[nSpace],nDOF_test_X_trial_element=nDOF_trial_element*nDOF_test_element;
12091 for (ebNE=0;ebNE<nExteriorElementBoundaries_global;ebNE++)
12092 {
12093 ebN = exteriorElementBoundaries[ebNE];
12094 eN_global = elementBoundaryElements[ebN*2+0];
12095 for(ii=0;ii<nFreeDOF_element_r[eN_global];ii++)
12096 {
12097 i = freeLocal_r[eN_global*nDOF_test_element+
12098 ii];
12099 for(k=0;k<nQuadraturePoints_elementBoundary;k++)
12100 {
12101 for(jj=0;jj<nFreeDOF_element_u[eN_global];jj++)
12102 {
12103 j = freeLocal_u[eN_global*nDOF_trial_element+
12104 jj];
12105 jacIndex = csrRowIndeces_ru[eN_global*nDOF_test_element+
12106 ii]
12107 +
12108 csrColumnOffsets_eb_ru[ebN*4*nDOF_test_X_trial_element +
12109 0*2*nDOF_test_X_trial_element +
12110 0*nDOF_test_X_trial_element +
12111 ii*nDOF_trial_element +
12112 jj];
12113 if (isDOFBoundary[ebNE*nQuadraturePoints_elementBoundary+k])
12114 {
12115 for (II=0;II<nSpace;II++)
12116 for (m=rowptr[II];m<rowptr[II+1];m++)
12117 jac[jacIndex]
12118 -= sigma*(v[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element+
12119 k*nDOF_trial_element+
12120 j]
12121 *n[ebNE*nQuadraturePoints_elementBoundary*nSpace+
12122 k*nSpace+
12123 colind[m]]
12124 *a[ebNE*nQuadraturePoints_elementBoundary*nnz+
12125 k*nnz+
12126 m]
12127 *grad_w[ebNE*nQuadraturePoints_elementBoundary*nDOF_trial_element*nSpace+
12128 k*nDOF_trial_element*nSpace+
12129 i*nSpace+
12130 II]
12131 *dS[ebNE*nQuadraturePoints_elementBoundary+
12132 k]);
12133 }
12134 }
12135 }
12136 }
12137 }
12138}
12139
12140void update_f_movingDomain_q(int nElements_global,
12141 int nQuadraturePoints_element,
12142 int nSpace,
12143 double* xt,
12144 double* m,
12145 double* f)
12146{
12147 int eN,k,I;
12148 for(eN=0;eN<nElements_global;eN++)
12149 for (k=0;k<nQuadraturePoints_element;k++)
12150 for (I=0;I<nSpace;I++)
12151 f[eN*nQuadraturePoints_element*nSpace +
12152 k*nSpace +
12153 I]
12154 -=
12155 m[eN*nQuadraturePoints_element +
12156 k]
12157 *
12158 xt[eN*nQuadraturePoints_element*3 +
12159 k*3 +
12160 I];
12161}
12162
12163void update_f_movingDomain_constantMass_q(int nElements_global,
12164 int nQuadraturePoints_element,
12165 int nSpace,
12166 double* xt,
12167 double* f)
12168{
12169 int eN,k,I;
12170 for(eN=0;eN<nElements_global;eN++)
12171 for (k=0;k<nQuadraturePoints_element;k++)
12172 for (I=0;I<nSpace;I++)
12173 f[eN*nQuadraturePoints_element*nSpace +
12174 k*nSpace +
12175 I]
12176 -=
12177 xt[eN*nQuadraturePoints_element*3 +
12178 k*3 +
12179 I];
12180}
12181
12182void update_f_movingDomain_ebq(int nElements_global,
12183 int nElementBoundaries_element,
12184 int nQuadraturePoints_elementBoundary,
12185 int nSpace,
12186 double* xt,
12187 double* m,
12188 double* f)
12189{
12190 int eN,ebN,k,I;
12191 for(eN=0;eN<nElements_global;eN++)
12192 for(ebN=0;ebN<nElementBoundaries_element;ebN++)
12193 for (k=0;k<nQuadraturePoints_elementBoundary;k++)
12194 for (I=0;I<nSpace;I++)
12195 f[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace +
12196 ebN*nQuadraturePoints_elementBoundary*nSpace+
12197 k*nSpace +
12198 I]
12199 -=
12200 m[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary+
12201 ebN*nQuadraturePoints_elementBoundary+
12202 k]
12203 *
12204 xt[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*3+
12205 ebN*nQuadraturePoints_elementBoundary*3+
12206 k*3 +
12207 I];
12208}
12209
12210void update_f_movingDomain_constantMass_ebq(int nElements_global,
12211 int nElementBoundaries_element,
12212 int nQuadraturePoints_elementBoundary,
12213 int nSpace,
12214 double* xt,
12215 double* f)
12216{
12217 int eN,ebN,k,I;
12218 for(eN=0;eN<nElements_global;eN++)
12219 for(ebN=0;ebN<nElementBoundaries_element;ebN++)
12220 for (k=0;k<nQuadraturePoints_elementBoundary;k++)
12221 for (I=0;I<nSpace;I++)
12222 f[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*nSpace +
12223 ebN*nQuadraturePoints_elementBoundary*nSpace+
12224 k*nSpace +
12225 I]
12226 -=
12227 xt[eN*nElementBoundaries_element*nQuadraturePoints_elementBoundary*3+
12228 ebN*nQuadraturePoints_elementBoundary*3+
12229 k*3 +
12230 I];
12231}
12232
12233void updateStress_weak(int nElements_global,
12234 int nQuadraturePoints_element,
12235 int nDOF_test_element,
12236 int nSpace,
12237 double* sigma,
12238 double* grad_w_dV,
12239 double* weak_residual_x,
12240 double* weak_residual_y,
12241 double* weak_residual_z)
12242{
12243 int eN,i,k,I,J,nSpace2=nSpace*nSpace;
12244 for(eN=0;eN<nElements_global;eN++)
12245 for (i=0;i<nDOF_test_element;i++)
12246 for (k=0;k<nQuadraturePoints_element;k++)
12247 for (J=0;J<nSpace;J++)
12248 {
12249 I=0;
12250 weak_residual_x[eN*nDOF_test_element + i]
12251 +=
12252 sigma[eN*nQuadraturePoints_element*nSpace2+
12253 k*nSpace2 +
12254 I*nSpace+
12255 J]
12256 *
12257 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
12258 k*nDOF_test_element*nSpace +
12259 i*nSpace+
12260 J];
12261 I=1;
12262 weak_residual_y[eN*nDOF_test_element + i]
12263 +=
12264 sigma[eN*nQuadraturePoints_element*nSpace2+
12265 k*nSpace2 +
12266 I*nSpace+
12267 J]
12268 *
12269 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
12270 k*nDOF_test_element*nSpace +
12271 i*nSpace+
12272 J];
12273 I=2;
12274 weak_residual_z[eN*nDOF_test_element + i]
12275 +=
12276 sigma[eN*nQuadraturePoints_element*nSpace2+
12277 k*nSpace2 +
12278 I*nSpace+
12279 J]
12280 *
12281 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
12282 k*nDOF_test_element*nSpace +
12283 i*nSpace+
12284 J];
12285 }
12286}
12287
12288void updateStressJacobian_weak(int nElements_global,
12289 int nQuadraturePoints_element,
12290 int nDOF_trial_element,
12291 int nDOF_test_element,
12292 int nSpace,
12293 double* dsigma_xx,
12294 double* dsigma_xy,
12295 double* dsigma_xz,
12296 double* dsigma_yx,
12297 double* dsigma_yy,
12298 double* dsigma_yz,
12299 double* dsigma_zx,
12300 double* dsigma_zy,
12301 double* dsigma_zz,
12302 double* grad_v,
12303 double* grad_w_dV,
12304 double* jacobian_weak_residual_xx,
12305 double* jacobian_weak_residual_xy,
12306 double* jacobian_weak_residual_xz,
12307 double* jacobian_weak_residual_yx,
12308 double* jacobian_weak_residual_yy,
12309 double* jacobian_weak_residual_yz,
12310 double* jacobian_weak_residual_zx,
12311 double* jacobian_weak_residual_zy,
12312 double* jacobian_weak_residual_zz)
12313{
12314 int eN,i,j,k,I,J,nDOF_test_X_trial_element=nDOF_test_element*nDOF_trial_element,nSpace2=nSpace*nSpace;
12315 for(eN=0;eN<nElements_global;eN++)
12316 for (i=0;i<nDOF_test_element;i++)
12317 for (k=0;k<nQuadraturePoints_element;k++)
12318 for (j=0;j<nDOF_trial_element;j++)
12319 for (I=0;I<nSpace;I++)
12320 for(J=0;J<nSpace;J++)
12321 {
12322 //x
12323 jacobian_weak_residual_xx[eN*nDOF_test_X_trial_element +
12324 i*nDOF_trial_element +
12325 j]
12326 +=
12327 dsigma_xx[eN*nQuadraturePoints_element*nSpace2 +
12328 k*nSpace2+
12329 I*nSpace+
12330 J]
12331 *
12332 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
12333 k*nDOF_trial_element*nSpace +
12334 j*nSpace +
12335 J]
12336 *
12337 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
12338 k*nDOF_test_element*nSpace +
12339 i*nSpace +
12340 I];
12341 jacobian_weak_residual_xy[eN*nDOF_test_X_trial_element +
12342 i*nDOF_trial_element +
12343 j]
12344 +=
12345 dsigma_xy[eN*nQuadraturePoints_element*nSpace2 +
12346 k*nSpace2+
12347 I*nSpace+
12348 J]
12349 *
12350 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
12351 k*nDOF_trial_element*nSpace +
12352 j*nSpace +
12353 J]
12354 *
12355 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
12356 k*nDOF_test_element*nSpace +
12357 i*nSpace +
12358 I];
12359 jacobian_weak_residual_xz[eN*nDOF_test_X_trial_element +
12360 i*nDOF_trial_element +
12361 j]
12362 +=
12363 dsigma_xz[eN*nQuadraturePoints_element*nSpace2 +
12364 k*nSpace2+
12365 I*nSpace+
12366 J]
12367 *
12368 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
12369 k*nDOF_trial_element*nSpace +
12370 j*nSpace +
12371 J]
12372 *
12373 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
12374 k*nDOF_test_element*nSpace +
12375 i*nSpace +
12376 I];
12377 //y
12378 jacobian_weak_residual_yx[eN*nDOF_test_X_trial_element +
12379 i*nDOF_trial_element +
12380 j]
12381 +=
12382 dsigma_yx[eN*nQuadraturePoints_element*nSpace2 +
12383 k*nSpace2+
12384 I*nSpace+
12385 J]
12386 *
12387 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
12388 k*nDOF_trial_element*nSpace +
12389 j*nSpace +
12390 J]
12391 *
12392 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
12393 k*nDOF_test_element*nSpace +
12394 i*nSpace +
12395 I];
12396 jacobian_weak_residual_yy[eN*nDOF_test_X_trial_element +
12397 i*nDOF_trial_element +
12398 j]
12399 +=
12400 dsigma_yy[eN*nQuadraturePoints_element*nSpace2 +
12401 k*nSpace2+
12402 I*nSpace+
12403 J]
12404 *
12405 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
12406 k*nDOF_trial_element*nSpace +
12407 j*nSpace +
12408 J]
12409 *
12410 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
12411 k*nDOF_test_element*nSpace +
12412 i*nSpace +
12413 I];
12414 jacobian_weak_residual_yz[eN*nDOF_test_X_trial_element +
12415 i*nDOF_trial_element +
12416 j]
12417 +=
12418 dsigma_yz[eN*nQuadraturePoints_element*nSpace2 +
12419 k*nSpace2+
12420 I*nSpace+
12421 J]
12422 *
12423 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
12424 k*nDOF_trial_element*nSpace +
12425 j*nSpace +
12426 J]
12427 *
12428 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
12429 k*nDOF_test_element*nSpace +
12430 i*nSpace +
12431 I];
12432 //z
12433 jacobian_weak_residual_zx[eN*nDOF_test_X_trial_element +
12434 i*nDOF_trial_element +
12435 j]
12436 +=
12437 dsigma_zx[eN*nQuadraturePoints_element*nSpace2 +
12438 k*nSpace2+
12439 I*nSpace+
12440 J]
12441 *
12442 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
12443 k*nDOF_trial_element*nSpace +
12444 j*nSpace +
12445 J]
12446 *
12447 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
12448 k*nDOF_test_element*nSpace +
12449 i*nSpace +
12450 I];
12451 jacobian_weak_residual_zy[eN*nDOF_test_X_trial_element +
12452 i*nDOF_trial_element +
12453 j]
12454 +=
12455 dsigma_zy[eN*nQuadraturePoints_element*nSpace2 +
12456 k*nSpace2+
12457 I*nSpace+
12458 J]
12459 *
12460 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
12461 k*nDOF_trial_element*nSpace +
12462 j*nSpace +
12463 J]
12464 *
12465 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
12466 k*nDOF_test_element*nSpace +
12467 i*nSpace +
12468 I];
12469 jacobian_weak_residual_zz[eN*nDOF_test_X_trial_element +
12470 i*nDOF_trial_element +
12471 j]
12472 +=
12473 dsigma_zz[eN*nQuadraturePoints_element*nSpace2 +
12474 k*nSpace2+
12475 I*nSpace+
12476 J]
12477 *
12478 grad_v[eN*nQuadraturePoints_element*nDOF_trial_element*nSpace +
12479 k*nDOF_trial_element*nSpace +
12480 j*nSpace +
12481 J]
12482 *
12483 grad_w_dV[eN*nQuadraturePoints_element*nDOF_test_element*nSpace +
12484 k*nDOF_test_element*nSpace +
12485 i*nSpace +
12486 I];
12487 }
12488}
12489
12490/*load nodal degrees of freedom from an element based set of interpolation values*/
12491void projectFromNodalInterpolationConditions(int nElements_global,
12492 int nDOF_element,
12493 int dim_dof,
12494 const int * l2g,
12495 const int * functional_map_element,
12496 const double * interpolationValues,
12497 double * dofs)
12498{
12499 int eN,i,j,k;
12500
12501 // printf("dim_dof = %d, nDOF_element = %d\n",dim_dof,nDOF_element);
12502 for (eN = 0; eN < nElements_global; eN++)
12503 {
12504 for (i=0; i < nDOF_element; i++)
12505 {
12506 k = functional_map_element[i]; /*dof i maps to interp value k locally*/
12507 // printf("eN=%d, k=%d, i=%d\n",eN,k,i);
12508 for (j=0; j < dim_dof; j++)
12509 {
12510 // printf("l2g[%d]= %d \n", eN*nDOF_element+i, l2g[eN*nDOF_element+i]);
12511 // printf("l2g[%d]*%d+%d = %d \n", eN*nDOF_element+i, dim_dof, j, l2g[eN*nDOF_element+i]*dim_dof + j);
12512 // printf("interpolationValues[eN*nDOF_element*dim_dof + k*dim_dof + j] = %.2f \n", interpolationValues[eN*nDOF_element*dim_dof + k*dim_dof + j]);
12513 dofs[l2g[eN*nDOF_element+i]*dim_dof + j] = interpolationValues[eN*nDOF_element*dim_dof + k*dim_dof + j];
12514
12515 }
12516 }
12517 }
12518}
12519
n
Int n
Definition Headers.h:28
L
Double L
Definition Headers.h:72
r
Double r
Definition Headers.h:83
H
Double H
Definition Headers.h:65
f
Double f
Definition Headers.h:64
s
Double s
Definition Headers.h:84
u
Double u
Definition Headers.h:89
num
Int num
Definition Headers.h:32
Y
Double * Y
Definition Headers.h:48
v
Double v
Definition Headers.h:95
phi
Double phi
Definition Headers.h:76
psi
Double psi
Definition Headers.h:78
pe
Double pe
Definition Headers.h:75
updateGlobalExteriorElementBoundaryDiffusiveVelocity_sd
void updateGlobalExteriorElementBoundaryDiffusiveVelocity_sd(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nSpace, int *rowptr, int *colind, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *a, double *grad_phi, double *velocity)
Definition femIntegrals.c:8042
calculateVelocityQuadrature_MixedForm2_Jacobian
void calculateVelocityQuadrature_MixedForm2_Jacobian(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, int nSpace, int nQuadraturePoints_element, double *qa, double *qw_dV, double *db, double *db_eb, double *v, double *DV, double *DV_eb, double *qv, double *qDV, double *qDV_eb)
Definition femIntegrals.c:9737
TR_ALPHA_EXT
#define TR_ALPHA_EXT
Definition femIntegrals.c:8667
updateGlobalExteriorElementBoundaryStressFlux
void updateGlobalExteriorElementBoundaryStressFlux(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *stressFlux, double *w_dS, double *residual)
Definition femIntegrals.c:4406
calculateVelocityQuadrature_MixedForm2_vdof_sd
void calculateVelocityQuadrature_MixedForm2_vdof_sd(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, int nSpace, int nQuadraturePoints_element, const int *rowptr, const int *colind, double *qa, double *qw_dV, double *b, double *v, double *V, double *qv, double *qV, double *vel_dofs)
Definition femIntegrals.c:9440
TR_ALPHA
#define TR_ALPHA
Definition femIntegrals.c:8666
updatePotential_MixedForm_weak_gwvd
void updatePotential_MixedForm_weak_gwvd(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double epsilon, double *phi, double *w_dV, double *grad_w_dV, double *b, double *mf)
Definition femIntegrals.c:9080
parametricMaps_getJacobianValuesTrace2D_movingDomain
void parametricMaps_getJacobianValuesTrace2D_movingDomain(int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_element, int nDOF_element, double *xtArray, double *grad_psi, double *boundaryNormals, double *boundaryJacobians, int *l2g, double *nodeArray, double *jacobianInverseArray, double *metricTensorArray, double *metricTensorDeterminantSqrtArray, double *unitNormalArray)
Definition femIntegrals.c:1187
calculateWeightedPiolaShapeTrace
void calculateWeightedPiolaShapeTrace(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_test_element, double *dSR, double *sqrt_det_g, double *w, double *w_dS)
Definition femIntegrals.c:6718
copyLeftElementBoundaryInfo_movingDomain
void copyLeftElementBoundaryInfo_movingDomain(int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nExteriorElementBoundaries_global, int nInteriorElementBoundaries_global, int *elementBoundaryElementsArray, int *elementBoundaryLocalElementBoundariesArray, int *exteriorElementBoundariesArray, int *interiorElementBoundariesArray, double *xt)
Definition femIntegrals.c:222
calculateVelocityQuadrature_MixedForm2
void calculateVelocityQuadrature_MixedForm2(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, int nSpace, int nQuadraturePoints_element, double *qa, double *qw_dV, double *b, double *v, double *V, double *qv, double *qV)
Definition femIntegrals.c:9224
calculateWeightedPiolaShapeGradients
void calculateWeightedPiolaShapeGradients(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *dVR, double *abs_det_jac, double *grad_w, double *grad_w_dV)
THIS SHOULD BE REMOVED BEFORE MERGE.
Definition femIntegrals.c:6487
accumulateExteriorElementPressureIntegrals
void accumulateExteriorElementPressureIntegrals(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int *elementBoundaryMaterialTypes, int *exteriorElementBoundaries, double *p, double *dS, double *P, double *boundaryMeasure)
Definition femIntegrals.c:4632
copyGlobalElementBoundaryInfo
void copyGlobalElementBoundaryInfo(int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nSpace_global, int nExteriorElementBoundaries_global, int nInteriorElementBoundaries_global, int *elementBoundaryElementsArray, int *elementBoundaryLocalElementBoundariesArray, int *exteriorElementBoundariesArray, int *interiorElementBoundariesArray, double *x, double *n, double *ebqe_x, double *ebqe_n, double *xg, double *ng)
Definition femIntegrals.c:109
femIntegrals.h
A library of functions for computing the discrete finite element formulations.
df
double df(double C, double b, double a, int q, int r)
Definition analyticalSolutions.c:2209
updateInteriorElementBoundaryDiffusiveVelocity_sd
void updateInteriorElementBoundaryDiffusiveVelocity_sd(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, int *rowptr, int *colind, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *a, double *grad_phi, double *velocity)
Definition femIntegrals.c:7869
parametricMaps_getJacobianValuesGlobalExteriorTrace2D
void parametricMaps_getJacobianValuesGlobalExteriorTrace2D(int nQuadraturePoints_element, int nDOF_element, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, double *grad_psi, double *boundaryNormals, double *boundaryJacobians, int *l2g, double *nodeArray, double *jacobianInverseArray, double *metricTensorArray, double *metricTensorDeterminantSqrtArray, double *unitNormalArray)
Definition femIntegrals.c:1389
calculateWeightedShapeHessians
void calculateWeightedShapeHessians(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *dVR, double *abs_det_jac, double *Hess_w, double *Hess_w_dV)
Definition femIntegrals.c:6515
calculateFiniteElementFunctionGradientValues
void calculateFiniteElementFunctionGradientValues(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nComponents, int nSpace, int *l2g, double *dof, double *grad_v, double *grad_u)
Calculate the gradient values of a multicomponent finite element function at the quadrature points fr...
Definition femIntegrals.c:7027
updateDiffusion_MixedForm_weak_sd
void updateDiffusion_MixedForm_weak_sd(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, int rho_split, int *rowptr, int *colind, double *a, double *qV, double *grad_w_dV, double *velocity, double *weak_residual)
Definition femIntegrals.c:10183
update_f_movingDomain_ebq
void update_f_movingDomain_ebq(int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, double *xt, double *m, double *f)
Definition femIntegrals.c:12182
parametricMaps_getJacobianValuesGlobalExteriorTrace1D
void parametricMaps_getJacobianValuesGlobalExteriorTrace1D(int nQuadraturePoints_element, int nDOF_element, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, double *grad_psi, double *boundaryNormals, double *boundaryJacobians, int *l2g, double *nodeArray, double *jacobianInverseArray, double *metricTensorArray, double *metricTensorDeterminantSqrtArray, double *unitNormalArray)
Definition femIntegrals.c:1331
updateGlobalJacobianFromExteriorElementBoundaryFluxJacobian_dense
void updateGlobalJacobianFromExteriorElementBoundaryFluxJacobian_dense(int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, double *elementBoundaryFluxJacobian, double *w_dS, double *jac)
Update the global dense Jacobian from the element boundary flux Jacobians at exterior boundaries.
Definition femIntegrals.c:5259
calculateWeightedShapeGradients
void calculateWeightedShapeGradients(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *dVR, double *abs_det_jac, double *grad_w, double *grad_w_dV)
Weight the test function with the integration weights.
Definition femIntegrals.c:6456
updateDiffusion_adjoint
void updateDiffusion_adjoint(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *da, double *grad_phi, double *grad_w_dV, double *Lstar_w_dV)
Loop over all the elements and update the linearized adjoint applied to the weighted test function wi...
Definition femIntegrals.c:3358
updateDiffusionJacobian2_strong
void updateDiffusionJacobian2_strong(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nSpace, int *l2g, double *a, double *da, double *v, double *Hess_phi, double *dphi, double *Hess_v, double *dstrong_residual)
Definition femIntegrals.c:3484
updateHamiltonianJacobian_weak_lowmem
void updateHamiltonianJacobian_weak_lowmem(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, double *dH, double *grad_v, double *w_dV, double *jacobian_weak_residual)
Definition femIntegrals.c:2416
updateGlobalJacobianFromExteriorElementBoundaryFluxJacobian_eb_dense
void updateGlobalJacobianFromExteriorElementBoundaryFluxJacobian_eb_dense(int *elementNeighbors, int nElements_global, int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, double *elementBoundaryFluxJacobian_eb, double *w_dS, double *jac)
Update the global dense Jacobian from the element boundary flux Jacobians at exterior boundaries.
Definition femIntegrals.c:5323
updateGlobalJacobianFromExteriorElementBoundaryDiffusionAdjoint_CSR_sd
void updateGlobalJacobianFromExteriorElementBoundaryDiffusionAdjoint_CSR_sd(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int nSpace, int *rowptr, int *colind, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, int *csrRowIndeces_ru, int *csrColumnOffsets_eb_ru, int *isDOFBoundary, double sigma, double *v, double *n, double *a, double *grad_w, double *dS, double *jac)
Definition femIntegrals.c:12058
updateHamiltonian_adjoint
void updateHamiltonian_adjoint(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *dH, double *grad_w_dV, double *Lstar_w_dV)
Loop over all the elements and update the linearized adjoint applied to the weighted test functions w...
Definition femIntegrals.c:2580
scalarDomainIntegral
double scalarDomainIntegral(int nElements, int nQuadraturePoints_element, double *dV, double *nValueArray)
Definition femIntegrals.c:10682
updateMass_adjoint
void updateMass_adjoint(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, double *dmt, double *w_dV, double *Lstar_w_dV)
Loop over all the elements and update the linearized adjoint, applied to the weighted test functions,...
Definition femIntegrals.c:1935
updateExteriorElementBoundaryDiffusionAdjoint_sd
void updateExteriorElementBoundaryDiffusionAdjoint_sd(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nSpace, int *rowptr, int *colind, int *isDOFBoundary, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double sigma, double *u, double *ub, double *n, double *a, double *grad_w, double *dS, double *residual)
Definition femIntegrals.c:11534
calculateFiniteElementFunctionGradientTensorValues
void calculateFiniteElementFunctionGradientTensorValues(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nComponents, int nSpace, int *l2g, double *dof, double *grad_v_X_grad_w_dV, double *grad_u_X_grad_w_dV)
Loop over all the quadrature points and calculate the tensor product of the solution gradient with th...
Definition femIntegrals.c:7138
parametricMaps_getJacobianValuesGlobalExteriorTrace2D_movingDomain
void parametricMaps_getJacobianValuesGlobalExteriorTrace2D_movingDomain(int nQuadraturePoints_element, int nDOF_element, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, double *xtArray, double *grad_psi, double *boundaryNormals, double *boundaryJacobians, int *l2g, double *nodeArray, double *jacobianInverseArray, double *metricTensorArray, double *metricTensorDeterminantSqrtArray, double *unitNormalArray)
Definition femIntegrals.c:1469
fluxDomainBoundaryIntegral
double fluxDomainBoundaryIntegral(int nExteriorElementBoundaries, int nElementBoundaries_owned, int nQuadraturePoints_elementBoundary, int *flag, int *exteriorElementBoundariesArray, double *dS, double *nValueArray)
Definition femIntegrals.c:10745
updateInteriorElementBoundaryShockCapturingVelocity
void updateInteriorElementBoundaryShockCapturingVelocity(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nQuadraturePoints_element, int nSpace, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *numDiff, double *grad_u, double *velocity)
Calculate the velocity from shock capturing at interior element boundary quadrature points.
Definition femIntegrals.c:8190
updateExteriorElementBoundary_MixedForm_weak
void updateExteriorElementBoundary_MixedForm_weak(int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nSpace, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *n, double *phi_trace, double *w_dS, double *b)
Update the element boundary flux on exterior element boundaries.
Definition femIntegrals.c:8958
updateGlobalJacobianFromInteriorElementBoundaryDiffusionAdjoint_dense
void updateGlobalJacobianFromInteriorElementBoundaryDiffusionAdjoint_dense(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int nSpace, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, double sigma, double *v, double *n, double *a, double *grad_w, double *dS, double *jac)
Definition femIntegrals.c:11188
parametricMaps_getJacobianValuesTrace1D
void parametricMaps_getJacobianValuesTrace1D(int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_element, int nDOF_element, double *grad_psi, double *boundaryNormals, double *boundaryJacobians, int *l2g, double *nodeArray, double *jacobianInverseArray, double *metricTensorArray, double *metricTensorDeterminantSqrtArray, double *unitNormalArray)
Definition femIntegrals.c:1274
updateGlobalJacobianFromExteriorElementBoundaryDiffusionAdjoint_dense_sd
void updateGlobalJacobianFromExteriorElementBoundaryDiffusionAdjoint_dense_sd(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int nSpace, int *rowptr, int *colind, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, int *isDOFBoundary, double sigma, double *v, double *n, double *a, double *grad_w, double *dS, double *jac)
Definition femIntegrals.c:11782
calculateCFLADR2speeds
void calculateCFLADR2speeds(int nElements_global, int nQuadraturePoints_element, int nSpace, double *elementDiameter, double *dm, double *df1, double *df2, double *cfl)
Definition femIntegrals.c:7766
updateInteriorElementBoundaryAdvectiveVelocity
void updateInteriorElementBoundaryAdvectiveVelocity(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *f, double *velocity)
Calculate the advective flux at at interior element boundaries.
Definition femIntegrals.c:8080
updateGlobalJacobianFromGlobalExteriorElementBoundaryFluxJacobian_dense
void updateGlobalJacobianFromGlobalExteriorElementBoundaryFluxJacobian_dense(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, double *elementBoundaryFluxJacobian, double *w_dS, double *jac)
Update the global dense Jacobian from the element boundary flux Jacobians at exterior boundaries.
Definition femIntegrals.c:5500
getPermutationsGlobal
void getPermutationsGlobal(int nElementBoundaries_global, int nElementBoundaryQuadraturePoints_elementBoundary, double *xArray, double *xArrayNew, int *permutations)
Definition femIntegrals.c:556
calculateIntegrationWeights
void calculateIntegrationWeights(int nElements_global, int nQuadraturePoints_element, double *abs_det_J, double *referenceWeights, double *weights)
Calculate the physical space integration weights from the reference element weights and Jacobian dete...
Definition femIntegrals.c:6935
checkElementBoundaryAndExteriorElementBoundaryArraysSame
int checkElementBoundaryAndExteriorElementBoundaryArraysSame(int nElementBoundaries_element, int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nValuesPerQuadraturePoint, double tolerance, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, const double *ebq_val, const double *ebqe_val, int *firstBadIndex)
Definition femIntegrals.c:10927
computeC0P1InterpolantDGP12
void computeC0P1InterpolantDGP12(int nElements_global, int nNodes_global, int nNodes_element, int nDOF_element, int dim_dof, const int *elementNodesArray, const int *nodeElementOffsets, const int *nodeElementsArray, const int *l2g, const double *dof, double *nodalAverage)
Definition femIntegrals.c:10803
updateGlobalExteriorElementBoundaryFlux
void updateGlobalExteriorElementBoundaryFlux(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *flux, double *w_dS, double *residual)
Definition femIntegrals.c:4375
updateReactionJacobian_weak
void updateReactionJacobian_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, double *dr, double *v_X_w_dV, double *jacobian_weak_residual)
Loop over all the elements and update the element Jacobian with the numerical quadrature approximatio...
Definition femIntegrals.c:3743
updateStress_weak
void updateStress_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *sigma, double *grad_w_dV, double *weak_residual_x, double *weak_residual_y, double *weak_residual_z)
Definition femIntegrals.c:12233
updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_2sided_dense
void updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_2sided_dense(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, double *elementBoundaryFluxJacobian_2sided, double *w_dS, double *jac)
Update the global dense Jacobian from the element boundary two-sided Hamiltonflux Jacobians at interi...
Definition femIntegrals.c:5123
parametricMaps_getInverseValuesTrace
void parametricMaps_getInverseValuesTrace(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, int nSpace_global, double *inverseJacobian, int *l2g, double *nodeArray, double *xArray, double *xiArray)
Definition femIntegrals.c:736
calculateGradShape_X_weightedShape
void calculateGradShape_X_weightedShape(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, double *grad_v, double *w_dV, double *grad_v_X_w_dV)
Calculate the tensor product of trial function gradients and test functions at the quadrature points.
Definition femIntegrals.c:6615
calculateVelocityQuadrature_MixedForm
void calculateVelocityQuadrature_MixedForm(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, int nSpace, int nQuadraturePoints_element, double *A_inv, double *b, double *v, double *V, double *qv, double *qV)
Definition femIntegrals.c:9150
updateSubgridErrorJacobian
void updateSubgridErrorJacobian(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, double *derror, double *Lstar_w_dV, double *jacobian_weak_residual)
Loop over all the elements and update the element Jacobian with the numerical quadrature approximatio...
Definition femIntegrals.c:3983
updateGlobalJacobianFromExteriorElementBoundaryDiffusionAdjoint_dense
void updateGlobalJacobianFromExteriorElementBoundaryDiffusionAdjoint_dense(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int nSpace, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, int *isDOFBoundary, double sigma, double *v, double *n, double *a, double *grad_w, double *dS, double *jac)
Definition femIntegrals.c:11372
updateGlobalExteriorElementBoundaryAdvectiveVelocity
void updateGlobalExteriorElementBoundaryAdvectiveVelocity(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nSpace, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *f, double *velocity)
Update the advective flux at exterior element boundaries.
Definition femIntegrals.c:8161
updateInteriorTwoSidedElementBoundaryFlux
void updateInteriorTwoSidedElementBoundaryFlux(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *flux, double *w_dS, double *residual)
Update a two-sided (say nonconservative HJ flux) element boundary flux on interior element boundaries...
Definition femIntegrals.c:4438
parametricMaps_getValuesGlobalExteriorTrace
void parametricMaps_getValuesGlobalExteriorTrace(int nQuadraturePoints_elementBoundary, int nDOF_element, int nSpace_global, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, double *psi, int *l2g, double *nodeArray, double *xArray)
Definition femIntegrals.c:658
calculateScalarScalarProduct
void calculateScalarScalarProduct(int nElements_global, int nQuadraturePoints_element, double *s1, double *s2, double *sResult)
Calculate the product of two scalars at the quadrature points.
Definition femIntegrals.c:4212
calculateGlobalExteriorElementBoundaryIntegrationWeights
void calculateGlobalExteriorElementBoundaryIntegrationWeights(int nQuadraturePoints_elementBoundary, int nExteriorElementBoundaries_global, double *sqrt_det_g, double *referenceWeights, double *weights)
Definition femIntegrals.c:6975
calculateFiniteElementFunctionHessianValues
void calculateFiniteElementFunctionHessianValues(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nComponents, int nSpace, int *l2g, double *dof, double *Hessian_v, double *Hessian_u)
Definition femIntegrals.c:7059
updateGlobalJacobianFromInteriorElementBoundaryDiffusionAdjoint_CSR_sd
void updateGlobalJacobianFromInteriorElementBoundaryDiffusionAdjoint_CSR_sd(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int nSpace, int *rowptr, int *colind, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, int *csrRowIndeces_ru, int *csrColumnOffsets_eb_ru, double sigma, double *v, double *n, double *a, double *grad_w, double *dS, double *jac)
Definition femIntegrals.c:11858
copyGlobalUnknownsToFreeUnknowns
void copyGlobalUnknownsToFreeUnknowns(int nDOF2set, int offset, int stride, const int *globalDOFids, const int *freeDOFids, const double *u, double *free_u)
Definition femIntegrals.c:11030
updateExteriorElementBoundary_MixedForm_weakJacobian
void updateExteriorElementBoundary_MixedForm_weakJacobian(int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nSpace, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *n, double *dphi_trace_left, double *v, double *w_dS, double *db, double *db_eb)
Update the element boundary flux on interior element boundaries.
Definition femIntegrals.c:9002
calculateFiniteElementFunctionValues
void calculateFiniteElementFunctionValues(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nComponents, int *l2g, double *dof, double *v, double *u)
Calculate the values of a multicomponent finite element function at the quadrature points from the de...
Definition femIntegrals.c:6996
updateDiffusionJacobian_MixedForm_weak
void updateDiffusionJacobian_MixedForm_weak(int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, double *a, double *da, double *qV, double *qDV, double *qDV_eb, double *grad_w_dV, double *v, double *jacobian_weak_residual, double *jacobian_weak_residual_eb)
Definition femIntegrals.c:10245
updateDiffusion_adjoint_sd
void updateDiffusion_adjoint_sd(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, int *rowptr, int *colind, double *da, double *grad_phi, double *grad_w_dV, double *Lstar_w_dV)
Definition femIntegrals.c:3392
calculateGradShape_X_weightedShapeGlobalExteriorTrace
void calculateGradShape_X_weightedShapeGlobalExteriorTrace(int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_trial_element, int nDOF_test_element, int nSpace, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, double *grad_v, double *w_dS, double *grad_v_X_w_dS)
Calculate the tensor product of trial function gradients and test functions at the quadrature points.
Definition femIntegrals.c:6897
updateExteriorElementBoundaryDiffusiveVelocity
void updateExteriorElementBoundaryDiffusiveVelocity(int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *a, double *grad_phi, double *velocity)
Calculate the diffusive flux at exterior element boundary quadrature points.
Definition femIntegrals.c:7925
updateGlobalJacobianFromElementJacobian_dense
void updateGlobalJacobianFromElementJacobian_dense(int nElements_global, int nDOF_test_element, int nDOF_trial_element, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, double *elementJacobian, double *globalJacobian)
Update the global dense jacobian from the element Jacobians.
Definition femIntegrals.c:4690
parametricMaps_getInverseValuesGlobalExteriorTrace
void parametricMaps_getInverseValuesGlobalExteriorTrace(int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, int nSpace_global, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, double *inverseJacobian, int *l2g, double *nodeArray, double *xArray, double *xiArray)
Definition femIntegrals.c:780
parametricMaps_getValuesTrace
void parametricMaps_getValuesTrace(int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_element, int nDOF_element, int nSpace_global, double *psi, int *l2g, double *nodeArray, double *xArray)
Definition femIntegrals.c:624
updateNumericalDiffusion_lowmem
void updateNumericalDiffusion_lowmem(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *numDiff, double *grad_u, double *grad_w_dV, double *weak_residual)
Definition femIntegrals.c:4073
copyExteriorElementBoundaryValuesFromGlobalElementBoundaryValues
void copyExteriorElementBoundaryValuesFromGlobalElementBoundaryValues(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nValuesPerQuadraturePoint, const int *exteriorElementBoundaries, const int *elementBoundaryElements, const int *elementBoundaryLocalElementBoundaries, const double *ebq_global_val, double *ebqe_val)
copy quantity that sits only on exterior boundaries from a global elementBoundary quadrature array
Definition femIntegrals.c:10655
calculateShape_X_weightedShapeGlobalExteriorTrace
void calculateShape_X_weightedShapeGlobalExteriorTrace(int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_trial_element, int nDOF_test_element, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, double *v, double *w_dS, double *v_X_w_dS)
Calcualte the tensor product of trial and test functions at the quadrature points global exterior bou...
Definition femIntegrals.c:6864
calculateVectorScalarProduct
void calculateVectorScalarProduct(int nElements_global, int nQuadraturePoints_element, int nSpace, double *v, double *s, double *vResult)
Calculate the product of a vector and a scalar at the quadrature points.
Definition femIntegrals.c:4234
calculateVelocityQuadrature_MixedForm2_sd
void calculateVelocityQuadrature_MixedForm2_sd(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, int nSpace, int nQuadraturePoints_element, const int *rowptr, const int *colind, double *qa, double *qw_dV, double *b, double *v, double *V, double *qv, double *qV)
Definition femIntegrals.c:9326
updateReaction_strong
void updateReaction_strong(int nElements_global, int nQuadraturePoints_element, double *r, double *strong_residual)
Loop over all the elements and update the strong from of the residual at the quadrature points with t...
Definition femIntegrals.c:3785
updateDiffusionJacobian_strong
void updateDiffusionJacobian_strong(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nSpace, int *l2g, double *da, double *dphi, double *grad_phi, double *grad_u, double *grad_v, double *dstrong_residual)
Loop over all the elements and update the strong form of the residual with the diffusion term at the ...
Definition femIntegrals.c:3221
calculateInteriorElementBoundaryAverageVelocity
void calculateInteriorElementBoundaryAverageVelocity(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *v, double *vAverage)
Definition femIntegrals.c:8313
parametricMaps_getInverseValues
void parametricMaps_getInverseValues(int nElements_global, int nQuadraturePoints_element, int nDOF_element, int nSpace_global, double *inverseJacobian, int *l2g, double *nodeArray, double *xArray, double *xiArray)
Definition femIntegrals.c:697
parametricFiniteElementSpace_getGradientValuesGlobalExteriorTrace
void parametricFiniteElementSpace_getGradientValuesGlobalExteriorTrace(int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, int nSpace_global, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, double *grad_psi, double *inverseJacobianArray, double *grad_vArray)
Definition femIntegrals.c:428
copyExteriorElementBoundaryValuesToElementBoundaryValues
void copyExteriorElementBoundaryValuesToElementBoundaryValues(int nExteriorElementBoundaries_global, int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nValuesPerQuadraturePoint, const int *exteriorElementBoundaries, const int *elementBoundaryElements, const int *elementBoundaryLocalElementBoundaries, const double *ebqe_val, double *ebq_val)
copy quantity that sits only on exterior boundaries into an elementBoundary quadrature array
Definition femIntegrals.c:10592
calculateElementBoundaryIntegrationWeights
void calculateElementBoundaryIntegrationWeights(int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, double *sqrt_det_g, double *referenceWeights, double *weights)
Definition femIntegrals.c:6953
updateExteriorElementBoundaryAdvectiveVelocity
void updateExteriorElementBoundaryAdvectiveVelocity(int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *f, double *velocity)
Update the advective flux at exterior element boundaries.
Definition femIntegrals.c:8127
calculateFlowVelocity
void calculateFlowVelocity(int nElements_global, int nQuadraturePoints_element, int nSpace, double *f, double *a, double *grad_phi, double *v)
Calculate the total (advective + diffusive) flow velocity.
Definition femIntegrals.c:7328
updateAdvection_adjoint
void updateAdvection_adjoint(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *df, double *grad_w_dV, double *Lstar_w_dV)
Loop over all the elements and update the linearized adjoint applied to the weighted test functions w...
Definition femIntegrals.c:2261
updateReactionJacobian_strong
void updateReactionJacobian_strong(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, double *dr, double *v, double *dstrong_residual)
Loop over all the elements and update the strong from of the residual at the quadrature points with t...
Definition femIntegrals.c:3819
parametricMaps_getValues
void parametricMaps_getValues(int nElements_global, int nQuadraturePoints_element, int nDOF_element, int nSpace_global, double *psi, int *l2g, double *nodeArray, double *xArray)
Definition femIntegrals.c:594
updateMassJacobian_strong
void updateMassJacobian_strong(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, double *dmt, double *v, double *dstrong_residual)
Loop over all the elements and update the Jacobian of the strong from of the residual at the quadratu...
Definition femIntegrals.c:1887
updateInteriorElementBoundary_MixedForm_weakJacobian
void updateInteriorElementBoundary_MixedForm_weakJacobian(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nSpace, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *n, double *dphi_trace_left, double *dphi_trace_right, double *v, double *w_dS, double *db, double *db_eb)
Update the element boundary flux on interior element boundaries.
Definition femIntegrals.c:8832
calculateExteriorNumericalTrace_Potential
void calculateExteriorNumericalTrace_Potential(int *isDOFBoundary, int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *phi_bc, double *phi, double *dphi, double *phi_trace, double *dphi_trace_left)
Calculate the trace of the potential on interior element boundaries. Use the arithmetic average.
Definition femIntegrals.c:8721
parametricFiniteElementSpace_getValues
void parametricFiniteElementSpace_getValues(int nElements_global, int nQuadraturePoints_element, int nDOF_element, double *psi, double *vArray)
Definition femIntegrals.c:255
calculateWeightedShape
void calculateWeightedShape(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, double *dVR, double *abs_det_jac, double *w, double *w_dV)
Weight the test function with the integration weights.
Definition femIntegrals.c:6427
calculateShape_X_weightedShapeTrace
void calculateShape_X_weightedShapeTrace(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_trial_element, int nDOF_test_element, double *v, double *w_dS, double *v_X_w_dS)
Calcualte the tensor product of trial and test functions at the quadrature points.
Definition femIntegrals.c:6754
updateStressJacobian_weak
void updateStressJacobian_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, double *dsigma_xx, double *dsigma_xy, double *dsigma_xz, double *dsigma_yx, double *dsigma_yy, double *dsigma_yz, double *dsigma_zx, double *dsigma_zy, double *dsigma_zz, double *grad_v, double *grad_w_dV, double *jacobian_weak_residual_xx, double *jacobian_weak_residual_xy, double *jacobian_weak_residual_xz, double *jacobian_weak_residual_yx, double *jacobian_weak_residual_yy, double *jacobian_weak_residual_yz, double *jacobian_weak_residual_zx, double *jacobian_weak_residual_zy, double *jacobian_weak_residual_zz)
Definition femIntegrals.c:12288
updateNumericalDiffusion
void updateNumericalDiffusion(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *numDiff, double *grad_u_X_grad_w_dV, double *weak_residual)
Loop over all the elements and update the element weak_residual with the numerical quadrature approxi...
Definition femIntegrals.c:4048
updateInteriorElementBoundaryFlux
void updateInteriorElementBoundaryFlux(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *flux, double *w_dS, double *residual)
Update the element boundary flux on interior element boundaries.
Definition femIntegrals.c:4294
copyGlobalElementBoundaryVelocityToElementBoundary
void copyGlobalElementBoundaryVelocityToElementBoundary(int nElements_global, int nInteriorElementBoundaries_global, int nExteriorElementBoundaries_global, int nElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, int *interiorElementBoundaries, int *exteriorElementBoundaries, int *elementBoundaryElementsArray, int *elementBoundaryLocalElementBoundariesArray, double *velocityBoundary_global, double *velocityBoundary_element)
Definition femIntegrals.c:8556
updateMassJacobian_weak
void updateMassJacobian_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, double *dmt, double *v_X_w_dV, double *jacobian_weak_residual)
Loop over all the elements and update the element Jacobian with the numerical quadrature approximatio...
Definition femIntegrals.c:1773
calculateVelocityProjectionMatrixLDG
void calculateVelocityProjectionMatrixLDG(int nElements_global, int nQuadraturePoints_element, int nDOF_element, double *vXw_dV, double *A_inv)
Definition femIntegrals.c:10123
scalarHeavisideDomainIntegral
double scalarHeavisideDomainIntegral(int nElements, int nQuadraturePoints_element, double *dV, double *nValueArray)
Definition femIntegrals.c:10698
updateGlobalJacobianFromExteriorElementBoundaryFluxJacobian_eb_CSR
void updateGlobalJacobianFromExteriorElementBoundaryFluxJacobian_eb_CSR(int *elementNeighbors, int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *csrRowIndeces_ru, int *csrColumnOffsets_eb_eNebN_ru, double *elementBoundaryFluxJacobian_eb, double *w_dS, double *jac)
Update the global CSR Jacobian from the element boundary flux Jacobians at exterior boundaries.
Definition femIntegrals.c:6120
calculateCFLADR
void calculateCFLADR(int nElements_global, int nQuadraturePoints_element, int nSpace, double *elementDiameter, double *dm, double *df, double *cfl)
Definition femIntegrals.c:7730
parametricMaps_getJacobianValuesTrace2D
void parametricMaps_getJacobianValuesTrace2D(int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_element, int nDOF_element, double *grad_psi, double *boundaryNormals, double *boundaryJacobians, int *l2g, double *nodeArray, double *jacobianInverseArray, double *metricTensorArray, double *metricTensorDeterminantSqrtArray, double *unitNormalArray)
Definition femIntegrals.c:1109
parametricFiniteElementSpace_getGradientValues
void parametricFiniteElementSpace_getGradientValues(int nElements_global, int nQuadraturePoints_element, int nDOF_element, int nSpace_global, double *grad_psi, double *inverseJacobianArray, double *grad_vArray)
Definition femIntegrals.c:325
updateAdvectionJacobian_strong
void updateAdvectionJacobian_strong(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nSpace, double *df, double *grad_v, double *dstrong_residual)
Loop over all the elements and update the Jacobian of the strong form of the residual with the advect...
Definition femIntegrals.c:2204
updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_dense
void updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_dense(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, double *elementBoundaryFluxJacobian, double *w_dS, double *jac)
Update the global dense Jacobian from the element boundary flux Jacobians at interior boundaries.
Definition femIntegrals.c:4792
updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_eb_dense
void updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_eb_dense(int *elementNeighbors, int nElements_global, int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, double *elementBoundaryFluxJacobian_eb, double *w_dS, double *jac)
Update the global dense Jacobian from the element boundary flux Jacobians at interior boundaries.
Definition femIntegrals.c:4922
parametricMaps_getJacobianValuesTrace3D
void parametricMaps_getJacobianValuesTrace3D(int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_element, int nDOF_element, double *grad_psi, double *boundaryNormals, double *boundaryJacobians, int *l2g, double *nodeArray, double *jacobianInverseArray, double *metricTensorArray, double *metricTensorDeterminantSqrtArray, double *unitNormalArray)
Definition femIntegrals.c:986
computeC0P1InterpolantNCP1
void computeC0P1InterpolantNCP1(int nElements_global, int nNodes_global, int nNodes_element, int nDOF_element, int dim_dof, const int *elementNodesArray, const int *nodeElementOffsets, const int *nodeElementsArray, const int *l2g, const double *dof, double *nodalAverage)
Definition femIntegrals.c:10871
updateGlobalResidualFromElementResidual
void updateGlobalResidualFromElementResidual(int nElements_global, int nDOF_test_element, int offset_r, int stride_r, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, double *elementResidual, double *globalResidual)
Update the global residuals from the element residuals.
Definition femIntegrals.c:4665
updateDiffusionJacobian_weak_lowmem
void updateDiffusionJacobian_weak_lowmem(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, int *l2g, double *a, double *da, double *grad_phi, double *grad_w_dV, double *dphi, double *v, double *grad_v, double *jacobian_weak_residual)
Definition femIntegrals.c:2904
parametricMaps_getJacobianValues2D
void parametricMaps_getJacobianValues2D(int nElements_global, int nQuadraturePoints_element, int nDOF_element, double *grad_psi, int *l2g, double *nodeArray, double *jacobianArray, double *jacobianDeterminantArray, double *jacobianInverseArray)
Definition femIntegrals.c:891
updateInteriorElementBoundaryDiffusionAdjoint_sd
void updateInteriorElementBoundaryDiffusionAdjoint_sd(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nSpace, int *rowptr, int *colind, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double sigma, double *u, double *n, double *a, double *grad_w, double *dS, double *residual)
Definition femIntegrals.c:11447
parametricMaps_getJacobianValues1D
void parametricMaps_getJacobianValues1D(int nElements_global, int nQuadraturePoints_element, int nDOF_element, double *grad_psi, int *l2g, double *nodeArray, double *jacobianArray, double *jacobianDeterminantArray, double *jacobianInverseArray)
Definition femIntegrals.c:942
calculateExteriorElementBoundaryVelocities
void calculateExteriorElementBoundaryVelocities(int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *m, double *a, double *grad_phi, double *f, double *vAverage, double *vJump, double *mAverage, double *mJump)
Definition femIntegrals.c:7475
updateAdvectionJacobian_weak
void updateAdvectionJacobian_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, double *df, double *v_X_grad_w_dV, double *jacobian_weak_residual)
Loop over all the elements and update the element Jacobian with the numerical quadrature approximatio...
Definition femIntegrals.c:2069
calculateFiniteElementFunctionGradientValuesGlobalExteriorTrace
void calculateFiniteElementFunctionGradientValuesGlobalExteriorTrace(int nQuadraturePoints_elementBoundary, int nDOF_trial_element, int nComponents, int nSpace, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, int *l2g, double *dof, double *grad_v, double *grad_u)
Definition femIntegrals.c:7285
updateDiffusion_weak_lowmem
void updateDiffusion_weak_lowmem(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *a, double *grad_phi, double *grad_w_dV, double *weak_residual)
Definition femIntegrals.c:2676
calculateShape_X_weightedShape
void calculateShape_X_weightedShape(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, double *v, double *w_dV, double *v_X_w_dV)
Calcualte the tensor product of trial and test functions at the quadrature points.
Definition femIntegrals.c:6551
updatePotential_MixedForm_weak
void updatePotential_MixedForm_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *phi, double *grad_w_dV, double *b)
Definition femIntegrals.c:9054
scalarSmoothedHeavisideDomainIntegral
double scalarSmoothedHeavisideDomainIntegral(int nElements, int nQuadraturePoints_element, double epsFact, double *elementDiameter, double *dV, double *nValueArray)
Definition femIntegrals.c:10716
calculateWeightedShapeTrace
void calculateWeightedShapeTrace(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_test_element, double *dSR, double *sqrt_det_g, double *w, double *w_dS)
Weight the traces of the test function with the element boundary integration weights.
Definition femIntegrals.c:6686
calculateInteriorElementBoundaryVelocities
void calculateInteriorElementBoundaryVelocities(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *m, double *a, double *grad_phi, double *f, double *vAverage, double *vJump, double *mAverage, double *mJump)
Definition femIntegrals.c:7383
calculateDimensionlessNumbersADR
void calculateDimensionlessNumbersADR(int nElements_global, int nQuadraturePoints_element, int nSpace, int computeDiffusiveTimeStepLimit, double *elementDiameter, double *df, double *a, double *dphi, double *dr, double *dmt, double *pe, double *cfl)
Calculate the Peclet and Courant-Friedrichs-Lewy numbers for the scalar advection-diffusion-reaction ...
Definition femIntegrals.c:7602
updateDiffusion_weak_sd
void updateDiffusion_weak_sd(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, int *rowptr, int *colind, double *a, double *grad_phi, double *grad_w_dV, double *weak_residual)
Definition femIntegrals.c:2728
updateAdvection_weak
void updateAdvection_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *f, double *grad_w_dV, double *weak_residual)
Loop over all the elements and update the element weak_residual with the numerical quadrature approxi...
Definition femIntegrals.c:1999
updateMass_weak
void updateMass_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, double *mt, double *w_dV, double *weak_residual)
Loop over all the elements and update the element weak_residual with the numerical quadrature approxi...
Definition femIntegrals.c:1712
updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_2sided_CSR
void updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_2sided_CSR(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *csrRowIndeces_ru, int *csrColumnOffsets_eb_ru, double *elementBoundaryFluxJacobian_2sided, double *w_dS, double *jac)
Update the global CSR Jacobian from the element boundary two-sided Hamiltonian flux Jacobians at inte...
Definition femIntegrals.c:6279
update_f_movingDomain_constantMass_q
void update_f_movingDomain_constantMass_q(int nElements_global, int nQuadraturePoints_element, int nSpace, double *xt, double *f)
Definition femIntegrals.c:12163
updateGlobalJacobianFromGlobalExteriorElementBoundaryFluxJacobian_CSR
void updateGlobalJacobianFromGlobalExteriorElementBoundaryFluxJacobian_CSR(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *csrRowIndeces_ru, int *csrColumnOffsets_eb_ru, double *elementBoundaryFluxJacobian, double *w_dS, double *jac)
Update the global CSR Jacobian from the element boundary flux Jacobians at exterior boundaries.
Definition femIntegrals.c:5859
updateHamiltonian_weak
void updateHamiltonian_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, double *H, double *w_dV, double *weak_residual)
Loop over all the elements and update the element weak_residual with the numerical quadrature approxi...
Definition femIntegrals.c:2320
calculateFiniteElementFunctionGradientValuesTrace
void calculateFiniteElementFunctionGradientValuesTrace(int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_trial_element, int nComponents, int nSpace, int *l2g, double *dof, double *grad_v, double *grad_u)
Calculate the gradients of a multi-component finite element function at the element boundary quadratu...
Definition femIntegrals.c:7216
calculateTensorScalarProduct
void calculateTensorScalarProduct(int nElements_global, int nQuadraturePoints_element, int nSpace, double *t, double *s, double *tResult)
Calculate the product of a tensor and scalar at the quadrature points.
Definition femIntegrals.c:4260
setExteriorGlobalElementBoundaryVelocityValues
void setExteriorGlobalElementBoundaryVelocityValues(int updateFluxValues, int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nSpace, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *n, double *vn_in, double *v_out)
Definition femIntegrals.c:7546
updateExteriorElementBoundaryFlux
void updateExteriorElementBoundaryFlux(int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *flux, double *w_dS, double *residual)
Update the element boundary flux on exterior element boundaries.
Definition femIntegrals.c:4341
updateInteriorElementBoundaryDiffusiveVelocity
void updateInteriorElementBoundaryDiffusiveVelocity(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *a, double *grad_phi, double *velocity)
Calculate the diffusive flux at interior element boundary quadrature points.
Definition femIntegrals.c:7816
updateInteriorElementBoundaryDiffusionAdjoint
void updateInteriorElementBoundaryDiffusionAdjoint(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nSpace, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double sigma, double *u, double *n, double *a, double *grad_w, double *dS, double *residual)
Definition femIntegrals.c:11047
updateDiffusion_strong_sd
void updateDiffusion_strong_sd(int nElements_global, int nQuadraturePoints_element, int nSpace, int *rowptr, int *colind, double *da, double *grad_phi, double *grad_u, double *strong_residual)
Definition femIntegrals.c:3167
estimate_mt_lowmem
void estimate_mt_lowmem(int nElements_global, int nQuadraturePoints_element, int nDOF_element, double *v, double *w_dV, double *elementSpatialResidual, double *mt)
Definition femIntegrals.c:10511
updateAdvectionJacobian_weak_lowmem
void updateAdvectionJacobian_weak_lowmem(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, double *df, double *v, double *grad_w_dV, double *jacobian_weak_residual)
Definition femIntegrals.c:2099
calculateShape_X_weightedGradShape
void calculateShape_X_weightedGradShape(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, double *v, double *grad_w_dV, double *v_X_grad_w_dV)
Calculate the tensor product of trial functions and test function gradients at the quadrature points.
Definition femIntegrals.c:6581
calculateGradShape_X_weightedShapeTrace
void calculateGradShape_X_weightedShapeTrace(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_trial_element, int nDOF_test_element, int nSpace, double *grad_v, double *w_dS, double *grad_v_X_w_dS)
Calculate the tensor product of trial function gradients and test functions at the quadrature points.
Definition femIntegrals.c:6789
parametricMaps_getJacobianValues3D
void parametricMaps_getJacobianValues3D(int nElements_global, int nQuadraturePoints_element, int nDOF_element, double *grad_psi, int *l2g, double *nodeArray, double *jacobianArray, double *jacobianDeterminantArray, double *jacobianInverseArray)
Definition femIntegrals.c:828
calculateExteriorElementBoundaryStress2D
void calculateExteriorElementBoundaryStress2D(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int *elementBoundaryMaterialTypes, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *p, double *mom_flux_vec_u, double *mom_flux_vec_v, double *dS, double *n, double *F)
Definition femIntegrals.c:4565
updateDiffusion2_strong
void updateDiffusion2_strong(int nElements_global, int nQuadraturePoints_element, int nSpace, double *a, double *Hess_phi, double *strong_residual)
Definition femIntegrals.c:3427
parametricFiniteElementSpace_getHessianValues
void parametricFiniteElementSpace_getHessianValues(int nElements_global, int nQuadraturePoints_element, int nDOF_element, int nSpace_global, double *Hessian_psi, double *inverseJacobianArray, double *Hessian_vArray)
Definition femIntegrals.c:354
updateGlobalJacobianFromInteriorElementBoundaryDiffusionAdjoint_dense_sd
void updateGlobalJacobianFromInteriorElementBoundaryDiffusionAdjoint_dense_sd(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int nSpace, int *rowptr, int *colind, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, double sigma, double *v, double *n, double *a, double *grad_w, double *dS, double *jac)
Definition femIntegrals.c:11591
updateGlobalJacobianFromElementJacobian_eb_CSR
void updateGlobalJacobianFromElementJacobian_eb_CSR(int *elementNeighbors, int nElements_global, int nElementBoundaries_element, int nDOF_test_element, int nDOF_trial_element, int *nFreeDOF_element_r, int *freeLocal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *csrRowIndeces_ru, int *csrColumnOffsets_eb_ru, double *elementJacobian_eb, double *globalJacobian)
Update the global CSR jacobian from the element Jacobians.
Definition femIntegrals.c:5601
updateReaction_adjoint
void updateReaction_adjoint(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, double *dr, double *w_dV, double *Lstar_w_dV)
Loop over all the elements and update the linearized adjoint, applied to the weighted test functions,...
Definition femIntegrals.c:3866
estimate_mt
void estimate_mt(int nElements_global, int nQuadraturePoints_element, int nDOF_element, double *v, double *vXw_dV, double *elementSpatialResidual, double *mt)
Definition femIntegrals.c:10468
calculateExteriorElementBoundaryStress3D
void calculateExteriorElementBoundaryStress3D(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int *elementBoundaryMaterialTypes, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *p, double *mom_flux_vec_u, double *mom_flux_vec_v, double *mom_flux_vec_w, double *dS, double *n, double *F)
Definition femIntegrals.c:4484
calculateFiniteElementFunctionValuesTrace
void calculateFiniteElementFunctionValuesTrace(int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_trial_element, int nComponents, int *l2g, double *dof, double *v, double *u)
Calculate the values of a multi-component finite element function at element boundary quadrature poin...
Definition femIntegrals.c:7181
updateExteriorElementBoundaryDiffusiveVelocity_sd
void updateExteriorElementBoundaryDiffusiveVelocity_sd(int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, int *rowptr, int *colind, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *a, double *grad_phi, double *velocity)
Definition femIntegrals.c:7965
updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_eb_CSR
void updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_eb_CSR(int *elementNeighbors, int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *csrRowIndeces_ru, int *csrColumnOffsets_eb_eNebN_ru, double *elementBoundaryFluxJacobian_eb, double *w_dS, double *jac)
Update the global CSR Jacobian from the element boundary flux Jacobians at interior boundaries.
Definition femIntegrals.c:5916
updateDiffusionJacobian_weak_sd
void updateDiffusionJacobian_weak_sd(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, int *rowptr, int *colind, int *l2g, double *a, double *da, double *grad_phi, double *grad_w_dV, double *dphi, double *v, double *grad_v, double *jacobian_weak_residual)
Definition femIntegrals.c:3037
updateHamiltonianJacobian_strong
void updateHamiltonianJacobian_strong(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nSpace, double *dH, double *grad_v, double *dstrong_residual)
Loop over all the elements and update the Jacobian of the strong form of the residual with the advect...
Definition femIntegrals.c:2522
updateGlobalJacobianFromElementJacobian_CSR
void updateGlobalJacobianFromElementJacobian_CSR(int nElements_global, int nDOF_test_element, int nDOF_trial_element, int *nFreeDOF_element_r, int *freeLocal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *csrRowIndeces_ru, int *csrColumnOffsets_ru, double *elementJacobian, double *globalJacobian)
Update the global CSR jacobian from the element Jacobians.
Definition femIntegrals.c:5561
updateGlobalJacobianFromExteriorElementBoundaryFluxJacobian_CSR
void updateGlobalJacobianFromExteriorElementBoundaryFluxJacobian_CSR(int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *csrRowIndeces_ru, int *csrColumnOffsets_eb_ru, double *elementBoundaryFluxJacobian, double *w_dS, double *jac)
Update the global CSR Jacobian from the element boundary flux Jacobians at exterior boundaries.
Definition femIntegrals.c:5799
calculateExteriorElementBoundaryAverageVelocity
void calculateExteriorElementBoundaryAverageVelocity(int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *v, double *vAverage)
Definition femIntegrals.c:8348
updateAddJacobian_CSR
void updateAddJacobian_CSR(int jacIndex, double val, double *jac)
Update a single element of the Jacobian.
Definition femIntegrals.c:7367
copyLeftElementBoundaryInfo
void copyLeftElementBoundaryInfo(int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nSpace_global, int nExteriorElementBoundaries_global, int nInteriorElementBoundaries_global, int *elementBoundaryElementsArray, int *elementBoundaryLocalElementBoundariesArray, int *exteriorElementBoundariesArray, int *interiorElementBoundariesArray, double *x, double *n, double *xg, double *ng)
Definition femIntegrals.c:20
updateMass_strong
void updateMass_strong(int nElements_global, int nQuadraturePoints_element, double *mt, double *strong_residual)
Loop over all the elements and update the strong from of the residual at the quadrature points with t...
Definition femIntegrals.c:1848
updateHamiltonian_strong
void updateHamiltonian_strong(int nElements_global, int nQuadraturePoints_element, int nSpace, double *dH, double *grad_u, double *strong_residual)
Loop over all the elements and update the strong form of the residual with the advection term.
Definition femIntegrals.c:2476
calculateWeightedShapeGlobalExteriorTrace
void calculateWeightedShapeGlobalExteriorTrace(int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_test_element, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, double *dSR, double *sqrt_det_g, double *w, double *w_dS)
Weight the traces of the test function with the element boundary integration weights global exterior ...
Definition femIntegrals.c:6828
calculateVelocityQuadrature_MixedForm_Jacobian
void calculateVelocityQuadrature_MixedForm_Jacobian(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, int nSpace, int nQuadraturePoints_element, double *A_inv, double *db, double *db_eb, double *v, double *DV, double *DV_eb, double *qv, double *qDV, double *qDV_eb)
Definition femIntegrals.c:9576
updateDiffusionJacobian_weak
void updateDiffusionJacobian_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, int *l2g, double *a, double *da, double *grad_phi_X_grad_w_dV, double *dphi, double *v, double *grad_v_X_grad_w_dV, double *jacobian_weak_residual)
Loop over all the elements and update the element Jacobian with the numerical quadrature approximatio...
Definition femIntegrals.c:2833
updateMassJacobian_weak_lowmem
void updateMassJacobian_weak_lowmem(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, double *dmt, double *v, double *w_dV, double *jacobian_weak_residual)
Definition femIntegrals.c:1799
zeroJacobian_CSR
void zeroJacobian_CSR(int nNonzeros, double *jac)
Set all the Jacobian entries to 0.0.
Definition femIntegrals.c:7377
updateReaction_weak
void updateReaction_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, double *r, double *w_dV, double *weak_residual)
Loop over all the elements and update the element weak_residual with the numerical quadrature approxi...
Definition femIntegrals.c:3694
updateExteriorElementBoundaryDiffusionAdjoint
void updateExteriorElementBoundaryDiffusionAdjoint(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nSpace, int *isDOFBoundary, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double sigma, double *u, double *ub, double *n, double *a, double *grad_w, double *dS, double *residual)
Definition femIntegrals.c:11132
updateDiffusion_weak
void updateDiffusion_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *a, double *grad_phi_X_grad_w_dV, double *weak_residual)
Loop over all the elements and update the element weak_residual with the numerical quadrature approxi...
Definition femIntegrals.c:2648
updateSubgridError
void updateSubgridError(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, double *error, double *Lstar_w_dV, double *weak_residual)
Loop over all the elements and update the element weak_residual with the numerical quadrature approxi...
Definition femIntegrals.c:3923
parametricFiniteElementSpace_getValuesGlobalExteriorTrace
void parametricFiniteElementSpace_getValuesGlobalExteriorTrace(int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, double *psi, double *vArray)
Definition femIntegrals.c:297
updateReactionJacobian_weak_lowmem
void updateReactionJacobian_weak_lowmem(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, double *dr, double *v, double *w_dV, double *jacobian_weak_residual)
Definition femIntegrals.c:3754
updateGlobalJacobianFromGlobalExteriorElementBoundaryFluxJacobian_eb_dense
void updateGlobalJacobianFromGlobalExteriorElementBoundaryFluxJacobian_eb_dense(int *elementNeighbors, int nElements_global, int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, double *elementBoundaryFluxJacobian_eb, double *w_dS, double *jac)
Update the global dense Jacobian from the element boundary flux Jacobians at exterior boundaries only...
Definition femIntegrals.c:5413
updateNumericalDiffusionJacobian
void updateNumericalDiffusionJacobian(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, double *numDiff, double *grad_v_X_grad_w_dV, double *jacobian_weak_residual)
Loop over all the elements and update the element Jacobian with the numerical quadrature approximatio...
Definition femIntegrals.c:4145
copyExteriorElementBoundaryValuesFromElementBoundaryValues
void copyExteriorElementBoundaryValuesFromElementBoundaryValues(int nExteriorElementBoundaries_global, int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nValuesPerQuadraturePoint, const int *exteriorElementBoundaries, const int *elementBoundaryElements, const int *elementBoundaryLocalElementBoundaries, const double *ebq_val, double *ebqe_val)
copy quantity in an elementBoundary quadrature array to one that sits only on exterior boundaries
Definition femIntegrals.c:10559
checkGlobalElementBoundaryAndExteriorElementBoundaryArraysSame
int checkGlobalElementBoundaryAndExteriorElementBoundaryArraysSame(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nValuesPerQuadraturePoint, double tolerance, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, const double *ebq_global_val, const double *ebqe_val, int *firstBadIndex)
Definition femIntegrals.c:10973
computeC0P1InterpolantDGP0
void computeC0P1InterpolantDGP0(int nElements_global, int nNodes_global, int nNodes_element, int nDOF_element, int dim_dof, const int *elementNodesArray, const int *nodeElementOffsets, const int *nodeElementsArray, const int *l2g, const double *dof, double *nodalAverage)
Definition femIntegrals.c:10837
update_f_movingDomain_q
void update_f_movingDomain_q(int nElements_global, int nQuadraturePoints_element, int nSpace, double *xt, double *m, double *f)
Definition femIntegrals.c:12140
copyFreeUnknownsToGlobalUnknowns
void copyFreeUnknownsToGlobalUnknowns(int nDOF2set, int offset, int stride, const int *globalDOFids, const int *freeDOFids, const double *free_u, double *u)
Definition femIntegrals.c:11013
parametricMaps_getPermutations
void parametricMaps_getPermutations(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nSpace_global, double *xiArray, int *permutations)
Definition femIntegrals.c:467
updateNumericalDiffusionJacobian_lowmem
void updateNumericalDiffusionJacobian_lowmem(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, double *numDiff, double *grad_v, double *grad_w_dV, double *jacobian_weak_residual)
Definition femIntegrals.c:4175
parametricMaps_getJacobianValuesGlobalExteriorTrace3D
void parametricMaps_getJacobianValuesGlobalExteriorTrace3D(int nQuadraturePoints_element, int nDOF_element, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, double *grad_psi, double *boundaryNormals, double *boundaryJacobians, int *l2g, double *nodeArray, double *jacobianInverseArray, double *metricTensorArray, double *metricTensorDeterminantSqrtArray, double *unitNormalArray)
Definition femIntegrals.c:1556
updateDiffusion2_adjoint
void updateDiffusion2_adjoint(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *a, double *Hess_w_dV, double *Lstar_w_dV)
Definition femIntegrals.c:3594
parametricFiniteElementSpace_getGradientValuesTrace
void parametricFiniteElementSpace_getGradientValuesTrace(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, int nSpace_global, double *grad_psi, int *permutations, double *inverseJacobianArray, double *grad_vArray)
Definition femIntegrals.c:392
calculateInteriorNumericalTrace_Potential
void calculateInteriorNumericalTrace_Potential(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *phi, double *dphi, double *phi_trace, double *dphi_trace_left, double *dphi_trace_right)
Calculate the trace of the potential on interior element boundaries. Use the arithmetic average.
Definition femIntegrals.c:8672
calculateConservationResidualDG
void calculateConservationResidualDG(int nElements_global, int nDOF_test_element, double *elementResidual, double *conservationResidual)
Definition femIntegrals.c:8390
updateDiffusion_MixedForm_weak
void updateDiffusion_MixedForm_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *a, double *qV, double *grad_w_dV, double *weak_residual)
Definition femIntegrals.c:10151
updateAdvection_strong
void updateAdvection_strong(int nElements_global, int nQuadraturePoints_element, int nSpace, double *df, double *grad_u, double *strong_residual)
Loop over all the elements and update the strong form of the residual with the advection term.
Definition femIntegrals.c:2157
calculateFiniteElementFunctionValuesGlobalExteriorTrace
void calculateFiniteElementFunctionValuesGlobalExteriorTrace(int nQuadraturePoints_elementBoundary, int nDOF_trial_element, int nComponents, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, int *l2g, double *dof, double *v, double *u)
Definition femIntegrals.c:7250
updateGlobalExteriorElementBoundaryShockCapturingVelocity
void updateGlobalExteriorElementBoundaryShockCapturingVelocity(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nSpace, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *numDiff, double *grad_u, double *velocity)
Calculate the shock capturing flux at exterior element boundary quadrature points.
Definition femIntegrals.c:8284
updateDiffusionJacobian2_strong_sd
void updateDiffusionJacobian2_strong_sd(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nSpace, int *rowptr, int *colind, int *l2g, double *a, double *da, double *v, double *Hess_phi, double *dphi, double *Hess_v, double *dstrong_residual)
Definition femIntegrals.c:3539
parametricMaps_getPermutationsGlobalExterior
void parametricMaps_getPermutationsGlobalExterior(int nElementBoundaryQuadraturePoints_elementBoundary, int nSpace_global, int nExteriorElementBoundaries_global, const int *exteriorElementBoundariesArray, const int *elementBoundaryElementsArray, const int *elementBoundaryLocalElementBoundariesArray, double *xiArray, int *permutations)
Definition femIntegrals.c:510
updateDiffusion2_adjoint_sd
void updateDiffusion2_adjoint_sd(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, int *rowptr, int *colind, double *a, double *Hess_w_dV, double *Lstar_w_dV)
Definition femIntegrals.c:3627
updateGlobalExteriorElementBoundaryDiffusiveVelocity
void updateGlobalExteriorElementBoundaryDiffusiveVelocity(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nSpace, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *a, double *grad_phi, double *velocity)
Calculate the diffusive flux at exterior element boundary quadrature points.
Definition femIntegrals.c:8009
calculateDimensionlessNumbersADR_sd
void calculateDimensionlessNumbersADR_sd(int nElements_global, int nQuadraturePoints_element, int nSpace, int computeDiffusiveTimeStepLimit, int *rowptr, int *colind, double *elementDiameter, double *df, double *a, double *dphi, double *dr, double *dmt, double *pe, double *cfl)
Definition femIntegrals.c:7661
fluxDomainBoundaryIntegralFromVector
double fluxDomainBoundaryIntegralFromVector(int nExteriorElementBoundaries, int nElementBoundaries_owned, int nQuadraturePoints_elementBoundary, int nSpace, int *flag, int *exteriorElementBoundaries, double *dS, double *nValueArray, double *normal)
Definition femIntegrals.c:10770
loadBoundaryFluxIntoGlobalElementBoundaryVelocity
void loadBoundaryFluxIntoGlobalElementBoundaryVelocity(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nSpace, int *exteriorElementBoundaries, int *fluxElementBoundaries, double *normal, double *flux, double updateCoef, double *velocity)
Definition femIntegrals.c:8620
updateDiffusionJacobian_MixedForm_weak_sd
void updateDiffusionJacobian_MixedForm_weak_sd(int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, int *rowptr, int *colind, double *a, double *da, double *qV, double *qDV, double *qDV_eb, double *grad_w_dV, double *v, double *jacobian_weak_residual, double *jacobian_weak_residual_eb)
Definition femIntegrals.c:10357
updateExteriorElementBoundaryShockCapturingVelocity
void updateExteriorElementBoundaryShockCapturingVelocity(int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nQuadraturePoints_element, int nSpace, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *numDiff, double *grad_u, double *velocity)
Calculate the shock capturing flux at exterior element boundary quadrature points.
Definition femIntegrals.c:8242
calculateGradShape_X_weightedGradShape
void calculateGradShape_X_weightedGradShape(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, double *grad_v, double *grad_w_dV, double *grad_v_X_grad_w_dV)
Calculate the tensor product of trial function gradients and test function gradients at the quadratur...
Definition femIntegrals.c:6649
updateHamiltonianJacobian_weak
void updateHamiltonianJacobian_weak(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nDOF_test_element, int nSpace, double *dH, double *grad_v_X_w_dV, double *jacobian_weak_residual)
Loop over all the elements and update the element Jacobian with the numerical quadrature approximatio...
Definition femIntegrals.c:2386
updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_CSR
void updateGlobalJacobianFromInteriorElementBoundaryFluxJacobian_CSR(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *csrRowIndeces_ru, int *csrColumnOffsets_eb_ru, double *elementBoundaryFluxJacobian, double *w_dS, double *jac)
Update the global CSR Jacobian from the element boundary flux Jacobians at interior boundaries.
Definition femIntegrals.c:5657
copyExteriorElementBoundaryValuesToGlobalElementBoundaryValues
void copyExteriorElementBoundaryValuesToGlobalElementBoundaryValues(int nExteriorElementBoundaries_global, int nQuadraturePoints_elementBoundary, int nValuesPerQuadraturePoint, const int *exteriorElementBoundaries, const int *elementBoundaryElements, const int *elementBoundaryLocalElementBoundaries, const double *ebqe_val, double *ebq_global_val)
copy quantity that sits only on exterior boundaries into a global elementBoundary quadrature array
Definition femIntegrals.c:10625
updateInteriorElementBoundary_MixedForm_weak
void updateInteriorElementBoundary_MixedForm_weak(int nInteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nSpace, int *interiorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, double *n, double *phi_trace, double *w_dS, double *b)
Update the element boundary flux on interior element boundaries.
Definition femIntegrals.c:8768
update_f_movingDomain_constantMass_ebq
void update_f_movingDomain_constantMass_ebq(int nElements_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, double *xt, double *f)
Definition femIntegrals.c:12210
updateDiffusionJacobian_strong_sd
void updateDiffusionJacobian_strong_sd(int nElements_global, int nQuadraturePoints_element, int nDOF_trial_element, int nSpace, int *rowptr, int *colind, int *l2g, double *da, double *dphi, double *grad_phi, double *grad_u, double *grad_v, double *dstrong_residual)
Definition femIntegrals.c:3272
updateDiffusion_strong
void updateDiffusion_strong(int nElements_global, int nQuadraturePoints_element, int nSpace, double *da, double *grad_phi, double *grad_u, double *strong_residual)
Loop over all the elements and update the strong form of the residual with the diffusion term at the ...
Definition femIntegrals.c:3139
updatePotential_MixedForm_weakJacobian
void updatePotential_MixedForm_weakJacobian(int nElements_global, int nQuadraturePoints_element, int nDOF_test_element, int nSpace, double *dphi, double *v, double *grad_w_dV, double *db)
Definition femIntegrals.c:9117
parametricFiniteElementSpace_getValuesTrace
void parametricFiniteElementSpace_getValuesTrace(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, double *psi, int *permutations, double *vArray)
Definition femIntegrals.c:273
projectFromNodalInterpolationConditions
void projectFromNodalInterpolationConditions(int nElements_global, int nDOF_element, int dim_dof, const int *l2g, const int *functional_map_element, const double *interpolationValues, double *dofs)
Definition femIntegrals.c:12491
calculateConservationResidual
void calculateConservationResidual(int nElements_global, int nDOF_test_element, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nSpace, double *n, double *dS_u, double *elementResidual, double *velocity, double *conservationResidual)
calculate mass conservation error as
Definition femIntegrals.c:8411
updateDiffusion2_strong_sd
void updateDiffusion2_strong_sd(int nElements_global, int nQuadraturePoints_element, int nSpace, int *rowptr, int *colind, double *a, double *Hess_phi, double *strong_residual)
Definition femIntegrals.c:3455
calculateVelocityQuadrature_MixedForm2_Jacobian_sd
void calculateVelocityQuadrature_MixedForm2_Jacobian_sd(int nElements_global, int nElementBoundaries_element, int nElementBoundaryQuadraturePoints_elementBoundary, int nDOF_element, int nSpace, int nQuadraturePoints_element, const int *rowptr, const int *colind, double *qa, double *qw_dV, double *db, double *db_eb, double *v, double *DV, double *DV_eb, double *qv, double *qDV, double *qDV_eb)
Definition femIntegrals.c:9925
updateGlobalJacobianFromGlobalExteriorElementBoundaryFluxJacobian_eb_CSR
void updateGlobalJacobianFromGlobalExteriorElementBoundaryFluxJacobian_eb_CSR(int *elementNeighbors, int nExteriorElementBoundaries_global, int nElementBoundaries_element, int nQuadraturePoints_elementBoundary, int nDOF_test_element, int nDOF_trial_element, int *exteriorElementBoundaries, int *elementBoundaryElements, int *elementBoundaryLocalElementBoundaries, int *nFreeDOF_element_r, int *freeLocal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *csrRowIndeces_ru, int *csrColumnOffsets_eb_eNebN_ru, double *elementBoundaryFluxJacobian_eb, double *w_dS, double *jac)
Update the global CSR Jacobian from the element boundary flux Jacobians at exterior boundaries only d...
Definition femIntegrals.c:6201
updateGlobalJacobianFromElementJacobian_eb_dense
void updateGlobalJacobianFromElementJacobian_eb_dense(int *elementNeighbors, int nElements_global, int nElementBoundaries_element, int nDOF_test_element, int nDOF_trial_element, int offset_r, int stride_r, int offset_u, int stride_u, int nFreeVDOF_global, int *nFreeDOF_element_r, int *freeLocal_r, int *freeGlobal_r, int *nFreeDOF_element_u, int *freeLocal_u, int *freeGlobal_u, double *elementJacobian_eb, double *globalJacobian)
Update the global dense jacobian from the element Jacobians.
Definition femIntegrals.c:4734
sign
#define sign(x, y)
Definition jf.h:44
w
#define w(x)
Definition jf.h:22
nnz
#define nnz
Definition m_comp_co2.h:19
dgetrf_
int dgetrf_(int *m, int *n, double *a, int *lda, int *ipiv, int *info)
dgetri_
int dgetri_(int *N, double *A, int *LDA, int *IPIV, double *WORK, int *LWORK, int *INFO)
dgetrs_
int dgetrs_(char *trans, int *n, int *nrhs, double *a, int *lda, int *ipiv, double *b, int *ldb, int *info)
Generated on for proteus by doxygen 1.18.0