proteus 1.9.0
C/C++/Fortran libraries
Loading...
Searching...
No Matches
RANS3PF.h
Go to the documentation of this file.
1#ifndef RANS3PF_H
2#define RANS3PF_H
3#include <cmath>
4#include <valarray>
5#include <iostream>
6#include <vector>
7#include <set>
8#include <cstring>
9#include "CompKernel.h"
10#include "ModelFactory.h"
11#include "SedClosure.h"
12#include "equivalent_polynomials.h"
13#include "ArgumentsDict.h"
14#include "xtensor-python/pyarray.hpp"
15
16double sgn3p(double val) {
17 return double((0.0 < val) - (val < 0.0));
18}
19
21// ***** TODO ***** //
23// *fix the following w.r.t. not dividing momentum eqn by rho
24// * updateSolidParticleTerms
25// *Double check the following w.r.t. not dividing momentum eqn by rho
26// * updateDarcyForchheimerTerms_Ergun
27// * updateTurbulenceClosure
28// * check pdeResidual_p. In particular check the term with q_dvos_dt
29// * double check exteriorNumericalAdvectiveFlux. I multiply from outside porosity*rho
30// * MOVING MESH. Double check.
31// * Turbulence: double check eddy_viscosity within evaluateCoefficients
32// ***** END OF TODO *****
33
34#define CELL_BASED_EV_COEFF 1
35#define POWER_SMOOTHNESS_INDICATOR 2
36#define EPS_FOR_GAMMA_INDICATOR 1E-10
37#define C_FOR_GAMMA_INDICATOR 0.25 // increase gamma to make the indicator more agressive (less dissipative)
38#define USE_GAMMA_INDICATOR 0
39#define ANISOTROPIC_DIFFUSION 0
40
41static const double DM=0.0;//1-mesh conservation and divergence, 0 - weak div(v) only
42static const double DM2=0.0;//1-point-wise mesh volume strong-residual, 0 - div(v) only
43static const double DM3=1.0;//1-point-wise divergence, 0-point-wise rate of volume change
44
45#define USE_CYLINDER_AS_PARTICLE//just for debug
46
47namespace proteus
48{
49 template<int nSpace, int nP, int nQ, int nEBQ>
50 // The trailing flag is the IFEM gate. It has always been false here -- by
51 // default rather than by statement -- and must stay false: with it set, an
52 // element whose interface passes through an edge or corner node takes the
53 // IFEM branch in Simplex::set_quad, which forces D to 0 and H/ImH to a hard
54 // 0/1 instead of the moment fit. That deletes the interface measure this
55 // model integrates over. Written out so the choice is visible at the call
56 // site and cannot change underneath us if the template default changes.
57 using GeneralizedFunctions = equivalent_polynomials::GeneralizedFunctions_mix<nSpace, nP, nP, nQ, nEBQ, false>;
58
59 class cppRANS3PF_base
60 {
61 public:
62 std::valarray<double> TransportMatrix, TransposeTransportMatrix;
63 std::valarray<double> uStar_psi, vStar_psi, wStar_psi;
64 std::valarray<double> uStar_hi, vStar_hi, wStar_hi, den_hi;
65 std::valarray<double> uStar_min_hiHe, vStar_min_hiHe, wStar_min_hiHe;
66 std::valarray<double> uStar_gamma, vStar_gamma, wStar_gamma;
67 virtual ~cppRANS3PF_base() {}
68 virtual void setSedClosure(double aDarcy,
69 double betaForch,
70 double grain,
71 double packFraction,
72 double packMargin,
73 double maxFraction,
74 double frFraction,
75 double sigmaC,
76 double C3e,
77 double C4e,
78 double eR,
79 double fContact,
80 double mContact,
81 double nContact,
82 double angFriction,
83 double vos_limiter,
84 double mu_fr_limiter
85 ) {}
86 virtual void calculateResidual(arguments_dict& args,
87 bool useExact
88 )=0;
89
90 virtual void calculateJacobian(arguments_dict& args,
91 bool useExact)=0;
92 virtual void calculateVelocityAverage(arguments_dict& args) = 0;
93 virtual void getBoundaryDOFs(arguments_dict& args)=0;
94 };
95
96 template<class CompKernelType,
97 int nSpace,
98 int nQuadraturePoints_element,
99 int nDOF_mesh_trial_element,
100 int nDOF_trial_element,
101 int nDOF_test_element,
102 int nQuadraturePoints_elementBoundary>
103 class cppRANS3PF : public cppRANS3PF_base
104 {
105 public:
106 std::vector<int> surrogate_boundaries, surrogate_boundary_elements, surrogate_boundary_particle;
107 double C_sbm, beta_sbm;
108 cppHsuSedStress<3> closure;
109 const int nDOF_test_X_trial_element,
110 nSpace2=9;
111 CompKernelType ck;
112 GeneralizedFunctions<nSpace,1,nQuadraturePoints_element,nQuadraturePoints_elementBoundary> gf;
113 GeneralizedFunctions<nSpace,1,nQuadraturePoints_element,nQuadraturePoints_elementBoundary> gf_s;
114 cppRANS3PF():
115 closure(150.0,
116 0.0,
117 0.0102,
118 0.2,
119 0.01,
120 0.635,
121 0.57,
122 1.1,
123 1.2,
124 1.0,
125 0.8,
126 0.02,
127 2.0,
128 5.0,
129 M_PI/6.,
130 0.05,
131 1.00),
132 nDOF_test_X_trial_element(nDOF_test_element*nDOF_trial_element),
133 ck(),
134 C_sbm(2.0),
135 beta_sbm(0.0)
136 {/* std::cout<<"Constructing cppRANS3PF<CompKernelTemplate<"
137 <<0<<","
138 <<0<<","
139 <<0<<","
140 <<0<<">,"*/
141 /* <<nSpaceIn<<","
142 <<nQuadraturePoints_elementIn<<","
143 <<nDOF_mesh_trial_elementIn<<","
144 <<nDOF_trial_elementIn<<","
145 <<nDOF_test_elementIn<<","
146 <<nQuadraturePoints_elementBoundaryIn<<">());"*/
147 /* <<std::endl<<std::flush; */
148 }
149
150 void setSedClosure(double aDarcy,
151 double betaForch,
152 double grain,
153 double packFraction,
154 double packMargin,
155 double maxFraction,
156 double frFraction,
157 double sigmaC,
158 double C3e,
159 double C4e,
160 double eR,
161 double fContact,
162 double mContact,
163 double nContact,
164 double angFriction,
165 double vos_limiter,
166 double mu_fr_limiter)
167 {
168 closure = cppHsuSedStress<3>(aDarcy,
169 betaForch,
170 grain,
171 packFraction,
172 packMargin,
173 maxFraction,
174 frFraction,
175 sigmaC,
176 C3e,
177 C4e,
178 eR,
179 fContact,
180 mContact,
181 nContact,
182 angFriction,
183 vos_limiter,
184 mu_fr_limiter);
185 }
186
187 inline double Dot(const double vec1[nSpace],
188 const double vec2[nSpace])
189 {
190 double dot = 0;
191 for (int I=0; I<nSpace; I++)
192 dot += vec1[I]*vec2[I];
193 return dot;
194 }
195
196 inline void calculateTangentialGradient(const double normal[nSpace],
197 const double vel_grad[nSpace],
198 double vel_tgrad[nSpace])
199 {
200 double normal_dot_vel_grad = Dot(normal,vel_grad);
201 for (int I=0; I<nSpace; I++)
202 vel_tgrad[I] = vel_grad[I] - normal_dot_vel_grad*normal[I];
203 }
204
205 inline
206 void evaluateCoefficients(const double eps_rho,
207 const double eps_mu,
208 const double eps_s,
209 const double sigma,
210 const double rho_0,
211 double nu_0,
212 const double rho_1,
213 double nu_1,
214 const double h_e,
215 const double smagorinskyConstant,
216 const int turbulenceClosureModel,
217 const double g[nSpace],
218 const double useVF,
219 const double& vf,
220 const double& phi,
221 const double n[nSpace],
222 const double distance_to_omega_solid,
223 const double& kappa,
224 const double porosity,//VRANS specific
225 const double& p,
226 const double grad_p[nSpace],
227 const double grad_u[nSpace],
228 const double grad_v[nSpace],
229 const double grad_w[nSpace],
230 const double& u,
231 const double& v,
232 const double& w,
233 const double& uStar,
234 const double& vStar,
235 const double& wStar,
236 double& eddy_viscosity,
237 double& mom_u_acc,
238 double& dmom_u_acc_u,
239 double& mom_v_acc,
240 double& dmom_v_acc_v,
241 double& mom_w_acc,
242 double& dmom_w_acc_w,
243 double mass_adv[nSpace],
244 double dmass_adv_u[nSpace],
245 double dmass_adv_v[nSpace],
246 double dmass_adv_w[nSpace],
247 double mom_u_adv[nSpace],
248 double dmom_u_adv_u[nSpace],
249 double dmom_u_adv_v[nSpace],
250 double dmom_u_adv_w[nSpace],
251 double mom_v_adv[nSpace],
252 double dmom_v_adv_u[nSpace],
253 double dmom_v_adv_v[nSpace],
254 double dmom_v_adv_w[nSpace],
255 double mom_w_adv[nSpace],
256 double dmom_w_adv_u[nSpace],
257 double dmom_w_adv_v[nSpace],
258 double dmom_w_adv_w[nSpace],
259 double mom_uu_diff_ten[nSpace],
260 double mom_vv_diff_ten[nSpace],
261 double mom_ww_diff_ten[nSpace],
262 double mom_uv_diff_ten[1],
263 double mom_uw_diff_ten[1],
264 double mom_vu_diff_ten[1],
265 double mom_vw_diff_ten[1],
266 double mom_wu_diff_ten[1],
267 double mom_wv_diff_ten[1],
268 double& mom_u_source,
269 double& mom_v_source,
270 double& mom_w_source,
271 double& mom_u_ham,
272 double dmom_u_ham_grad_p[nSpace],
273 double dmom_u_ham_grad_u[nSpace],
274 double& mom_v_ham,
275 double dmom_v_ham_grad_p[nSpace],
276 double dmom_v_ham_grad_v[nSpace],
277 double& mom_w_ham,
278 double dmom_w_ham_grad_p[nSpace],
279 double dmom_w_ham_grad_w[nSpace],
280 double& rhoSave,
281 double& nuSave,
282 int KILL_PRESSURE_TERM,
283 int MULTIPLY_EXTERNAL_FORCE_BY_DENSITY,
284 double forcex,
285 double forcey,
286 double forcez,
287 int MATERIAL_PARAMETERS_AS_FUNCTION,
288 double density_as_function,
289 double dynamic_viscosity_as_function,
290 int USE_SBM,
291 double x, double y, double z,
292 int use_ball_as_particle,
293 double* ball_center,
294 double* ball_radius,
295 double* ball_velocity,
296 double* ball_angular_velocity,
297 // int by parts pressure
298 int INT_BY_PARTS_PRESSURE)
299 {
300 double rho,nu,mu,H_rho,ImH_rho,d_rho,H_mu,ImH_mu,d_mu,norm_n,nu_t0=0.0,nu_t1=0.0,nu_t;
301 H_rho = (1.0-useVF)*gf.H(eps_rho,phi) + useVF*fmin(1.0,fmax(0.0,vf));
302 ImH_rho = (1.0-useVF)*gf.ImH(eps_rho,phi) + useVF*(1.0-fmin(1.0,fmax(0.0,vf)));
303 d_rho = (1.0-useVF)*gf.D(eps_rho,phi);
304 H_mu = (1.0-useVF)*gf.H(eps_mu,phi) + useVF*fmin(1.0,fmax(0.0,vf));
305 ImH_mu = (1.0-useVF)*gf.ImH(eps_mu,phi) + useVF*(1.0-fmin(1.0,fmax(0.0,vf)));
306 d_mu = (1.0-useVF)*gf.D(eps_mu,phi);
307
308 //calculate eddy viscosity
309 switch (turbulenceClosureModel)
310 {
311 double norm_S;
312 case 1:
313 {
314 norm_S = sqrt(2.0*(grad_u[0]*grad_u[0] + grad_v[1]*grad_v[1] + grad_w[2]*grad_w[2] +
315 0.5*(grad_u[1]+grad_v[0])*(grad_u[1]+grad_v[0]) +
316 0.5*(grad_u[2]+grad_w[0])*(grad_u[2]+grad_w[0]) +
317 0.5*(grad_v[2]+grad_w[1])*(grad_v[2]+grad_w[1])));
318 nu_t0 = smagorinskyConstant*smagorinskyConstant*h_e*h_e*norm_S;
319 nu_t1 = smagorinskyConstant*smagorinskyConstant*h_e*h_e*norm_S;
320 }
321 case 2:
322 {
323 double re_0,cs_0=0.0,re_1,cs_1=0.0;
324 norm_S = sqrt(2.0*(grad_u[0]*grad_u[0] + grad_v[1]*grad_v[1] + grad_w[2]*grad_w[2] +
325 0.5*(grad_u[1]+grad_v[0])*(grad_u[1]+grad_v[0]) +
326 0.5*(grad_u[2]+grad_w[0])*(grad_u[2]+grad_w[0]) +
327 0.5*(grad_v[2]+grad_w[1])*(grad_v[2]+grad_w[1])));
328 re_0 = h_e*h_e*norm_S/nu_0;
329 if (re_0 > 1.0)
330 cs_0=0.027*pow(10.0,-3.23*pow(re_0,-0.92));
331 nu_t0 = cs_0*h_e*h_e*norm_S;
332 re_1 = h_e*h_e*norm_S/nu_1;
333 if (re_1 > 1.0)
334 cs_1=0.027*pow(10.0,-3.23*pow(re_1,-0.92));
335 nu_t1 = cs_1*h_e*h_e*norm_S;
336 }
337 }
338
339 if (MATERIAL_PARAMETERS_AS_FUNCTION==0)
340 {
341 rho = rho_0*ImH_rho+rho_1*H_rho;
342 nu_t= nu_t0*ImH_mu+nu_t1*H_mu;
343 nu = nu_0*ImH_mu+nu_1*H_mu;
344 nu += nu_t;
345 mu = rho_0*nu_0*ImH_mu+rho_1*nu_1*H_mu;
346 }
347 else // set the material parameters by a function. To check convergence
348 {
349 rho = density_as_function;
350 nu_t= 0;
351 mu = dynamic_viscosity_as_function;
352 nu = mu/rho;
353 }
354
355 rhoSave = rho;
356 nuSave = nu;
357
358 eddy_viscosity = nu_t*rho; // mql. CHECK. Most changes about not divide by rho are here
359 // mass (volume accumulation)
360 //..hardwired
361
362 double phi_s_effect = (distance_to_omega_solid > 0.0) ? 1.0 : 1e-10;
363
364 if(USE_SBM>0)
365 phi_s_effect = 1.0;
366 //u momentum accumulation
367 mom_u_acc=u;//trick for non-conservative form
368 dmom_u_acc_u=phi_s_effect * rho*porosity;
369
370 //v momentum accumulation
371 mom_v_acc=v;
372 dmom_v_acc_v=phi_s_effect * rho*porosity;
373
374 //w momentum accumulation
375 mom_w_acc=phi_s_effect*w;
376 dmom_w_acc_w=phi_s_effect*rho*porosity;
377
378 //mass advective flux
379 mass_adv[0]=phi_s_effect * porosity*u;
380 mass_adv[1]=phi_s_effect * porosity*v;
381 mass_adv[2]=phi_s_effect * porosity*w;
382
383 dmass_adv_u[0]=phi_s_effect * porosity;
384 dmass_adv_u[1]=0.0;
385 dmass_adv_u[2]=0.0;
386
387 dmass_adv_v[0]=0.0;
388 dmass_adv_v[1]=phi_s_effect * porosity;
389 dmass_adv_v[2]=0.0;
390
391 dmass_adv_w[0]=0.0;
392 dmass_adv_w[1]=0.0;
393 dmass_adv_w[2]=phi_s_effect * porosity;
394
395 //advection switched to non-conservative form but could be used for mesh motion...
396 //u momentum advective flux
397 mom_u_adv[0]=0.0;
398 mom_u_adv[1]=0.0;
399 mom_u_adv[2]=0.0;
400
401 dmom_u_adv_u[0]=0.0;
402 dmom_u_adv_u[1]=0.0;
403 dmom_u_adv_u[2]=0.0;
404
405 dmom_u_adv_v[0]=0.0;
406 dmom_u_adv_v[1]=0.0;
407 dmom_u_adv_v[2]=0.0;
408
409 dmom_u_adv_w[0]=0.0;
410 dmom_u_adv_w[1]=0.0;
411 dmom_u_adv_w[2]=0.0;
412
413 //v momentum advective_flux
414 mom_v_adv[0]=0.0;
415 mom_v_adv[1]=0.0;
416 mom_v_adv[2]=0.0;
417
418 dmom_v_adv_u[0]=0.0;
419 dmom_v_adv_u[1]=0.0;
420 dmom_v_adv_u[2]=0.0;
421
422 dmom_v_adv_w[0]=0.0;
423 dmom_v_adv_w[1]=0.0;
424 dmom_v_adv_w[2]=0.0;
425
426 dmom_v_adv_v[0]=0.0;
427 dmom_v_adv_v[1]=0.0;
428 dmom_v_adv_v[2]=0.0;
429
430 //w momentum advective_flux
431 mom_w_adv[0]=0.0;
432 mom_w_adv[1]=0.0;
433 mom_w_adv[2]=0.0;
434
435 dmom_w_adv_u[0]=0.0;
436 dmom_w_adv_u[1]=0.0;
437 dmom_w_adv_u[2]=0.0;
438
439 dmom_w_adv_v[0]=0.0;
440 dmom_w_adv_v[1]=0.0;
441 dmom_w_adv_v[2]=0.0;
442
443 dmom_w_adv_w[0]=0.0;
444 dmom_w_adv_w[1]=0.0;
445 dmom_w_adv_w[2]=0.0;
446
447 //u momentum diffusion tensor
448 mom_uu_diff_ten[0] = phi_s_effect*porosity*2.0*mu;
449 mom_uu_diff_ten[1] = phi_s_effect*porosity*mu;
450 mom_uu_diff_ten[2] = phi_s_effect*porosity*mu;
451
452 mom_uv_diff_ten[0]=phi_s_effect * porosity*mu;
453
454 mom_uw_diff_ten[0]=phi_s_effect*porosity*mu;
455
456 //v momentum diffusion tensor
457 mom_vv_diff_ten[0] = phi_s_effect*porosity*mu;
458 mom_vv_diff_ten[1] = phi_s_effect*porosity*2.0*mu;
459 mom_vv_diff_ten[2] = phi_s_effect*porosity*mu;
460
461 mom_vu_diff_ten[0]=phi_s_effect * porosity*mu;
462
463 mom_vw_diff_ten[0]=phi_s_effect*porosity*mu;
464
465 //w momentum diffusion tensor
466 mom_ww_diff_ten[0] = phi_s_effect*porosity*mu;
467 mom_ww_diff_ten[1] = phi_s_effect*porosity*mu;
468 mom_ww_diff_ten[2] = phi_s_effect*porosity*2.0*mu;
469
470 mom_wu_diff_ten[0]=phi_s_effect*porosity*mu;
471
472 mom_wv_diff_ten[0]=phi_s_effect*porosity*mu;
473
474 //momentum sources
475 norm_n = sqrt(n[0]*n[0]+n[1]*n[1]+n[2]*n[2]);
476
477 mom_u_source = -phi_s_effect*porosity*rho*g[0];// - d_mu*sigma*kappa*n[0]/(rho*(norm_n+1.0e-8));
478 mom_v_source = -phi_s_effect*porosity*rho*g[1];// - d_mu*sigma*kappa*n[1]/(rho*(norm_n+1.0e-8));
479 mom_w_source = -phi_s_effect*porosity*rho*g[2];// - d_mu*sigma*kappa*n[2]/(rho*(norm_n+1.0e-8));
480
481 // mql: add general force term
482 mom_u_source -= (MULTIPLY_EXTERNAL_FORCE_BY_DENSITY == 1 ? porosity*rho : 1.0)*forcex;
483 mom_v_source -= (MULTIPLY_EXTERNAL_FORCE_BY_DENSITY == 1 ? porosity*rho : 1.0)*forcey;
484 mom_w_source -= (MULTIPLY_EXTERNAL_FORCE_BY_DENSITY == 1 ? porosity*rho : 1.0)*forcez;
485
486 //u momentum Hamiltonian (pressure)
487 double aux_pressure = (KILL_PRESSURE_TERM==1 ? 0. : 1.)*(INT_BY_PARTS_PRESSURE==1 ? 0. : 1.);
488 mom_u_ham = phi_s_effect * porosity*grad_p[0]*aux_pressure;
489 dmom_u_ham_grad_p[0]=phi_s_effect * porosity*aux_pressure;
490 dmom_u_ham_grad_p[1]=0.0;
491 dmom_u_ham_grad_p[2]=0.0;
492
493 //v momentum Hamiltonian (pressure)
494 mom_v_ham = phi_s_effect * porosity*grad_p[1]*aux_pressure;
495 dmom_v_ham_grad_p[0]=0.0;
496 dmom_v_ham_grad_p[1]=phi_s_effect * porosity*aux_pressure;
497 dmom_v_ham_grad_p[2]=0.0;
498
499 //w momentum Hamiltonian (pressure)
500 mom_w_ham = phi_s_effect*porosity*grad_p[2]*aux_pressure;
501 dmom_w_ham_grad_p[0]=0.0;
502 dmom_w_ham_grad_p[1]=0.0;
503 dmom_w_ham_grad_p[2]=phi_s_effect*porosity*aux_pressure;
504
505 //u momentum Hamiltonian (advection)
506 mom_u_ham += phi_s_effect*rho*porosity*(uStar*grad_u[0]+vStar*grad_u[1]+wStar*grad_u[2]);
507 dmom_u_ham_grad_u[0]=phi_s_effect*rho*porosity*uStar;
508 dmom_u_ham_grad_u[1]=phi_s_effect*rho*porosity*vStar;
509 dmom_u_ham_grad_u[2]=phi_s_effect*rho*porosity*wStar;
510
511 //v momentum Hamiltonian (advection)
512 mom_v_ham += phi_s_effect*rho*porosity*(uStar*grad_v[0]+vStar*grad_v[1]+wStar*grad_v[2]);
513 dmom_v_ham_grad_v[0]=phi_s_effect*rho*porosity*uStar;
514 dmom_v_ham_grad_v[1]=phi_s_effect*rho*porosity*vStar;
515 dmom_v_ham_grad_v[2]=phi_s_effect*rho*porosity*wStar;
516
517 //w momentum Hamiltonian (advection)
518 mom_w_ham += phi_s_effect*rho*porosity*(uStar*grad_w[0]+vStar*grad_w[1]+wStar*grad_w[2]);
519 dmom_w_ham_grad_w[0]=phi_s_effect*rho*porosity*uStar;
520 dmom_w_ham_grad_w[1]=phi_s_effect*rho*porosity*vStar;
521 dmom_w_ham_grad_w[2]=phi_s_effect*rho*porosity*wStar;
522 }
523
524 //VRANS specific
525 inline
526 void updateDarcyForchheimerTerms_Ergun(/* const double linearDragFactor, */
527 /* const double nonlinearDragFactor, */
528 /* const double porosity, */
529 /* const double meanGrainSize, */
530 const double alpha,
531 const double beta,
532 const double eps_rho,
533 const double eps_mu,
534 const double rho_0,
535 const double nu_0,
536 const double rho_1,
537 const double nu_1,
538 double nu_t,
539 const double useVF,
540 const double vf,
541 const double phi,
542 const double u,
543 const double v,
544 const double w,
545 const double uStar,
546 const double vStar,
547 const double wStar,
548 const double eps_s,
549 const double phi_s,
550 const double u_s,
551 const double v_s,
552 const double w_s,
553 const double uStar_s,
554 const double vStar_s,
555 const double wStar_s,
556 double& mom_u_source,
557 double& mom_v_source,
558 double& mom_w_source,
559 double dmom_u_source[nSpace],
560 double dmom_v_source[nSpace],
561 double dmom_w_source[nSpace],
562 double gradC_x,
563 double gradC_y,
564 double gradC_z)
565 {
566 double rho, mu,nu,H_mu,ImH_mu,uc,duc_du,duc_dv,duc_dw,viscosity,H_s;
567 H_mu = (1.0-useVF)*gf.H(eps_mu,phi)+useVF*fmin(1.0,fmax(0.0,vf));
568 ImH_mu = (1.0-useVF)*gf.ImH(eps_mu,phi) + useVF*(1.0-fmin(1.0,fmax(0.0,vf)));
569 nu = nu_0*ImH_mu+nu_1*H_mu;
570 rho = rho_0*ImH_mu+rho_1*H_mu;
571 mu = rho_0*nu_0*ImH_mu+rho_1*nu_1*H_mu;
572 viscosity = nu;
573 uc = sqrt(u*u+v*v*+w*w);
574 duc_du = u/(uc+1.0e-12);
575 duc_dv = v/(uc+1.0e-12);
576 duc_dw = w/(uc+1.0e-12);
577 double fluid_velocity[3]={uStar,vStar,wStar}, solid_velocity[3]={uStar_s,vStar_s,wStar_s};
578 double new_beta = closure.betaCoeff(1.0-phi_s,
579 rho,
580 fluid_velocity,
581 solid_velocity,
582 viscosity);
583 //new_beta/=rho;
584 mom_u_source += (1.0 - phi_s)*new_beta*( (u - uStar_s) - nu_t*gradC_x/closure.sigmaC_ );
585 mom_v_source += (1.0 - phi_s)*new_beta*( (v - vStar_s)- nu_t*gradC_y/closure.sigmaC_ );
586 mom_w_source += (1.0 - phi_s)*new_beta*( (w - wStar_s)- nu_t*gradC_z/closure.sigmaC_ );;
587
588 dmom_u_source[0] = (1.0 - phi_s)*new_beta;
589 dmom_u_source[1] = 0.0;
590 dmom_u_source[2] = 0.0;
591
592 dmom_v_source[0] = 0.0;
593 dmom_v_source[1] = (1.0 - phi_s)*new_beta;
594 dmom_v_source[2] = 0.0;
595
596 dmom_w_source[0] = 0.0;
597 dmom_w_source[1] = 0.0;
598 dmom_w_source[2] = (1.0 - phi_s)*new_beta;
599 }
600
601 inline void updateSolidParticleTerms(bool element_owned,
602 const double particle_nitsche,
603 const double dV,
604 const int nParticles,
605 const int sd_offset,
606 double *particle_signed_distances,
607 double *particle_signed_distance_normals,
608 double *particle_velocities,
609 double *particle_centroids,
610 int use_ball_as_particle,
611 double* ball_center,
612 double* ball_radius,
613 double* ball_velocity,
614 double* ball_angular_velocity,
615 const double porosity, //VRANS specific
616 const double penalty,
617 const double alpha,
618 const double beta,
619 const double eps_rho,
620 const double eps_mu,
621 const double rho_0,
622 const double nu_0,
623 const double rho_1,
624 const double nu_1,
625 const double useVF,
626 const double vf,
627 const double phi,
628 const double x,
629 const double y,
630 const double z,
631 const double p,
632 const double u,
633 const double v,
634 const double w,
635 const double uStar,
636 const double vStar,
637 const double wStar,
638 const double eps_s,
639 const double grad_u[nSpace],
640 const double grad_v[nSpace],
641 const double grad_w[nSpace],
642 double &mom_u_source,
643 double &mom_v_source,
644 double &mom_w_source,
645 double dmom_u_source[nSpace],
646 double dmom_v_source[nSpace],
647 double dmom_w_source[nSpace],
648 double mom_u_adv[nSpace],
649 double mom_v_adv[nSpace],
650 double mom_w_adv[nSpace],
651 double dmom_u_adv_u[nSpace],
652 double dmom_v_adv_v[nSpace],
653 double dmom_w_adv_w[nSpace],
654 double &mom_u_ham,
655 double dmom_u_ham_grad_u[nSpace],
656 double &mom_v_ham,
657 double dmom_v_ham_grad_v[nSpace],
658 double &mom_w_ham,
659 double dmom_w_ham_grad_w[nSpace],
660 double *particle_netForces,
661 double *particle_netMoments,
662 double *particle_surfaceArea)
663 {
664 double C,rho, mu,nu,H_mu,ImH_mu,uc,duc_du,duc_dv,duc_dw,H_s,D_s,phi_s,u_s,v_s,w_s,force_x,force_y,force_z,r_x,r_y,r_z;
665 double phi_s_normal[3];
666 double fluid_outward_normal[3];
667 double vel[3];
668 double center[3];
669 H_mu = (1.0-useVF)*gf.H(eps_mu,phi)+useVF*fmin(1.0,fmax(0.0,vf));
670 ImH_mu = (1.0-useVF)*gf.ImH(eps_mu,phi) + useVF*(1.0-fmin(1.0,fmax(0.0,vf)));
671 nu = nu_0*ImH_mu+nu_1*H_mu;
672 rho = rho_0*ImH_mu+rho_1*H_mu;
673 mu = rho_0*nu_0*ImH_mu+rho_1*nu_1*H_mu;
674 C=0.0;
675 for (int i=0;i<nParticles;i++)
676 {
677 double* vel_pointer= &particle_velocities[i*sd_offset*nSpace];
678 if(use_ball_as_particle==1)
679 {
680 get_distance_to_ith_ball(nParticles,ball_center,ball_radius,i,x,y,z,phi_s);
681 get_normal_to_ith_ball(nParticles,ball_center,ball_radius,i,x,y,z,phi_s_normal[0],phi_s_normal[1],phi_s_normal[2]);
682 get_velocity_to_ith_ball(nParticles,ball_center,ball_radius,
683 ball_velocity,ball_angular_velocity,
684 i,x,y,z,
685 vel[0],vel[1],vel[2]);
686 center[0] = ball_center[3*i + 0];
687 center[1] = ball_center[3*i + 1];
688 center[2] = ball_center[3*i + 2];
689 u_s = vel[0];
690 v_s = vel[1];
691 w_s = vel[2];
692 }
693 else
694 {
695 phi_s = particle_signed_distances[i * sd_offset];
696 phi_s_normal[0] = particle_signed_distance_normals[i * sd_offset * nSpace + 0];
697 phi_s_normal[1] = particle_signed_distance_normals[i * sd_offset * nSpace + 1];
698 phi_s_normal[2] = particle_signed_distance_normals[i * sd_offset * nSpace + 2];
699 vel[0] = particle_velocities[i * sd_offset * nSpace + 0];
700 vel[1] = particle_velocities[i * sd_offset * nSpace + 1];
701 vel[2] = particle_velocities[i * sd_offset * nSpace + 2];
702 u_s = vel_pointer[0];
703 v_s = vel_pointer[1];
704 w_s = vel_pointer[2];
705 center[0] = particle_centroids[3*i + 0];
706 center[1] = particle_centroids[3*i + 1];
707 center[2] = particle_centroids[3*i + 2];
708 }
709 fluid_outward_normal[0] = -phi_s_normal[0];
710 fluid_outward_normal[1] = -phi_s_normal[1];
711 fluid_outward_normal[2] = -phi_s_normal[2];
712
713 H_s = gf_s.H(eps_s, phi_s);
714 D_s = gf_s.D(eps_s, phi_s);
715 double rel_vel_norm=sqrt((uStar - u_s)*(uStar - u_s)+
716 (vStar - v_s)*(vStar - v_s)+
717 (wStar - w_s)*(wStar - w_s));
718 double C_surf = (phi_s > 0.0) ? 0.0 : nu*penalty;
719 double C_vol = (phi_s > 0.0) ? 0.0 : (alpha + beta*rel_vel_norm);
720 C = (D_s*C_surf + gf_s.ImH(eps_s, phi_s) * C_vol);
721 force_x = dV*D_s*(p*fluid_outward_normal[0] - porosity*mu*(fluid_outward_normal[0]*grad_u[0] +
722 fluid_outward_normal[1]*grad_u[1] +
723 fluid_outward_normal[2]*grad_u[2]) +
724 C_surf*rel_vel_norm*(u-u_s)*rho) + dV*gf_s.ImH(eps_s, phi_s)*C_vol*(u-u_s)*rho;
725 force_y = dV*D_s*(p*fluid_outward_normal[1] - porosity*mu*(fluid_outward_normal[0]*grad_v[0] +
726 fluid_outward_normal[1]*grad_v[1] +
727 fluid_outward_normal[2]*grad_v[2]) +
728 C_surf*rel_vel_norm*(v-v_s)*rho) + dV*gf_s.ImH(eps_s, phi_s)*C_vol*(v-v_s)*rho;
729 force_z = dV*D_s*(p*fluid_outward_normal[2] - porosity*mu*(fluid_outward_normal[0]*grad_w[0] +
730 fluid_outward_normal[1]*grad_w[1] +
731 fluid_outward_normal[2]*grad_w[2]) +
732 C_surf*rel_vel_norm*(v-v_s)*rho) + dV*gf_s.ImH(eps_s, phi_s)*C_vol*(v-v_s)*rho;
733 //always 3D for particle centroids
734 r_x = x - center[0];
735 r_y = y - center[1];
736 r_z = z - center[2];
737
738 if (element_owned)
739 {
740 //always 3D for particle forces
741 particle_netForces[i*3+0] += force_x;
742 particle_netForces[i*3+1] += force_y;
743 particle_netForces[i*3+2] += force_z;
744 particle_netMoments[i*3+0] += (r_y*force_z - r_z*force_y);
745 particle_netMoments[i*3+1] += (r_z*force_x - r_x*force_z);
746 particle_netMoments[i*3+2] += (r_x*force_y - r_y*force_x);
747 }
748
749 // These should be done inside to make sure the correct velocity of different particles are used
750 mom_u_source += C*(u - u_s);
751 mom_v_source += C*(v - v_s);
752 mom_w_source += C*(w - w_s);
753
754 dmom_u_source[0] += C;
755 dmom_v_source[1] += C;
756 dmom_w_source[2] += C;
757
758 //Nitsche terms
759 mom_u_ham -= D_s*porosity*nu*(fluid_outward_normal[0]*grad_u[0] + fluid_outward_normal[1]*grad_u[1] + fluid_outward_normal[2]*grad_u[2]);
760 dmom_u_ham_grad_u[0] -= D_s*porosity*nu*fluid_outward_normal[0];
761 dmom_u_ham_grad_u[1] -= D_s*porosity*nu*fluid_outward_normal[1];
762 dmom_u_ham_grad_u[2] -= D_s*porosity*nu*fluid_outward_normal[2];
763
764 mom_v_ham -= D_s*porosity*nu*(fluid_outward_normal[0]*grad_v[0] + fluid_outward_normal[1]*grad_v[1]+ fluid_outward_normal[2]*grad_v[2]);
765 dmom_v_ham_grad_v[0] -= D_s*porosity*nu*fluid_outward_normal[0];
766 dmom_v_ham_grad_v[1] -= D_s*porosity*nu*fluid_outward_normal[1];
767 dmom_v_ham_grad_v[2] -= D_s*porosity*nu*fluid_outward_normal[2];
768
769 mom_u_adv[0] += D_s*porosity*nu*fluid_outward_normal[0]*(u - u_s);
770 mom_u_adv[1] += D_s*porosity*nu*fluid_outward_normal[1]*(u - u_s);
771 mom_u_adv[2] += D_s*porosity*nu*fluid_outward_normal[2]*(u - u_s);
772 dmom_u_adv_u[0] += D_s*porosity*nu*fluid_outward_normal[0];
773 dmom_u_adv_u[1] += D_s*porosity*nu*fluid_outward_normal[1];
774 dmom_u_adv_u[2] += D_s*porosity*nu*fluid_outward_normal[2];
775
776 mom_v_adv[0] += D_s*porosity*nu*fluid_outward_normal[0]*(v - v_s);
777 mom_v_adv[1] += D_s*porosity*nu*fluid_outward_normal[1]*(v - v_s);
778 mom_v_adv[2] += D_s*porosity*nu*fluid_outward_normal[2]*(v - v_s);
779 dmom_v_adv_v[0] += D_s*porosity*nu*fluid_outward_normal[0];
780 dmom_v_adv_v[1] += D_s*porosity*nu*fluid_outward_normal[1];
781 dmom_v_adv_v[2] += D_s*porosity*nu*fluid_outward_normal[2];
782
783 mom_w_adv[0] += D_s*porosity*nu*fluid_outward_normal[0]*(w - w_s);
784 mom_w_adv[1] += D_s*porosity*nu*fluid_outward_normal[1]*(w - w_s);
785 mom_w_adv[2] += D_s*porosity*nu*fluid_outward_normal[2]*(w - w_s);
786 dmom_w_adv_w[0] += D_s*porosity*nu*fluid_outward_normal[0];
787 dmom_w_adv_w[1] += D_s*porosity*nu*fluid_outward_normal[1];
788 dmom_w_adv_w[2] += D_s*porosity*nu*fluid_outward_normal[2];
789 }
790 }
791
792 inline
793 void calculateCFL(const double& hFactor,
794 const double& elementDiameter,
795 const double& dm,
796 const double df[nSpace],
797 double& cfl)
798 {
799 double h,density,nrm_df=0.0;
800 h = hFactor*elementDiameter;
801 density = dm;
802 for(int I=0;I<nSpace;I++)
803 nrm_df+=df[I]*df[I];
804 nrm_df = sqrt(nrm_df);
805 if (density > 1.0e-8)
806 cfl = nrm_df/(h*density);//this is really cfl/dt, but that's what we want to know, the step controller expect this
807 else
808 cfl = nrm_df/h;
809 //cfl = nrm_df/(h*density);//this is really cfl/dt, but that's what we want to know, the step controller expect this
810 }
811
812 inline void updateTurbulenceClosure(const int turbulenceClosureModel,
813 const double eps_rho,
814 const double eps_mu,
815 const double rho_0,
816 const double nu_0,
817 const double rho_1,
818 const double nu_1,
819 const double useVF,
820 const double vf,
821 const double phi,
822 const double porosity,
823 const double eddy_visc_coef_0,
824 const double turb_var_0, //k for k-eps or k-omega
825 const double turb_var_1, //epsilon for k-epsilon, omega for k-omega
826 const double turb_grad_0[nSpace], //grad k for k-eps,k-omega
827 double &eddy_viscosity,
828 double mom_uu_diff_ten[nSpace],
829 double mom_vv_diff_ten[nSpace],
830 double mom_ww_diff_ten[nSpace],
831 double mom_uv_diff_ten[1],
832 double mom_uw_diff_ten[1],
833 double mom_vu_diff_ten[1],
834 double mom_vw_diff_ten[1],
835 double mom_wu_diff_ten[1],
836 double mom_wv_diff_ten[1],
837 double &mom_u_source,
838 double &mom_v_source,
839 double &mom_w_source)
840 {
841 /****
842 eddy_visc_coef
843 <= 2 LES (do nothing)
844 == 3 k-epsilon
845
846 */
847 assert (turbulenceClosureModel >=3);
848 double rho,nu,H_mu,ImH_mu,nu_t=0.0,nu_t_keps =0.0, nu_t_komega=0.0;
849 double isKEpsilon = 1.0;
850 if (turbulenceClosureModel == 4)
851 isKEpsilon = 0.0;
852 H_mu = (1.0-useVF)*gf.H(eps_mu,phi)+useVF*fmin(1.0,fmax(0.0,vf));
853 ImH_mu = (1.0-useVF)*gf.ImH(eps_mu,phi) + useVF*(1.0-fmin(1.0,fmax(0.0,vf)));
854 nu = nu_0*ImH_mu+nu_1*H_mu;
855 rho = rho_0*ImH_mu+rho_1*H_mu;
856
857 const double twoThirds = 2.0/3.0; const double div_zero = 1.0e-2*fmin(nu_0,nu_1);
858 mom_u_source += twoThirds*turb_grad_0[0];
859 mom_v_source += twoThirds*turb_grad_0[1];
860 mom_w_source += twoThirds*turb_grad_0[2];
861
862 //--- closure model specific ---
863 //k-epsilon
864 nu_t_keps = eddy_visc_coef_0*turb_var_0*turb_var_0/(fabs(turb_var_1) + div_zero);
865 //k-omega
866 nu_t_komega = turb_var_0/(fabs(turb_var_1) + div_zero);
867 //
868 nu_t = isKEpsilon*nu_t_keps + (1.0-isKEpsilon)*nu_t_komega;
869 //mwf debug
870 //if (nu_t > 1.e6*nu)
871 //{
872 // std::cout<<"cppRANS3PF WARNING isKEpsilon = "<<isKEpsilon<<" nu_t = " <<nu_t<<" nu= "<<nu<<" k= "<<turb_var_0<<" turb_var_1= "<<turb_var_1<<std::endl;
873 //}
874
875 nu_t = fmax(nu_t,1.0e-4*nu); //limit according to Lew, Buscaglia etal 01
876 //mwf hack
877 nu_t = fmin(nu_t,1.0e6*nu);
878
879 eddy_viscosity = nu_t*rho; // mql. CHECK.
880 //u momentum diffusion tensor
881 mom_uu_diff_ten[0] += porosity*2.0*eddy_viscosity;
882 mom_uu_diff_ten[1] += porosity*eddy_viscosity;
883 mom_uu_diff_ten[2] += porosity*eddy_viscosity;
884
885 mom_uv_diff_ten[0]+=porosity*eddy_viscosity;
886
887 mom_uw_diff_ten[0]+=porosity*eddy_viscosity;
888
889 //v momentum diffusion tensor
890 mom_vv_diff_ten[0] += porosity*eddy_viscosity;
891 mom_vv_diff_ten[1] += porosity*2.0*eddy_viscosity;
892 mom_vv_diff_ten[2] += porosity*eddy_viscosity;
893
894 mom_vu_diff_ten[0]+=porosity*eddy_viscosity;
895
896 mom_vw_diff_ten[0]+=porosity*eddy_viscosity;
897
898 //w momentum diffusion tensor
899 mom_ww_diff_ten[0] += porosity*eddy_viscosity;
900 mom_ww_diff_ten[1] += porosity*eddy_viscosity;
901 mom_ww_diff_ten[2] += porosity*2.0*eddy_viscosity;
902
903 mom_wu_diff_ten[0]+=porosity*eddy_viscosity;
904
905 mom_wv_diff_ten[0]+=eddy_viscosity;
906 }
907
908 inline void calculateSubgridError_tau(const double &hFactor,
909 const double &elementDiameter,
910 const double &dmt,
911 const double &dm,
912 const double df[nSpace],
913 const double &a,
914 const double &pfac,
915 double &tau_v,
916 double &tau_p,
917 double &cfl)
918 {
919 double h, oneByAbsdt, density, viscosity, nrm_df;
920 h = hFactor * elementDiameter;
921 density = dm;
922 viscosity = a;
923 nrm_df = 0.0;
924 for (int I = 0; I < nSpace; I++)
925 nrm_df += df[I] * df[I];
926 nrm_df = sqrt(nrm_df);
927 if (density > 1.0e-8)
928 cfl = nrm_df/(h*density);//this is really cfl/dt, but that's what we want to know, the step controller expect this
929 else
930 cfl = nrm_df/h;
931 oneByAbsdt = fabs(dmt);
932 tau_v = 1.0/(4.0*viscosity/(h*h) + 2.0*nrm_df/h + oneByAbsdt);
933 tau_p = (4.0*viscosity + 2.0*nrm_df*h + oneByAbsdt*h*h)/pfac;
934 }
935
936 inline void calculateSubgridError_tau(const double &Ct_sge,
937 const double &Cd_sge,
938 const double G[nSpace * nSpace],
939 const double &G_dd_G,
940 const double &tr_G,
941 const double &A0,
942 const double Ai[nSpace],
943 const double &Kij,
944 const double &pfac,
945 double &tau_v,
946 double &tau_p,
947 double &q_cfl)
948 {
949 double v_d_Gv = 0.0;
950 for (int I = 0; I < nSpace; I++)
951 for (int J = 0; J < nSpace; J++)
952 v_d_Gv += Ai[I] * G[I * nSpace + J] * Ai[J];
953 tau_v = 1.0 / sqrt(Ct_sge * A0 * A0 + v_d_Gv + Cd_sge * Kij * Kij * G_dd_G + 1.0e-12);
954 tau_p = 1.0 / (pfac * tr_G * tau_v);
955 }
956
957 inline void calculateSubgridError_tauRes(const double &tau_p,
958 const double &tau_v,
959 const double &pdeResidualP,
960 const double &pdeResidualU,
961 const double &pdeResidualV,
962 const double &pdeResidualW,
963 double &subgridErrorP,
964 double &subgridErrorU,
965 double &subgridErrorV,
966 double &subgridErrorW)
967 {
968 /* GLS pressure */
969 subgridErrorP = -tau_p * pdeResidualP;
970 /* GLS momentum */
971 subgridErrorU = -tau_v*pdeResidualU;
972 subgridErrorV = -tau_v*pdeResidualV;
973 subgridErrorW = -tau_v*pdeResidualW;
974 }
975
976 inline void calculateSubgridErrorDerivatives_tauRes(const double &tau_p,
977 const double &tau_v,
978 const double dpdeResidualP_du[nDOF_trial_element],
979 const double dpdeResidualP_dv[nDOF_trial_element],
980 const double dpdeResidualP_dw[nDOF_trial_element],
981 const double dpdeResidualU_dp[nDOF_trial_element],
982 const double dpdeResidualU_du[nDOF_trial_element],
983 const double dpdeResidualV_dp[nDOF_trial_element],
984 const double dpdeResidualV_dv[nDOF_trial_element],
985 const double dpdeResidualW_dp[nDOF_trial_element],
986 const double dpdeResidualW_dw[nDOF_trial_element],
987 double dsubgridErrorP_du[nDOF_trial_element],
988 double dsubgridErrorP_dv[nDOF_trial_element],
989 double dsubgridErrorP_dw[nDOF_trial_element],
990 double dsubgridErrorU_dp[nDOF_trial_element],
991 double dsubgridErrorU_du[nDOF_trial_element],
992 double dsubgridErrorV_dp[nDOF_trial_element],
993 double dsubgridErrorV_dv[nDOF_trial_element],
994 double dsubgridErrorW_dp[nDOF_trial_element],
995 double dsubgridErrorW_dw[nDOF_trial_element])
996 {
997 for (int j = 0; j < nDOF_trial_element; j++)
998 {
999 /* GLS pressure */
1000 dsubgridErrorP_du[j] = -tau_p*dpdeResidualP_du[j];
1001 dsubgridErrorP_dv[j] = -tau_p*dpdeResidualP_dv[j];
1002 dsubgridErrorP_dw[j] = -tau_p*dpdeResidualP_dw[j];
1003 /* GLS momentum*/
1004 /* u */
1005 dsubgridErrorU_dp[j] = -tau_v * dpdeResidualU_dp[j];
1006 dsubgridErrorU_du[j] = -tau_v * dpdeResidualU_du[j];
1007 /* v */
1008 dsubgridErrorV_dp[j] = -tau_v*dpdeResidualV_dp[j];
1009 dsubgridErrorV_dv[j] = -tau_v*dpdeResidualV_dv[j];
1010 /* w */
1011 dsubgridErrorW_dp[j] = -tau_v*dpdeResidualW_dp[j];
1012 dsubgridErrorW_dw[j] = -tau_v*dpdeResidualW_dw[j];
1013 }
1014 }
1015
1016 inline
1017 void exteriorNumericalAdvectiveFlux(const int& isDOFBoundary_p,
1018 const int& isDOFBoundary_u,
1019 const int& isDOFBoundary_v,
1020 const int& isDOFBoundary_w,
1021 const int& isFluxBoundary_p,
1022 const int& isFluxBoundary_u,
1023 const int& isFluxBoundary_v,
1024 const int& isFluxBoundary_w,
1025 const double& oneByRho,
1026 const double& bc_oneByRho,
1027 const double n[nSpace],
1028 const double& porosity, //mql. CHECK. Multiply by rho outside
1029 const double& bc_p,
1030 const double& bc_u,
1031 const double& bc_v,
1032 const double& bc_w,
1033 const double bc_f_mass[nSpace],
1034 const double bc_f_umom[nSpace],
1035 const double bc_f_vmom[nSpace],
1036 const double bc_f_wmom[nSpace],
1037 const double& bc_flux_mass,
1038 const double& bc_flux_umom,
1039 const double& bc_flux_vmom,
1040 const double& bc_flux_wmom,
1041 const double& p,
1042 const double& u,
1043 const double& v,
1044 const double& w,
1045 const double f_mass[nSpace],
1046 const double f_umom[nSpace],
1047 const double f_vmom[nSpace],
1048 const double f_wmom[nSpace],
1049 const double df_mass_du[nSpace],
1050 const double df_mass_dv[nSpace],
1051 const double df_mass_dw[nSpace],
1052 const double df_umom_dp[nSpace],
1053 const double df_umom_du[nSpace],
1054 const double df_umom_dv[nSpace],
1055 const double df_umom_dw[nSpace],
1056 const double df_vmom_dp[nSpace],
1057 const double df_vmom_du[nSpace],
1058 const double df_vmom_dv[nSpace],
1059 const double df_vmom_dw[nSpace],
1060 const double df_wmom_dp[nSpace],
1061 const double df_wmom_du[nSpace],
1062 const double df_wmom_dv[nSpace],
1063 const double df_wmom_dw[nSpace],
1064 double& flux_mass,
1065 double& flux_umom,
1066 double& flux_vmom,
1067 double& flux_wmom,
1068 double* velocity_star,
1069 double* velocity)
1070 {
1071 double flowSpeedNormal;
1072 flux_mass = 0.0;
1073 flux_umom = 0.0;
1074 flux_vmom = 0.0;
1075 flux_wmom = 0.0;
1076 flowSpeedNormal=porosity*(n[0]*velocity_star[0] +
1077 n[1]*velocity_star[1] +
1078 n[2]*velocity_star[2]);
1079 velocity[0] = u;
1080 velocity[1] = v;
1081 velocity[2] = w;
1082 if (isDOFBoundary_u != 1)
1083 {
1084 flux_mass += n[0]*f_mass[0];
1085 if (flowSpeedNormal < 0.0)
1086 {
1087 flux_umom+=flowSpeedNormal*(0.0 - u);
1088 }
1089 }
1090 else
1091 {
1092 flux_mass += n[0]*f_mass[0];
1093 if (flowSpeedNormal < 0.0)
1094 {
1095 flux_umom+=flowSpeedNormal*(bc_u - u);
1096 velocity[0] = bc_u;
1097 }
1098 }
1099 if (isDOFBoundary_v != 1)
1100 {
1101 flux_mass+=n[1]*f_mass[1];
1102 if (flowSpeedNormal < 0.0)
1103 {
1104 flux_vmom+=flowSpeedNormal*(0.0 - v);
1105 }
1106 }
1107 else
1108 {
1109 flux_mass+=n[1]*f_mass[1];
1110 if (flowSpeedNormal < 0.0)
1111 {
1112 flux_vmom+=flowSpeedNormal*(bc_v - v);
1113 velocity[1] = bc_v;
1114 }
1115 }
1116 if (isDOFBoundary_w != 1)
1117 {
1118 flux_mass+=n[2]*f_mass[2];
1119 if (flowSpeedNormal < 0.0)
1120 {
1121 flux_wmom+=flowSpeedNormal*(0.0 - w);
1122 }
1123 }
1124 else
1125 {
1126 flux_mass +=n[2]*f_mass[2];
1127 if (flowSpeedNormal < 0.0)
1128 {
1129 flux_wmom+=flowSpeedNormal*(bc_w - w);
1130 velocity[2] = bc_w;
1131 }
1132 }
1133 /* if (isDOFBoundary_p == 1) */
1134 /* { */
1135 /* flux_umom+= n[0]*(bc_p*bc_oneByRho-p*oneByRho); */
1136 /* flux_vmom+= n[1]*(bc_p*bc_oneByRho-p*oneByRho); */
1137 /* flux_wmom+= n[2]*(bc_p*bc_oneByRho-p*oneByRho); */
1138 /* } */
1139 /* if (isFluxBoundary_p == 1) */
1140 /* { */
1141 /* /\* velocity[0] += (bc_flux_mass - flux_mass)*n[0]; *\/ */
1142 /* /\* velocity[1] += (bc_flux_mass - flux_mass)*n[1]; *\/ */
1143 /* /\* velocity[2] += (bc_flux_mass - flux_mass)*n[2]; *\/ */
1144 /* flux_mass = bc_flux_mass; */
1145 /* } */
1146 if (isFluxBoundary_u == 1)
1147 {
1148 flux_umom = bc_flux_umom;
1149 //velocity[0] = bc_flux_umom/porosity;
1150 }
1151 if (isFluxBoundary_v == 1)
1152 {
1153 flux_vmom = bc_flux_vmom;
1154 //velocity[1] = bc_flux_umom/porosity;
1155 }
1156 if (isFluxBoundary_w == 1)
1157 {
1158 flux_wmom = bc_flux_wmom;
1159 //velocity[2] = bc_flux_umom/porosity;
1160 }
1161 }
1162
1163 inline
1164 void exteriorNumericalAdvectiveFluxDerivatives(const int& isDOFBoundary_p,
1165 const int& isDOFBoundary_u,
1166 const int& isDOFBoundary_v,
1167 const int& isDOFBoundary_w,
1168 const int& isFluxBoundary_p,
1169 const int& isFluxBoundary_u,
1170 const int& isFluxBoundary_v,
1171 const int& isFluxBoundary_w,
1172 const double& oneByRho,
1173 const double n[nSpace],
1174 const double& porosity, //mql. CHECK. Multiply by rho outside
1175 const double& bc_p,
1176 const double& bc_u,
1177 const double& bc_v,
1178 const double& bc_w,
1179 const double bc_f_mass[nSpace],
1180 const double bc_f_umom[nSpace],
1181 const double bc_f_vmom[nSpace],
1182 const double bc_f_wmom[nSpace],
1183 const double& bc_flux_mass,
1184 const double& bc_flux_umom,
1185 const double& bc_flux_vmom,
1186 const double& bc_flux_wmom,
1187 const double& p,
1188 const double& u,
1189 const double& v,
1190 const double& w,
1191 const double f_mass[nSpace],
1192 const double f_umom[nSpace],
1193 const double f_vmom[nSpace],
1194 const double f_wmom[nSpace],
1195 const double df_mass_du[nSpace],
1196 const double df_mass_dv[nSpace],
1197 const double df_mass_dw[nSpace],
1198 const double df_umom_dp[nSpace],
1199 const double df_umom_du[nSpace],
1200 const double df_umom_dv[nSpace],
1201 const double df_umom_dw[nSpace],
1202 const double df_vmom_dp[nSpace],
1203 const double df_vmom_du[nSpace],
1204 const double df_vmom_dv[nSpace],
1205 const double df_vmom_dw[nSpace],
1206 const double df_wmom_dp[nSpace],
1207 const double df_wmom_du[nSpace],
1208 const double df_wmom_dv[nSpace],
1209 const double df_wmom_dw[nSpace],
1210 double& dflux_mass_du,
1211 double& dflux_mass_dv,
1212 double& dflux_mass_dw,
1213 double& dflux_umom_dp,
1214 double& dflux_umom_du,
1215 double& dflux_umom_dv,
1216 double& dflux_umom_dw,
1217 double& dflux_vmom_dp,
1218 double& dflux_vmom_du,
1219 double& dflux_vmom_dv,
1220 double& dflux_vmom_dw,
1221 double& dflux_wmom_dp,
1222 double& dflux_wmom_du,
1223 double& dflux_wmom_dv,
1224 double& dflux_wmom_dw,
1225 double* velocity_star)
1226 {
1227 double flowSpeedNormal;
1228 dflux_mass_du = 0.0;
1229 dflux_mass_dv = 0.0;
1230 dflux_mass_dw = 0.0;
1231
1232 dflux_umom_dp = 0.0;
1233 dflux_umom_du = 0.0;
1234 dflux_umom_dv = 0.0;
1235 dflux_umom_dw = 0.0;
1236
1237 dflux_vmom_dp = 0.0;
1238 dflux_vmom_du = 0.0;
1239 dflux_vmom_dv = 0.0;
1240 dflux_vmom_dw = 0.0;
1241
1242 dflux_wmom_dp = 0.0;
1243 dflux_wmom_du = 0.0;
1244 dflux_wmom_dv = 0.0;
1245 dflux_wmom_dw = 0.0;
1246 flowSpeedNormal=porosity*(n[0]*velocity_star[0] +
1247 n[1]*velocity_star[1] +
1248 n[2]*velocity_star[2]);
1249 if (isDOFBoundary_u != 1)
1250 {
1251 dflux_mass_du += n[0]*df_mass_du[0];
1252 if (flowSpeedNormal < 0.0)
1253 dflux_umom_du -= flowSpeedNormal;
1254 }
1255 else
1256 {
1257 dflux_mass_du += n[0]*df_mass_du[0];
1258 if (flowSpeedNormal < 0.0)
1259 dflux_umom_du -= flowSpeedNormal;
1260 }
1261 if (isDOFBoundary_v != 1)
1262 {
1263 dflux_mass_dv += n[1]*df_mass_dv[1];
1264 if (flowSpeedNormal < 0.0)
1265 dflux_vmom_dv -= flowSpeedNormal;
1266 }
1267 else
1268 {
1269 dflux_mass_dv += n[1]*df_mass_dv[1];
1270 if (flowSpeedNormal < 0.0)
1271 dflux_vmom_dv -= flowSpeedNormal;
1272 }
1273 if (isDOFBoundary_w != 1)
1274 {
1275 dflux_mass_dw+=n[2]*df_mass_dw[2];
1276 if (flowSpeedNormal < 0.0)
1277 dflux_wmom_dw -= flowSpeedNormal;
1278 }
1279 else
1280 {
1281 dflux_mass_dw += n[2]*df_mass_dw[2];
1282 if (flowSpeedNormal < 0.0)
1283 dflux_wmom_dw -= flowSpeedNormal;
1284 }
1285 /* if (isDOFBoundary_p == 1) */
1286 /* { */
1287 /* dflux_umom_dp= -n[0]*oneByRho; */
1288 /* dflux_vmom_dp= -n[1]*oneByRho; */
1289 /* dflux_wmom_dp= -n[2]*oneByRho; */
1290 /* } */
1291 /* if (isFluxBoundary_p == 1) */
1292 /* { */
1293 /* dflux_mass_du = 0.0; */
1294 /* dflux_mass_dv = 0.0; */
1295 /* dflux_mass_dw = 0.0; */
1296 /* } */
1297 if (isFluxBoundary_u == 1)
1298 {
1299 dflux_umom_dp = 0.0;
1300 dflux_umom_du = 0.0;
1301 dflux_umom_dv = 0.0;
1302 dflux_umom_dw = 0.0;
1303 }
1304 if (isFluxBoundary_v == 1)
1305 {
1306 dflux_vmom_dp = 0.0;
1307 dflux_vmom_du = 0.0;
1308 dflux_vmom_dv = 0.0;
1309 dflux_vmom_dw = 0.0;
1310 }
1311 if (isFluxBoundary_w == 1)
1312 {
1313 dflux_wmom_dp = 0.0;
1314 dflux_wmom_du = 0.0;
1315 dflux_wmom_dv = 0.0;
1316 dflux_wmom_dw = 0.0;
1317 }
1318 }
1319
1320 inline
1321 void exteriorNumericalDiffusiveFlux(const double& eps,
1322 const double& phi,
1323 int* rowptr,
1324 int* colind,
1325 const int& isDOFBoundary,
1326 const int& isFluxBoundary,
1327 const double n[nSpace],
1328 double* bc_a,
1329 const double& bc_u,
1330 const double& bc_flux,
1331 double* a,
1332 const double grad_potential[nSpace],
1333 const double& u,
1334 const double& penalty,
1335 double& flux)
1336 {
1337 double diffusiveVelocityComponent_I,penaltyFlux,max_a;
1338 if(isFluxBoundary == 1)
1339 {
1340 flux = bc_flux;
1341 }
1342 else if(isDOFBoundary == 1)
1343 {
1344 flux = 0.0;
1345 max_a=0.0;
1346 for(int I=0;I<nSpace;I++)
1347 {
1348 diffusiveVelocityComponent_I=0.0;
1349 for(int m=rowptr[I];m<rowptr[I+1];m++)
1350 {
1351 diffusiveVelocityComponent_I -= a[m]*grad_potential[colind[m]];
1352 max_a = fmax(max_a,a[m]);
1353 }
1354 flux+= diffusiveVelocityComponent_I*n[I];
1355 }
1356 penaltyFlux = max_a*penalty*(u-bc_u);
1357 flux += penaltyFlux;
1358 //contact line slip
1359 //flux*=(gf.D(eps,0) - gf.D(eps,phi))/gf.D(eps,0);
1360 }
1361 else
1362 {
1363 std::cerr<<"RANS3PF: warning, diffusion term with no boundary condition set, setting diffusive flux to 0.0"<<std::endl;
1364 flux = 0.0;
1365 }
1366 }
1367
1368 inline
1369 double ExteriorNumericalDiffusiveFluxJacobian(const double& eps,
1370 const double& phi,
1371 int* rowptr,
1372 int* colind,
1373 const int& isDOFBoundary,
1374 const int& isFluxBoundary,
1375 const double n[nSpace],
1376 double* a,
1377 const double& v,
1378 const double grad_v[nSpace],
1379 const double& penalty)
1380 {
1381 double dvel_I,tmp=0.0,max_a=0.0;
1382 if(isFluxBoundary==0 && isDOFBoundary==1)
1383 {
1384 for(int I=0;I<nSpace;I++)
1385 {
1386 dvel_I=0.0;
1387 for(int m=rowptr[I];m<rowptr[I+1];m++)
1388 {
1389 dvel_I -= a[m]*grad_v[colind[m]];
1390 max_a = fmax(max_a,a[m]);
1391 }
1392 tmp += dvel_I*n[I];
1393 }
1394 tmp +=max_a*penalty*v;
1395 //contact line slip
1396 //tmp*=(gf.D(eps,0) - gf.D(eps,phi))/gf.D(eps,0);
1397 }
1398 return tmp;
1399 }
1400
1401 void get_symmetric_gradient_dot_vec(const double *grad_u, const double *grad_v, const double *grad_w, const double *n,double res[3])
1402 {
1403// res[0] = 2.0*grad_u[0]*n[0]+(grad_u[1]+grad_v[0])*n[1]+(grad_u[2]+grad_w[0])*n[2];
1404// res[1] = (grad_v[0]+grad_u[1])*n[0]+ 2*grad_v[1]*n[1]+(grad_v[2]+grad_w[1])*n[2];
1405// res[2] = (grad_w[0]+grad_u[2])*n[0]+(grad_w[1]+grad_v[2])*n[1]+ 2*grad_w[2]*n[2];
1406 res[0] = grad_u[0]*n[0]+grad_u[1]*n[1]+grad_u[2]*n[2];
1407 res[1] = grad_v[0]*n[0]+grad_v[1]*n[1]+grad_v[2]*n[2];
1408 res[2] = grad_w[0]*n[0]+grad_w[1]*n[1]+grad_w[2]*n[2];;
1409 }
1410 // n is the outward unit normal direction
1411 void get_stress_in_n(const double *grad_u, const double *grad_v, const double *grad_w, const double *n, double p, double mu, double f[3])
1412 {
1413 f[0] = 2.0*grad_u[0]*n[0]+(grad_u[1]+grad_v[0])*n[1]+(grad_u[2]+grad_w[0])*n[2];
1414 f[1] = (grad_v[0]+grad_u[1])*n[0]+ 2*grad_v[1]*n[1]+(grad_v[2]+grad_w[1])*n[2];
1415 f[2] = (grad_w[0]+grad_u[2])*n[0]+(grad_w[1]+grad_v[2])*n[1]+ 2*grad_w[2]*n[2];
1416
1417 f[0] *= mu;
1418 f[1] *= mu;
1419 f[2] *= mu;
1420
1421 f[0] -= p*n[0];
1422 f[1] -= p*n[1];
1423 f[2] -= p*n[2];
1424 }
1425 void get_cross_product(const double *u, const double *v,double res[3])
1426 {
1427 res[0] = u[1]*v[2]-u[2]*v[1];
1428 res[1] = u[2]*v[0]-u[0]*v[2];
1429 res[2] = u[0]*v[1]-u[1]*v[0];
1430 }
1431 double get_dot_product(const double *u, const double *v)
1432 {
1433 return u[0]*v[0]+u[1]*v[1]+u[2]*v[2];
1434 }
1435 int get_distance_to_ball(int n_balls,double* ball_center, double* ball_radius, double x, double y, double z, double& distance)
1436 {
1437 distance = 1e10;
1438 int index = -1;
1439 double d_ball_i;
1440 for (int i=0; i<n_balls; ++i)
1441 {
1442 d_ball_i = std::sqrt((ball_center[i*3+0]-x)*(ball_center[i*3+0]-x)
1443 +(ball_center[i*3+1]-y)*(ball_center[i*3+1]-y)
1444#ifndef USE_CYLINDER_AS_PARTICLE
1445 +(ball_center[i*3+2]-z)*(ball_center[i*3+2]-z)
1446#endif
1447 ) - ball_radius[i];
1448 if(d_ball_i<distance)
1449 {
1450 distance = d_ball_i;
1451 index = i;
1452 }
1453 }
1454 return index;
1455 }
1456 void get_distance_to_ith_ball(int n_balls,double* ball_center, double* ball_radius,
1457 int I,
1458 double x, double y, double z,
1459 double& distance)
1460 {
1461 distance = std::sqrt((ball_center[I*3+0]-x)*(ball_center[I*3+0]-x)
1462 + (ball_center[I*3+1]-y)*(ball_center[I*3+1]-y)
1463#ifndef USE_CYLINDER_AS_PARTICLE
1464 + (ball_center[I*3+2]-z)*(ball_center[I*3+2]-z)
1465#endif
1466 ) - ball_radius[I];
1467 }
1468 void get_normal_to_ith_ball(int n_balls,double* ball_center, double* ball_radius,
1469 int I,
1470 double x, double y, double z,
1471 double& nx, double& ny, double& nz)
1472 {
1473 double distance = std::sqrt((ball_center[I*3+0]-x)*(ball_center[I*3+0]-x)
1474 + (ball_center[I*3+1]-y)*(ball_center[I*3+1]-y)
1475#ifndef USE_CYLINDER_AS_PARTICLE
1476 + (ball_center[I*3+2]-z)*(ball_center[I*3+2]-z)
1477#endif
1478 );
1479 nx = (x - ball_center[I*3+0])/(distance+1e-10);
1480 ny = (y - ball_center[I*3+1])/(distance+1e-10);
1481#ifdef USE_CYLINDER_AS_PARTICLE
1482 nz = 0.0;
1483#else
1484 nz = (z - ball_center[I*3+2])/(distance+1e-10);
1485#endif
1486 }
1487 void get_velocity_to_ith_ball(int n_balls,double* ball_center, double* ball_radius,
1488 double* ball_velocity, double* ball_angular_velocity,
1489 int I,
1490 double x, double y, double z,
1491 double& vx, double& vy, double& vz)
1492 {
1493#ifdef USE_CYLINDER_AS_PARTICLE
1494 double position[3]={x-ball_center[3*I + 0],y-ball_center[3*I + 1],0.0};
1495#else
1496 double position[3]={x-ball_center[3*I + 0],y-ball_center[3*I + 1],z-ball_center[3*I + 2]};
1497#endif
1498 double angular_cross_position[3];
1499 get_cross_product(&ball_angular_velocity[3*I + 0],position,angular_cross_position);
1500 vx = ball_velocity[3*I + 0] + angular_cross_position[0];
1501 vy = ball_velocity[3*I + 1] + angular_cross_position[1];
1502 vz = ball_velocity[3*I + 2] + angular_cross_position[2];
1503
1504 }
1505 void calculateResidual(arguments_dict& args,
1506 bool useExact)
1507 {
1508 xt::pyarray<double>& mesh_trial_ref = args.array<double>("mesh_trial_ref");
1509 xt::pyarray<double>& mesh_grad_trial_ref = args.array<double>("mesh_grad_trial_ref");
1510 xt::pyarray<double>& mesh_dof = args.array<double>("mesh_dof");
1511 xt::pyarray<double>& mesh_velocity_dof = args.array<double>("mesh_velocity_dof");
1512 double MOVING_DOMAIN = args.scalar<double>("MOVING_DOMAIN");
1513 double PSTAB = args.scalar<double>("PSTAB");
1514 xt::pyarray<int>& mesh_l2g = args.array<int>("mesh_l2g");
1515 xt::pyarray<double>& x_ref = args.array<double>("x_ref");
1516 xt::pyarray<double>& dV_ref = args.array<double>("dV_ref");
1517 int nDOF_per_element_pressure = args.scalar<int>("nDOF_per_element_pressure");
1518 xt::pyarray<double>& p_trial_ref = args.array<double>("p_trial_ref");
1519 xt::pyarray<double>& p_grad_trial_ref = args.array<double>("p_grad_trial_ref");
1520 xt::pyarray<double>& p_test_ref = args.array<double>("p_test_ref");
1521 xt::pyarray<double>& p_grad_test_ref = args.array<double>("p_grad_test_ref");
1522 xt::pyarray<double>& q_p = args.array<double>("q_p");
1523 xt::pyarray<double>& q_grad_p = args.array<double>("q_grad_p");
1524 xt::pyarray<double>& ebqe_p = args.array<double>("ebqe_p");
1525 xt::pyarray<double>& ebqe_grad_p = args.array<double>("ebqe_grad_p");
1526 xt::pyarray<double>& vel_trial_ref = args.array<double>("vel_trial_ref");
1527 xt::pyarray<double>& vel_grad_trial_ref = args.array<double>("vel_grad_trial_ref");
1528 xt::pyarray<double>& vel_hess_trial_ref = args.array<double>("vel_hess_trial_ref");
1529 xt::pyarray<double>& vel_test_ref = args.array<double>("vel_test_ref");
1530 xt::pyarray<double>& vel_grad_test_ref = args.array<double>("vel_grad_test_ref");
1531 xt::pyarray<double>& mesh_trial_trace_ref = args.array<double>("mesh_trial_trace_ref");
1532 xt::pyarray<double>& mesh_grad_trial_trace_ref = args.array<double>("mesh_grad_trial_trace_ref");
1533 xt::pyarray<double>& dS_ref = args.array<double>("dS_ref");
1534 xt::pyarray<double>& p_trial_trace_ref = args.array<double>("p_trial_trace_ref");
1535 xt::pyarray<double>& p_grad_trial_trace_ref = args.array<double>("p_grad_trial_trace_ref");
1536 xt::pyarray<double>& p_test_trace_ref = args.array<double>("p_test_trace_ref");
1537 xt::pyarray<double>& p_grad_test_trace_ref = args.array<double>("p_grad_test_trace_ref");
1538 xt::pyarray<double>& vel_trial_trace_ref = args.array<double>("vel_trial_trace_ref");
1539 xt::pyarray<double>& vel_grad_trial_trace_ref = args.array<double>("vel_grad_trial_trace_ref");
1540 xt::pyarray<double>& vel_test_trace_ref = args.array<double>("vel_test_trace_ref");
1541 xt::pyarray<double>& vel_grad_test_trace_ref = args.array<double>("vel_grad_test_trace_ref");
1542 xt::pyarray<double>& normal_ref = args.array<double>("normal_ref");
1543 xt::pyarray<double>& boundaryJac_ref = args.array<double>("boundaryJac_ref");
1544 double eb_adjoint_sigma = args.scalar<double>("eb_adjoint_sigma");
1545 xt::pyarray<double>& elementDiameter = args.array<double>("elementDiameter");
1546 xt::pyarray<double>& nodeDiametersArray = args.array<double>("nodeDiametersArray");
1547 double hFactor = args.scalar<double>("hFactor");
1548 int nElements_global = args.scalar<int>("nElements_global");
1549 int nElements_owned = args.scalar<int>("nElements_owned");
1550 int nElementBoundaries_global = args.scalar<int>("nElementBoundaries_global");
1551 int nElementBoundaries_owned = args.scalar<int>("nElementBoundaries_owned");
1552 int nNodes_owned = args.scalar<int>("nNodes_owned");
1553 double useRBLES = args.scalar<double>("useRBLES");
1554 double useMetrics = args.scalar<double>("useMetrics");
1555 double alphaBDF = args.scalar<double>("alphaBDF");
1556 double epsFact_rho = args.scalar<double>("epsFact_rho");
1557 double epsFact_mu = args.scalar<double>("epsFact_mu");
1558 double sigma = args.scalar<double>("sigma");
1559 double rho_0 = args.scalar<double>("rho_0");
1560 double nu_0 = args.scalar<double>("nu_0");
1561 double rho_1 = args.scalar<double>("rho_1");
1562 double nu_1 = args.scalar<double>("nu_1");
1563 double smagorinskyConstant = args.scalar<double>("smagorinskyConstant");
1564 int turbulenceClosureModel = args.scalar<int>("turbulenceClosureModel");
1565 double Ct_sge = args.scalar<double>("Ct_sge");
1566 double Cd_sge = args.scalar<double>("Cd_sge");
1567 double C_dc = args.scalar<double>("C_dc");
1568 double C_b = args.scalar<double>("C_b");
1569 const xt::pyarray<double>& eps_solid = args.array<double>("eps_solid");
1570 const xt::pyarray<double>& ebq_global_phi_solid = args.array<double>("ebq_global_phi_solid");
1571 const xt::pyarray<double>& ebq_global_grad_phi_solid = args.array<double>("ebq_global_grad_phi_solid");
1572 const xt::pyarray<double>& ebq_particle_velocity_solid = args.array<double>("ebq_particle_velocity_solid");
1573 xt::pyarray<double>& phi_solid_nodes = args.array<double>("phi_solid_nodes");
1574 xt::pyarray<double>& phi_solid = args.array<double>("phi_solid");
1575 const xt::pyarray<double>& q_velocity_solid = args.array<double>("q_velocity_solid");
1576 const xt::pyarray<double>& q_velocityStar_solid = args.array<double>("q_velocityStar_solid");
1577 const xt::pyarray<double>& q_vos = args.array<double>("q_vos");
1578 const xt::pyarray<double>& q_dvos_dt = args.array<double>("q_dvos_dt");
1579 const xt::pyarray<double>& q_grad_vos = args.array<double>("q_grad_vos");
1580 const xt::pyarray<double>& q_dragAlpha = args.array<double>("q_dragAlpha");
1581 const xt::pyarray<double>& q_dragBeta = args.array<double>("q_dragBeta");
1582 const xt::pyarray<double>& q_mass_source = args.array<double>("q_mass_source");
1583 const xt::pyarray<double>& q_turb_var_0 = args.array<double>("q_turb_var_0");
1584 const xt::pyarray<double>& q_turb_var_1 = args.array<double>("q_turb_var_1");
1585 const xt::pyarray<double>& q_turb_var_grad_0 = args.array<double>("q_turb_var_grad_0");
1586 xt::pyarray<double>& q_eddy_viscosity = args.array<double>("q_eddy_viscosity");
1587 xt::pyarray<int>& p_l2g = args.array<int>("p_l2g");
1588 xt::pyarray<int>& vel_l2g = args.array<int>("vel_l2g");
1589 xt::pyarray<double>& p_dof = args.array<double>("p_dof");
1590 xt::pyarray<double>& u_dof = args.array<double>("u_dof");
1591 xt::pyarray<double>& v_dof = args.array<double>("v_dof");
1592 xt::pyarray<double>& w_dof = args.array<double>("w_dof");
1593 xt::pyarray<double>& u_dof_old = args.array<double>("u_dof_old");
1594 xt::pyarray<double>& v_dof_old = args.array<double>("v_dof_old");
1595 xt::pyarray<double>& w_dof_old = args.array<double>("w_dof_old");
1596 xt::pyarray<double>& u_dof_old_old = args.array<double>("u_dof_old_old");
1597 xt::pyarray<double>& v_dof_old_old = args.array<double>("v_dof_old_old");
1598 xt::pyarray<double>& w_dof_old_old = args.array<double>("w_dof_old_old");
1599 xt::pyarray<double>& uStar_dof = args.array<double>("uStar_dof");
1600 xt::pyarray<double>& vStar_dof = args.array<double>("vStar_dof");
1601 xt::pyarray<double>& wStar_dof = args.array<double>("wStar_dof");
1602 xt::pyarray<double>& g = args.array<double>("g");
1603 const double useVF = args.scalar<double>("useVF");
1604 xt::pyarray<double>& vf = args.array<double>("vf");
1605 xt::pyarray<double>& phi = args.array<double>("phi");
1606 xt::pyarray<double>& phi_dof = args.array<double>("phi_dof");
1607 xt::pyarray<double>& normal_phi = args.array<double>("normal_phi");
1608 xt::pyarray<double>& kappa_phi = args.array<double>("kappa_phi");
1609 xt::pyarray<double>& q_mom_u_acc = args.array<double>("q_mom_u_acc");
1610 xt::pyarray<double>& q_mom_v_acc = args.array<double>("q_mom_v_acc");
1611 xt::pyarray<double>& q_mom_w_acc = args.array<double>("q_mom_w_acc");
1612 xt::pyarray<double>& q_mass_adv = args.array<double>("q_mass_adv");
1613 xt::pyarray<double>& q_mom_u_acc_beta_bdf = args.array<double>("q_mom_u_acc_beta_bdf");
1614 xt::pyarray<double>& q_mom_v_acc_beta_bdf = args.array<double>("q_mom_v_acc_beta_bdf");
1615 xt::pyarray<double>& q_mom_w_acc_beta_bdf = args.array<double>("q_mom_w_acc_beta_bdf");
1616 xt::pyarray<double>& q_dV = args.array<double>("q_dV");
1617 xt::pyarray<double>& q_dV_last = args.array<double>("q_dV_last");
1618 xt::pyarray<double>& q_velocity_sge = args.array<double>("q_velocity_sge");
1619 xt::pyarray<double>& ebqe_velocity_star = args.array<double>("ebqe_velocity_star");
1620 xt::pyarray<double>& q_cfl = args.array<double>("q_cfl");
1621 xt::pyarray<double>& q_numDiff_u = args.array<double>("q_numDiff_u");
1622 xt::pyarray<double>& q_numDiff_v = args.array<double>("q_numDiff_v");
1623 xt::pyarray<double>& q_numDiff_w = args.array<double>("q_numDiff_w");
1624 xt::pyarray<double>& q_numDiff_u_last = args.array<double>("q_numDiff_u_last");
1625 xt::pyarray<double>& q_numDiff_v_last = args.array<double>("q_numDiff_v_last");
1626 xt::pyarray<double>& q_numDiff_w_last = args.array<double>("q_numDiff_w_last");
1627 xt::pyarray<int>& sdInfo_u_u_rowptr = args.array<int>("sdInfo_u_u_rowptr");
1628 xt::pyarray<int>& sdInfo_u_u_colind = args.array<int>("sdInfo_u_u_colind");
1629 xt::pyarray<int>& sdInfo_u_v_rowptr = args.array<int>("sdInfo_u_v_rowptr");
1630 xt::pyarray<int>& sdInfo_u_v_colind = args.array<int>("sdInfo_u_v_colind");
1631 xt::pyarray<int>& sdInfo_u_w_rowptr = args.array<int>("sdInfo_u_w_rowptr");
1632 xt::pyarray<int>& sdInfo_u_w_colind = args.array<int>("sdInfo_u_w_colind");
1633 xt::pyarray<int>& sdInfo_v_v_rowptr = args.array<int>("sdInfo_v_v_rowptr");
1634 xt::pyarray<int>& sdInfo_v_v_colind = args.array<int>("sdInfo_v_v_colind");
1635 xt::pyarray<int>& sdInfo_v_u_rowptr = args.array<int>("sdInfo_v_u_rowptr");
1636 xt::pyarray<int>& sdInfo_v_u_colind = args.array<int>("sdInfo_v_u_colind");
1637 xt::pyarray<int>& sdInfo_v_w_rowptr = args.array<int>("sdInfo_v_w_rowptr");
1638 xt::pyarray<int>& sdInfo_v_w_colind = args.array<int>("sdInfo_v_w_colind");
1639 xt::pyarray<int>& sdInfo_w_w_rowptr = args.array<int>("sdInfo_w_w_rowptr");
1640 xt::pyarray<int>& sdInfo_w_w_colind = args.array<int>("sdInfo_w_w_colind");
1641 xt::pyarray<int>& sdInfo_w_u_rowptr = args.array<int>("sdInfo_w_u_rowptr");
1642 xt::pyarray<int>& sdInfo_w_u_colind = args.array<int>("sdInfo_w_u_colind");
1643 xt::pyarray<int>& sdInfo_w_v_rowptr = args.array<int>("sdInfo_w_v_rowptr");
1644 xt::pyarray<int>& sdInfo_w_v_colind = args.array<int>("sdInfo_w_v_colind");
1645 int offset_p = args.scalar<int>("offset_p");
1646 int offset_u = args.scalar<int>("offset_u");
1647 int offset_v = args.scalar<int>("offset_v");
1648 int offset_w = args.scalar<int>("offset_w");
1649 int stride_p = args.scalar<int>("stride_p");
1650 int stride_u = args.scalar<int>("stride_u");
1651 int stride_v = args.scalar<int>("stride_v");
1652 int stride_w = args.scalar<int>("stride_w");
1653 xt::pyarray<double>& globalResidual = args.array<double>("globalResidual");
1654 int nExteriorElementBoundaries_global = args.scalar<int>("nExteriorElementBoundaries_global");
1655 xt::pyarray<int>& exteriorElementBoundariesArray = args.array<int>("exteriorElementBoundariesArray");
1656 xt::pyarray<int>& elementBoundariesArray = args.array<int>("elementBoundariesArray");
1657 xt::pyarray<int>& elementBoundaryElementsArray = args.array<int>("elementBoundaryElementsArray");
1658 xt::pyarray<int>& elementBoundaryLocalElementBoundariesArray = args.array<int>("elementBoundaryLocalElementBoundariesArray");
1659 xt::pyarray<double>& ebqe_vf_ext = args.array<double>("ebqe_vf_ext");
1660 xt::pyarray<double>& bc_ebqe_vf_ext = args.array<double>("bc_ebqe_vf_ext");
1661 xt::pyarray<double>& ebqe_phi_ext = args.array<double>("ebqe_phi_ext");
1662 xt::pyarray<double>& bc_ebqe_phi_ext = args.array<double>("bc_ebqe_phi_ext");
1663 xt::pyarray<double>& ebqe_normal_phi_ext = args.array<double>("ebqe_normal_phi_ext");
1664 xt::pyarray<double>& ebqe_kappa_phi_ext = args.array<double>("ebqe_kappa_phi_ext");
1665 const xt::pyarray<double>& ebqe_vos_ext = args.array<double>("ebqe_vos_ext");
1666 const xt::pyarray<double>& ebqe_turb_var_0 = args.array<double>("ebqe_turb_var_0");
1667 const xt::pyarray<double>& ebqe_turb_var_1 = args.array<double>("ebqe_turb_var_1");
1668 xt::pyarray<int>& isDOFBoundary_p = args.array<int>("isDOFBoundary_p");
1669 xt::pyarray<int>& isDOFBoundary_u = args.array<int>("isDOFBoundary_u");
1670 xt::pyarray<int>& isDOFBoundary_v = args.array<int>("isDOFBoundary_v");
1671 xt::pyarray<int>& isDOFBoundary_w = args.array<int>("isDOFBoundary_w");
1672 xt::pyarray<int>& isAdvectiveFluxBoundary_p = args.array<int>("isAdvectiveFluxBoundary_p");
1673 xt::pyarray<int>& isAdvectiveFluxBoundary_u = args.array<int>("isAdvectiveFluxBoundary_u");
1674 xt::pyarray<int>& isAdvectiveFluxBoundary_v = args.array<int>("isAdvectiveFluxBoundary_v");
1675 xt::pyarray<int>& isAdvectiveFluxBoundary_w = args.array<int>("isAdvectiveFluxBoundary_w");
1676 xt::pyarray<int>& isDiffusiveFluxBoundary_u = args.array<int>("isDiffusiveFluxBoundary_u");
1677 xt::pyarray<int>& isDiffusiveFluxBoundary_v = args.array<int>("isDiffusiveFluxBoundary_v");
1678 xt::pyarray<int>& isDiffusiveFluxBoundary_w = args.array<int>("isDiffusiveFluxBoundary_w");
1679 xt::pyarray<double>& ebqe_bc_p_ext = args.array<double>("ebqe_bc_p_ext");
1680 xt::pyarray<double>& ebqe_bc_flux_mass_ext = args.array<double>("ebqe_bc_flux_mass_ext");
1681 xt::pyarray<double>& ebqe_bc_flux_mom_u_adv_ext = args.array<double>("ebqe_bc_flux_mom_u_adv_ext");
1682 xt::pyarray<double>& ebqe_bc_flux_mom_v_adv_ext = args.array<double>("ebqe_bc_flux_mom_v_adv_ext");
1683 xt::pyarray<double>& ebqe_bc_flux_mom_w_adv_ext = args.array<double>("ebqe_bc_flux_mom_w_adv_ext");
1684 xt::pyarray<double>& ebqe_bc_u_ext = args.array<double>("ebqe_bc_u_ext");
1685 xt::pyarray<double>& ebqe_bc_flux_u_diff_ext = args.array<double>("ebqe_bc_flux_u_diff_ext");
1686 xt::pyarray<double>& ebqe_penalty_ext = args.array<double>("ebqe_penalty_ext");
1687 xt::pyarray<double>& ebqe_bc_v_ext = args.array<double>("ebqe_bc_v_ext");
1688 xt::pyarray<double>& ebqe_bc_flux_v_diff_ext = args.array<double>("ebqe_bc_flux_v_diff_ext");
1689 xt::pyarray<double>& ebqe_bc_w_ext = args.array<double>("ebqe_bc_w_ext");
1690 xt::pyarray<double>& ebqe_bc_flux_w_diff_ext = args.array<double>("ebqe_bc_flux_w_diff_ext");
1691 xt::pyarray<double>& q_x = args.array<double>("q_x");
1692 xt::pyarray<double>& q_velocity = args.array<double>("q_velocity");
1693 xt::pyarray<double>& ebqe_velocity = args.array<double>("ebqe_velocity");
1694 xt::pyarray<double>& q_grad_u = args.array<double>("q_grad_u");
1695 xt::pyarray<double>& q_grad_v = args.array<double>("q_grad_v");
1696 xt::pyarray<double>& q_grad_w = args.array<double>("q_grad_w");
1697 xt::pyarray<double>& q_divU = args.array<double>("q_divU");
1698 xt::pyarray<double>& ebqe_grad_u = args.array<double>("ebqe_grad_u");
1699 xt::pyarray<double>& ebqe_grad_v = args.array<double>("ebqe_grad_v");
1700 xt::pyarray<double>& ebqe_grad_w = args.array<double>("ebqe_grad_w");
1701 xt::pyarray<double>& flux = args.array<double>("flux");
1702 xt::pyarray<double>& elementResidual_p_save = args.array<double>("elementResidual_p_save");
1703 xt::pyarray<int>& elementFlags = args.array<int>("elementFlags");
1704 xt::pyarray<int>& boundaryFlags = args.array<int>("boundaryFlags");
1705 xt::pyarray<double>& barycenters = args.array<double>("barycenters");
1706 xt::pyarray<double>& wettedAreas = args.array<double>("wettedAreas");
1707 xt::pyarray<double>& netForces_p = args.array<double>("netForces_p");
1708 xt::pyarray<double>& netForces_v = args.array<double>("netForces_v");
1709 xt::pyarray<double>& netMoments = args.array<double>("netMoments");
1710 xt::pyarray<double>& q_rho = args.array<double>("q_rho");
1711 xt::pyarray<double>& ebqe_rho = args.array<double>("ebqe_rho");
1712 xt::pyarray<double>& q_nu = args.array<double>("q_nu");
1713 xt::pyarray<double>& ebqe_nu = args.array<double>("ebqe_nu");
1714 int nParticles = args.scalar<int>("nParticles");
1715 double particle_epsFact = args.scalar<double>("particle_epsFact");
1716 double particle_alpha = args.scalar<double>("particle_alpha");
1717 double particle_beta = args.scalar<double>("particle_beta");
1718 double particle_penalty_constant = args.scalar<double>("particle_penalty_constant");
1719 xt::pyarray<double>& particle_signed_distances = args.array<double>("particle_signed_distances");
1720 xt::pyarray<double>& particle_signed_distance_normals = args.array<double>("particle_signed_distance_normals");
1721 xt::pyarray<double>& particle_velocities = args.array<double>("particle_velocities");
1722 xt::pyarray<double>& particle_centroids = args.array<double>("particle_centroids");
1723 xt::pyarray<double>& particle_netForces = args.array<double>("particle_netForces");
1724 xt::pyarray<double>& particle_netMoments = args.array<double>("particle_netMoments");
1725 xt::pyarray<double>& particle_surfaceArea = args.array<double>("particle_surfaceArea");
1726 double particle_nitsche = args.scalar<double>("particle_nitsche");
1727 int use_ball_as_particle = args.scalar<int>("use_ball_as_particle");
1728 xt::pyarray<double>& ball_center = args.array<double>("ball_center");
1729 xt::pyarray<double>& ball_radius = args.array<double>("ball_radius");
1730 xt::pyarray<double>& ball_velocity = args.array<double>("ball_velocity");
1731 xt::pyarray<double>& ball_angular_velocity = args.array<double>("ball_angular_velocity");
1732 xt::pyarray<double>& phisError = args.array<double>("phisError");
1733 xt::pyarray<double>& phisErrorNodal = args.array<double>("phisErrorNodal");
1734 int USE_SUPG = args.scalar<int>("USE_SUPG");
1735 int ARTIFICIAL_VISCOSITY = args.scalar<int>("ARTIFICIAL_VISCOSITY");
1736 double cMax = args.scalar<double>("cMax");
1737 double cE = args.scalar<double>("cE");
1738 int MULTIPLY_EXTERNAL_FORCE_BY_DENSITY = args.scalar<int>("MULTIPLY_EXTERNAL_FORCE_BY_DENSITY");
1739 xt::pyarray<double>& forcex = args.array<double>("forcex");
1740 xt::pyarray<double>& forcey = args.array<double>("forcey");
1741 xt::pyarray<double>& forcez = args.array<double>("forcez");
1742 int KILL_PRESSURE_TERM = args.scalar<int>("KILL_PRESSURE_TERM");
1743 double dt = args.scalar<double>("dt");
1744 xt::pyarray<double>& quantDOFs = args.array<double>("quantDOFs");
1745 int MATERIAL_PARAMETERS_AS_FUNCTION = args.scalar<int>("MATERIAL_PARAMETERS_AS_FUNCTION");
1746 xt::pyarray<double>& density_as_function = args.array<double>("density_as_function");
1747 xt::pyarray<double>& dynamic_viscosity_as_function = args.array<double>("dynamic_viscosity_as_function");
1748 xt::pyarray<double>& ebqe_density_as_function = args.array<double>("ebqe_density_as_function");
1749 xt::pyarray<double>& ebqe_dynamic_viscosity_as_function = args.array<double>("ebqe_dynamic_viscosity_as_function");
1750 double order_polynomial = args.scalar<double>("order_polynomial");
1751 xt::pyarray<double>& isActiveDOF = args.array<double>("isActiveDOF");
1752 int USE_SBM = args.scalar<int>("USE_SBM");
1753 xt::pyarray<double>& ncDrag = args.array<double>("ncDrag");
1754 xt::pyarray<double>& betaDrag = args.array<double>("betaDrag");
1755 xt::pyarray<double>& vos_vel_nodes = args.array<double>("vos_vel_nodes");
1756 xt::pyarray<double>& entropyResidualPerNode = args.array<double>("entropyResidualPerNode");
1757 xt::pyarray<double>& laggedEntropyResidualPerNode = args.array<double>("laggedEntropyResidualPerNode");
1758 xt::pyarray<double>& uStar_dMatrix = args.array<double>("uStar_dMatrix");
1759 xt::pyarray<double>& vStar_dMatrix = args.array<double>("vStar_dMatrix");
1760 xt::pyarray<double>& wStar_dMatrix = args.array<double>("wStar_dMatrix");
1761 int numDOFs_1D = args.scalar<int>("numDOFs_1D");
1762 int NNZ_1D = args.scalar<int>("NNZ_1D");
1763 xt::pyarray<int>& csrRowIndeces_1D = args.array<int>("csrRowIndeces_1D");
1764 xt::pyarray<int>& csrColumnOffsets_1D = args.array<int>("csrColumnOffsets_1D");
1765 xt::pyarray<int>& rowptr_1D = args.array<int>("rowptr_1D");
1766 xt::pyarray<int>& colind_1D = args.array<int>("colind_1D");
1767 xt::pyarray<double>& isBoundary_1D = args.array<double>("isBoundary_1D");
1768 int INT_BY_PARTS_PRESSURE = args.scalar<int>("INT_BY_PARTS_PRESSURE");
1769 gf.useExact=useExact;
1770 gf_s.useExact=useExact;
1771 double element_uStar_He[nElements_global], element_vStar_He[nElements_global], element_wStar_He[nElements_global];
1772 uStar_hi.resize(numDOFs_1D,0.0);
1773 vStar_hi.resize(numDOFs_1D,0.0);
1774 wStar_hi.resize(numDOFs_1D,0.0);
1775 den_hi.resize(numDOFs_1D,0.0);
1776 uStar_min_hiHe.resize(numDOFs_1D,0.0);
1777 vStar_min_hiHe.resize(numDOFs_1D,0.0);
1778 wStar_min_hiHe.resize(numDOFs_1D,0.0);
1779 uStar_gamma.resize(numDOFs_1D,0.0);
1780 vStar_gamma.resize(numDOFs_1D,0.0);
1781 wStar_gamma.resize(numDOFs_1D,0.0);
1782 TransportMatrix.resize(NNZ_1D,0.0);
1783 TransposeTransportMatrix.resize(NNZ_1D,0.0);
1784 uStar_psi.resize(numDOFs_1D,0.0);
1785 vStar_psi.resize(numDOFs_1D,0.0);
1786 wStar_psi.resize(numDOFs_1D,0.0);
1787
1788 if (ARTIFICIAL_VISCOSITY==3 || ARTIFICIAL_VISCOSITY==4)
1789 {
1790 for (int i=0; i<NNZ_1D; i++)
1791 {
1792 uStar_dMatrix[i]=0.;
1793 vStar_dMatrix[i]=0.;
1794 wStar_dMatrix[i]=0.;
1795 TransportMatrix[i] = 0.;
1796 TransposeTransportMatrix[i] = 0.;
1797 }
1798 for (int i=0; i<numDOFs_1D; i++)
1799 {
1800 uStar_min_hiHe[i] = 1E100;
1801 vStar_min_hiHe[i] = 1E100;
1802 wStar_min_hiHe[i] = 1E100;
1803 entropyResidualPerNode[i]=0.;
1804 uStar_hi[i] = 0.;
1805 vStar_hi[i] = 0;
1806 wStar_hi[i] = 0.;
1807 den_hi[i] = 0.;
1808 }
1809 }
1810
1811 //
1812 //loop over elements to compute volume integrals and load them into element and global residual
1813 //
1814 double mesh_volume_conservation=0.0,
1815 mesh_volume_conservation_weak=0.0,
1816 mesh_volume_conservation_err_max=0.0,
1817 mesh_volume_conservation_err_max_weak=0.0;
1818 double globalConservationError=0.0;
1819 const int nQuadraturePoints_global(nElements_global*nQuadraturePoints_element);
1820 for(int eN=0;eN<nElements_global;eN++)
1821 {
1822 double elementTransport[nDOF_test_element][nDOF_trial_element];
1823 double elementTransposeTransport[nDOF_test_element][nDOF_trial_element];
1824 //declare local storage for element residual and initialize
1825 double elementResidual_p[nDOF_test_element],elementResidual_mesh[nDOF_test_element],
1826 elementResidual_u[nDOF_test_element],
1827 elementResidual_v[nDOF_test_element],
1828 mom_u_source_i[nDOF_test_element],
1829 mom_v_source_i[nDOF_test_element],
1830 mom_w_source_i[nDOF_test_element],
1831 betaDrag_i[nDOF_test_element],
1832 vos_i[nDOF_test_element],
1833 phisErrorElement[nDOF_test_element],
1834 elementResidual_w[nDOF_test_element],
1835 elementEntropyResidual[nDOF_test_element],
1836 eps_rho,eps_mu;
1837 double element_active=1.0;//use 1 since by default it is ibm
1838 double mesh_volume_conservation_element=0.0,
1839 mesh_volume_conservation_element_weak=0.0;
1840 // for entropy viscosity
1841 double linVisc_eN = 0, nlinVisc_eN_num = 0, nlinVisc_eN_den = 0;
1842 // for hessians of uStar
1843 double det_hess_uStar_Ke=0.0, det_hess_vStar_Ke=0.0, det_hess_wStar_Ke=0.0, area_Ke=0.0;
1844 for (int i=0;i<nDOF_test_element;i++)
1845 {
1846 int eN_i = eN*nDOF_test_element+i;
1847 elementResidual_p_save[eN_i]=0.0;
1848 elementResidual_mesh[i]=0.0;
1849 elementResidual_p[i]=0.0;
1850 elementResidual_u[i]=0.0;
1851 elementResidual_v[i]=0.0;
1852 mom_u_source_i[i]=0.0;
1853 mom_v_source_i[i]=0.0;
1854 mom_w_source_i[i]=0.0;
1855 betaDrag_i[i]=0.0;
1856 vos_i[i]=0.0;
1857 phisErrorElement[i]=0.0;
1858 elementResidual_w[i]=0.0;
1859 elementEntropyResidual[i]=0.0;
1860 if (ARTIFICIAL_VISCOSITY==3 || ARTIFICIAL_VISCOSITY==4)
1861 {
1862 for (int j=0;j<nDOF_trial_element;j++)
1863 {
1864 elementTransport[i][j]=0.0;
1865 elementTransposeTransport[i][j]=0.0;
1866 }
1867 }
1868 }//i
1869 //Use for plotting result
1870 if(use_ball_as_particle==1)
1871 {
1872 for (int I=0;I<nDOF_mesh_trial_element;I++)
1873 get_distance_to_ball(nParticles, ball_center.data(), ball_radius.data(),
1874 mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+I]+0],
1875 mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+I]+1],
1876 mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+I]+2],
1877 phi_solid_nodes[mesh_l2g[eN*nDOF_mesh_trial_element+I]]);
1878 }
1879 if(USE_SBM>0)
1880 {
1881 //isActiveDOF has value 1 for ibm.
1882 //isActiveDOF is initialized in python side.
1883 //
1884 //detect cut cells
1885 //
1886 double _distance[nDOF_mesh_trial_element]={0.0};
1887 int pos_counter=0;
1888 for (int I=0;I<nDOF_mesh_trial_element;I++)
1889 {
1890 if(use_ball_as_particle==1)
1891 {
1892 get_distance_to_ball(nParticles, ball_center.data(), ball_radius.data(),
1893 mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+I]+0],
1894 mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+I]+1],
1895 mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+I]+2],
1896 _distance[I]);
1897 }
1898 else
1899 {
1900 _distance[I] = phi_solid_nodes[mesh_l2g[eN*nDOF_mesh_trial_element+I]];
1901 }
1902 if ( _distance[I] >= 0)//fully in fluid
1903 pos_counter++;
1904 }
1905 if (pos_counter == 3)//surrogate face
1906 {
1907 element_active=0.0;
1908 int opp_node=-1;
1909 for (int I=0;I<nDOF_mesh_trial_element;I++)
1910 {
1911 if (_distance[I] < 0)
1912 opp_node = I;
1913 }
1914 assert(opp_node >=0);
1915 assert(opp_node <nDOF_mesh_trial_element);
1916 //For parallel. Two reasons:
1917 //if none of nodes of this edge is owned by this processor,
1918 //1. The surrogate_boundary_elements corresponding to this edge is -1, which gives 0 JacDet and infty h_penalty.
1919 //2. there is no contribution of the integral over this edge to Jacobian and residual.
1920 const int ebN = elementBoundariesArray[eN*nDOF_mesh_trial_element+opp_node];//only works for simplices
1921 const int eN_oppo = (eN == elementBoundaryElementsArray[ebN*2+0])?elementBoundaryElementsArray[ebN*2+1]:elementBoundaryElementsArray[ebN*2+0];
1922 if((mesh_l2g[eN*nDOF_mesh_trial_element+(opp_node+1)%4]<nNodes_owned
1923 || mesh_l2g[eN*nDOF_mesh_trial_element+(opp_node+2)%4]<nNodes_owned
1924 || mesh_l2g[eN*nDOF_mesh_trial_element+(opp_node+3)%4]<nNodes_owned
1925 )&&eN_oppo !=-1)//not a boundary face
1926 {
1927 surrogate_boundaries.push_back(ebN);
1928 //now find which element neighbor this element is
1929 //since each face has 2 neighbor elements.
1930 //YY: what if this face is a boundary face?
1931 if (eN == elementBoundaryElementsArray[ebN*2+0])
1932 surrogate_boundary_elements.push_back(1);
1933 else
1934 surrogate_boundary_elements.push_back(0);
1935
1936 //check which particle this surrogate edge is related to.
1937 //The method is to check one quadrature point inside of this element.
1938 //It works based on the assumption that the distance between any two particles
1939 //is larger than 2*h_min, otherwise it depends on the choice of the quadrature point
1940 //or one edge belongs to two particles .
1941 //But in any case, phi_s is well defined as the minimum.
1942 int j=-1;
1943 double distance=1e10, distance_to_ith_particle;
1944 if(use_ball_as_particle==1)
1945 {
1946 double middle_point_coord[3]={0.0};
1947 double middle_point_distance;
1948 middle_point_coord[0] = (mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+(opp_node+1)%4]+0]
1949 +mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+(opp_node+2)%4]+0]
1950 +mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+(opp_node+3)%4]+0])/3.0;
1951 middle_point_coord[1] = (mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+(opp_node+1)%4]+1]
1952 +mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+(opp_node+2)%4]+1]
1953 +mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+(opp_node+3)%4]+1])/3.0;
1954 middle_point_coord[2] = (mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+(opp_node+1)%4]+2]
1955 +mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+(opp_node+2)%4]+2]
1956 +mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+(opp_node+3)%4]+2])/3.0;
1957 j = get_distance_to_ball(nParticles, ball_center.data(), ball_radius.data(),
1958 middle_point_coord[0],middle_point_coord[1],middle_point_coord[2],
1959 middle_point_distance);
1960 }
1961 else
1962 {
1963 for (int i=0;i<nParticles;++i)
1964 {
1965 distance_to_ith_particle=particle_signed_distances[i*nElements_global*nQuadraturePoints_element
1966 +eN*nQuadraturePoints_element
1967 +0];//0-th quadrature point
1968 if (distance_to_ith_particle<distance)
1969 {
1970 distance = distance_to_ith_particle;
1971 j = i;
1972 }
1973 }
1974 }
1975 surrogate_boundary_particle.push_back(j);
1976 }else{
1977 //If the integral over the surrogate boundary is needed, we have to make sure all edges are in surrogate_boundaries,
1978 //which is based on the assumption that if none of its nodes is owned by the processor, then the edge is not owned
1979 //by the processor. This assert is used to make sure this is the case.
1980 if(ebN<nElementBoundaries_owned)//eN_oppo ==-1
1981 {
1982 assert(eN_oppo==-1);
1983 }
1984 }
1985 }
1986 else if (pos_counter == 4)// so the element is in fluid totally
1987 {
1988 element_active=1.0;
1989 for (int i=0;i<nDOF_test_element;i++)
1990 {
1991 isActiveDOF[offset_u+stride_u*vel_l2g[eN*nDOF_trial_element + i]]=1.0;
1992 isActiveDOF[offset_v+stride_v*vel_l2g[eN*nDOF_trial_element + i]]=1.0;
1993 isActiveDOF[offset_w+stride_w*vel_l2g[eN*nDOF_trial_element + i]]=1.0;
1994 }
1995 }
1996 else
1997 {
1998 element_active=0.0;
1999 }
2000 }
2001 double element_phi[nDOF_mesh_trial_element], element_phi_s[nDOF_mesh_trial_element];
2002 for (int j=0;j<nDOF_mesh_trial_element;j++)
2003 {
2004 int eN_j = eN*nDOF_mesh_trial_element+j;
2005 element_phi[j] = phi_dof[p_l2g[eN_j]];
2006 element_phi_s[j] = phi_solid_nodes[p_l2g[eN_j]];
2007 }
2008 double element_nodes[nDOF_mesh_trial_element*3];
2009 for (int i=0;i<nDOF_mesh_trial_element;i++)
2010 {
2011 int eN_i=eN*nDOF_mesh_trial_element+i;
2012 for(int I=0;I<3;I++)
2013 element_nodes[i*3 + I] = mesh_dof[mesh_l2g[eN_i]*3 + I];
2014 }//i
2015 gf_s.calculate(element_phi_s, element_nodes, x_ref.data(), false);
2016 gf.calculate(element_phi, element_nodes, x_ref.data(), false);
2017 //
2018 //loop over quadrature points and compute integrands
2019 //
2020 for(int k=0;k<nQuadraturePoints_element;k++)
2021 {
2022 gf.set_quad(k);
2023 gf_s.set_quad(k);
2024 //compute indices and declare local storage
2025 int eN_k = eN*nQuadraturePoints_element+k,
2026 eN_k_nSpace = eN_k*nSpace,
2027 eN_k_3d = eN_k*3,
2028 eN_nDOF_trial_element = eN*nDOF_trial_element;
2029 double p=0.0,u=0.0,v=0.0,w=0.0,un=0.0,vn=0.0,wn=0.0,
2030 grad_p[nSpace],grad_u[nSpace],grad_v[nSpace],grad_w[nSpace],
2031 hess_u[nSpace2],hess_v[nSpace2],hess_w[nSpace2],
2032 mom_u_acc=0.0,
2033 dmom_u_acc_u=0.0,
2034 mom_v_acc=0.0,
2035 dmom_v_acc_v=0.0,
2036 mom_w_acc=0.0,
2037 dmom_w_acc_w=0.0,
2038 mass_adv[nSpace],
2039 dmass_adv_u[nSpace],
2040 dmass_adv_v[nSpace],
2041 dmass_adv_w[nSpace],
2042 mom_u_adv[nSpace],
2043 dmom_u_adv_u[nSpace],
2044 dmom_u_adv_v[nSpace],
2045 dmom_u_adv_w[nSpace],
2046 mom_v_adv[nSpace],
2047 dmom_v_adv_u[nSpace],
2048 dmom_v_adv_v[nSpace],
2049 dmom_v_adv_w[nSpace],
2050 mom_w_adv[nSpace],
2051 dmom_w_adv_u[nSpace],
2052 dmom_w_adv_v[nSpace],
2053 dmom_w_adv_w[nSpace],
2054 mom_uu_diff_ten[nSpace],
2055 mom_vv_diff_ten[nSpace],
2056 mom_ww_diff_ten[nSpace],
2057 mom_uv_diff_ten[1],
2058 mom_uw_diff_ten[1],
2059 mom_vu_diff_ten[1],
2060 mom_vw_diff_ten[1],
2061 mom_wu_diff_ten[1],
2062 mom_wv_diff_ten[1],
2063 mom_u_source=0.0,
2064 mom_v_source=0.0,
2065 mom_w_source=0.0,
2066 mom_u_ham=0.0,
2067 dmom_u_ham_grad_p[nSpace],
2068 dmom_u_ham_grad_u[nSpace],
2069 mom_v_ham=0.0,
2070 dmom_v_ham_grad_p[nSpace],
2071 dmom_v_ham_grad_v[nSpace],
2072 mom_w_ham=0.0,
2073 dmom_w_ham_grad_p[nSpace],
2074 dmom_w_ham_grad_w[nSpace],
2075 mom_u_acc_t=0.0,
2076 dmom_u_acc_u_t=0.0,
2077 mom_v_acc_t=0.0,
2078 dmom_v_acc_v_t=0.0,
2079 mom_w_acc_t=0.0,
2080 dmom_w_acc_w_t=0.0,
2081 pdeResidual_p=0.0,
2082 pdeResidual_u=0.0,
2083 pdeResidual_v=0.0,
2084 pdeResidual_w=0.0,
2085 Lstar_u_p[nDOF_test_element],
2086 Lstar_v_p[nDOF_test_element],
2087 Lstar_w_p[nDOF_test_element],
2088 Lstar_u_u[nDOF_test_element],
2089 Lstar_v_v[nDOF_test_element],
2090 Lstar_w_w[nDOF_test_element],
2091 Lstar_p_u[nDOF_test_element],
2092 Lstar_p_v[nDOF_test_element],
2093 Lstar_p_w[nDOF_test_element],
2094 subgridError_p=0.0,
2095 subgridError_u=0.0,
2096 subgridError_v=0.0,
2097 subgridError_w=0.0,
2098 tau_p=0.0,tau_p0=0.0,tau_p1=0.0,
2099 tau_v=0.0,tau_v0=0.0,tau_v1=0.0,
2100 jac[nSpace*nSpace],
2101 jacDet,
2102 jacInv[nSpace*nSpace],
2103 p_grad_trial[nDOF_trial_element*nSpace],vel_grad_trial[nDOF_trial_element*nSpace],
2104 vel_hess_trial[nDOF_trial_element*nSpace2],
2105 p_test_dV[nDOF_trial_element],vel_test_dV[nDOF_trial_element],
2106 p_grad_test_dV[nDOF_test_element*nSpace],vel_grad_test_dV[nDOF_test_element*nSpace],
2107 u_times_vel_grad_test_dV[nDOF_test_element*nSpace], // For entropy residual
2108 v_times_vel_grad_test_dV[nDOF_test_element*nSpace], // For entropy residual
2109 w_times_vel_grad_test_dV[nDOF_test_element*nSpace], // For entropy residual
2110 dV,x,y,z,xt,yt,zt,
2111 //
2112 porosity,
2113 //meanGrainSize,
2114 mass_source,
2115 dmom_u_source[nSpace],
2116 dmom_v_source[nSpace],
2117 dmom_w_source[nSpace],
2118 //
2119 velStar[nSpace], hess_uStar[nSpace2], hess_vStar[nSpace2], hess_wStar[nSpace2],
2120 //
2121 G[nSpace*nSpace],G_dd_G,tr_G,norm_Rv,h_phi, dmom_adv_star[nSpace],dmom_adv_sge[nSpace];
2122 //get jacobian, etc for mapping reference element
2123 ck.calculateMapping_element(eN,
2124 k,
2125 mesh_dof.data(),
2126 mesh_l2g.data(),
2127 mesh_trial_ref.data(),
2128 mesh_grad_trial_ref.data(),
2129 jac,
2130 jacDet,
2131 jacInv,
2132 x,y,z);
2133 ck.calculateH_element(eN,
2134 k,
2135 nodeDiametersArray.data(),
2136 mesh_l2g.data(),
2137 mesh_trial_ref.data(),
2138 h_phi);
2139 ck.calculateMappingVelocity_element(eN,
2140 k,
2141 mesh_velocity_dof.data(),
2142 mesh_l2g.data(),
2143 mesh_trial_ref.data(),
2144 xt,yt,zt);
2145 //xt=0.0;yt=0.0;zt=0.0;
2146 //std::cout<<"xt "<<xt<<'\t'<<yt<<'\t'<<zt<<std::endl;
2147 //get the physical integration weight
2148 dV = fabs(jacDet)*dV_ref[k];
2149 ck.calculateG(jacInv,G,G_dd_G,tr_G);
2150 //ck.calculateGScale(G,&normal_phi[eN_k_nSpace],h_phi);
2151
2152 eps_rho = epsFact_rho*(useMetrics*h_phi+(1.0-useMetrics)*elementDiameter[eN]);
2153 eps_mu = epsFact_mu *(useMetrics*h_phi+(1.0-useMetrics)*elementDiameter[eN]);
2154 double particle_eps = particle_epsFact*(useMetrics*h_phi+(1.0-useMetrics)*elementDiameter[eN]);
2155
2156 //get the trial function gradients
2157 /* ck.gradTrialFromRef(&p_grad_trial_ref[k*nDOF_trial_element*nSpace],jacInv,p_grad_trial); */
2158 ck.gradTrialFromRef(&vel_grad_trial_ref[k*nDOF_trial_element*nSpace],jacInv,vel_grad_trial);
2159 ck.hessTrialFromRef(&vel_hess_trial_ref[k*nDOF_trial_element*nSpace2],jacInv,vel_hess_trial);
2160 //get the solution
2161 /* ck.valFromDOF(p_dof,&p_l2g[eN_nDOF_trial_element],&p_trial_ref[k*nDOF_trial_element],p); */
2162 p = q_p[eN_k];
2163 // get solution at quad points
2164 ck.valFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_ref[k*nDOF_trial_element],u);
2165 ck.valFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_ref[k*nDOF_trial_element],v);
2166 ck.valFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_ref[k*nDOF_trial_element],w);
2167 // get old solution at quad points
2168 ck.valFromDOF(u_dof_old.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_ref[k*nDOF_trial_element],un);
2169 ck.valFromDOF(v_dof_old.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_ref[k*nDOF_trial_element],vn);
2170 ck.valFromDOF(w_dof_old.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_ref[k*nDOF_trial_element],wn);
2171 //get the solution gradients
2172 /* ck.gradFromDOF(p_dof,&p_l2g[eN_nDOF_trial_element],p_grad_trial,grad_p); */
2173 for (int I=0;I<nSpace;I++)
2174 grad_p[I] = q_grad_p[eN_k_nSpace + I];
2175 ck.gradFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial,grad_u);
2176 ck.gradFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial,grad_v);
2177 ck.gradFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial,grad_w);
2178 ck.hessFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_hess_trial,hess_u);
2179 ck.hessFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_hess_trial,hess_v);
2180 ck.hessFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_hess_trial,hess_w);
2181 ck.hessFromDOF(uStar_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_hess_trial,hess_uStar);
2182 ck.hessFromDOF(vStar_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_hess_trial,hess_vStar);
2183 ck.hessFromDOF(wStar_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_hess_trial,hess_wStar);
2184 //precalculate test function products with integration weights
2185 for (int j=0;j<nDOF_trial_element;j++)
2186 {
2187 /* p_test_dV[j] = p_test_ref[k*nDOF_trial_element+j]*dV; */
2188 vel_test_dV[j] = vel_test_ref[k*nDOF_trial_element+j]*dV;
2189 for (int I=0;I<nSpace;I++)
2190 {
2191 /* p_grad_test_dV[j*nSpace+I] = p_grad_trial[j*nSpace+I]*dV;//cek warning won't work for Petrov-Galerkin */
2192 vel_grad_test_dV[j*nSpace+I] = vel_grad_trial[j*nSpace+I]*dV;//cek warning won't work for Petrov-Galerkin
2193 if (ARTIFICIAL_VISCOSITY==4)
2194 {
2195 // mql: for entropy residual. grad(u*phi) and grad(v*phi)
2196 u_times_vel_grad_test_dV[j*nSpace+I] =
2197 u*vel_grad_trial[j*nSpace+I]*dV + vel_test_dV[j]*grad_u[I];
2198 v_times_vel_grad_test_dV[j*nSpace+I] =
2199 v*vel_grad_trial[j*nSpace+I]*dV + vel_test_dV[j]*grad_v[I];
2200 w_times_vel_grad_test_dV[j*nSpace+I] =
2201 w*vel_grad_trial[j*nSpace+I]*dV + vel_test_dV[j]*grad_w[I];
2202 }
2203 }
2204 }
2205 // compute determinant of Hessians
2206 if (ARTIFICIAL_VISCOSITY==3)
2207 {
2208 det_hess_uStar_Ke +=
2209 (hess_uStar[0]*(hess_uStar[4]*hess_uStar[8] - hess_uStar[7]*hess_uStar[5])
2210 -hess_uStar[1]*(hess_uStar[3]*hess_uStar[8] - hess_uStar[6]*hess_uStar[5])
2211 +hess_uStar[2]*(hess_uStar[3]*hess_uStar[7] - hess_uStar[6]*hess_uStar[4]))*dV;
2212 det_hess_vStar_Ke +=
2213 (hess_vStar[0]*(hess_vStar[4]*hess_vStar[8] - hess_vStar[7]*hess_vStar[5])
2214 -hess_vStar[1]*(hess_vStar[3]*hess_vStar[8] - hess_vStar[6]*hess_vStar[5])
2215 +hess_vStar[2]*(hess_vStar[3]*hess_vStar[7] - hess_vStar[6]*hess_vStar[4]))*dV;
2216 det_hess_wStar_Ke +=
2217 (hess_wStar[0]*(hess_wStar[4]*hess_wStar[8] - hess_wStar[7]*hess_wStar[5])
2218 -hess_wStar[1]*(hess_wStar[3]*hess_wStar[8] - hess_wStar[6]*hess_wStar[5])
2219 +hess_wStar[2]*(hess_wStar[3]*hess_wStar[7] - hess_wStar[6]*hess_wStar[4]))*dV;
2220 area_Ke += dV;
2221 }
2222 //cek hack
2223 double div_mesh_velocity=0.0;
2224 int NDOF_MESH_TRIAL_ELEMENT=4;
2225 for (int j=0;j<NDOF_MESH_TRIAL_ELEMENT;j++)
2226 {
2227 int eN_j=eN*NDOF_MESH_TRIAL_ELEMENT+j;
2228 div_mesh_velocity +=
2229 mesh_velocity_dof[mesh_l2g[eN_j]*3+0]*vel_grad_trial[j*nSpace+0] +
2230 mesh_velocity_dof[mesh_l2g[eN_j]*3+1]*vel_grad_trial[j*nSpace+1] +
2231 mesh_velocity_dof[mesh_l2g[eN_j]*3+2]*vel_grad_trial[j*nSpace+2];
2232 }
2233 mesh_volume_conservation_element += (alphaBDF*(dV-q_dV_last[eN_k])/dV - div_mesh_velocity)*dV;
2234 div_mesh_velocity = DM3*div_mesh_velocity + (1.0-DM3)*alphaBDF*(dV-q_dV_last[eN_k])/dV;
2235 //VRANS
2236 porosity = 1.0 - q_vos[eN_k];
2237 //meanGrainSize = q_meanGrain[eN_k];
2238 //
2239 q_x[eN_k_3d+0]=x;
2240 q_x[eN_k_3d+1]=y;
2241 q_x[eN_k_3d+2]=z;
2242 //
2243 //calculate pde coefficients at quadrature points
2244 //
2245 double distance_to_omega_solid = 1e10;
2246 if(use_ball_as_particle==1)
2247 {
2248 get_distance_to_ball(nParticles, ball_center.data(), ball_radius.data(),
2249 x,y,z,
2250 distance_to_omega_solid);
2251 }
2252 else
2253 {
2254 for (int i = 0; i < nParticles; i++)
2255 {
2256 double distance_to_i_th_solid = particle_signed_distances[i * nElements_global * nQuadraturePoints_element + eN_k];
2257 distance_to_omega_solid = (distance_to_i_th_solid < distance_to_omega_solid)?distance_to_i_th_solid:distance_to_omega_solid;
2258 }
2259 }
2260 phi_solid[eN_k] = distance_to_omega_solid;//save it
2261 //
2262 //calculate pde coefficients at quadrature points
2263 //
2264 evaluateCoefficients(eps_rho,
2265 eps_mu,
2266 particle_eps,
2267 sigma,
2268 rho_0,
2269 nu_0,
2270 rho_1,
2271 nu_1,
2272 elementDiameter[eN],
2273 smagorinskyConstant,
2274 turbulenceClosureModel,
2275 g.data(),
2276 useVF,
2277 vf[eN_k],
2278 phi[eN_k],
2279 &normal_phi[eN_k_nSpace],
2280 distance_to_omega_solid,
2281 kappa_phi[eN_k],
2282 //VRANS
2283 porosity,
2284 //
2285 p,
2286 grad_p,
2287 grad_u,
2288 grad_v,
2289 grad_w,
2290 u,
2291 v,
2292 w,
2293 q_velocity_sge[eN_k_nSpace+0],
2294 q_velocity_sge[eN_k_nSpace+1],
2295 q_velocity_sge[eN_k_nSpace+2],
2296 q_eddy_viscosity[eN_k],
2297 mom_u_acc,
2298 dmom_u_acc_u,
2299 mom_v_acc,
2300 dmom_v_acc_v,
2301 mom_w_acc,
2302 dmom_w_acc_w,
2303 mass_adv,
2304 dmass_adv_u,
2305 dmass_adv_v,
2306 dmass_adv_w,
2307 mom_u_adv,
2308 dmom_u_adv_u,
2309 dmom_u_adv_v,
2310 dmom_u_adv_w,
2311 mom_v_adv,
2312 dmom_v_adv_u,
2313 dmom_v_adv_v,
2314 dmom_v_adv_w,
2315 mom_w_adv,
2316 dmom_w_adv_u,
2317 dmom_w_adv_v,
2318 dmom_w_adv_w,
2319 mom_uu_diff_ten,
2320 mom_vv_diff_ten,
2321 mom_ww_diff_ten,
2322 mom_uv_diff_ten,
2323 mom_uw_diff_ten,
2324 mom_vu_diff_ten,
2325 mom_vw_diff_ten,
2326 mom_wu_diff_ten,
2327 mom_wv_diff_ten,
2328 mom_u_source,
2329 mom_v_source,
2330 mom_w_source,
2331 mom_u_ham,
2332 dmom_u_ham_grad_p,
2333 dmom_u_ham_grad_u,
2334 mom_v_ham,
2335 dmom_v_ham_grad_p,
2336 dmom_v_ham_grad_v,
2337 mom_w_ham,
2338 dmom_w_ham_grad_p,
2339 dmom_w_ham_grad_w,
2340 q_rho[eN_k],
2341 q_nu[eN_k],
2342 KILL_PRESSURE_TERM,
2343 MULTIPLY_EXTERNAL_FORCE_BY_DENSITY,
2344 forcex[eN_k],
2345 forcey[eN_k],
2346 forcez[eN_k],
2347 MATERIAL_PARAMETERS_AS_FUNCTION,
2348 density_as_function[eN_k],
2349 dynamic_viscosity_as_function[eN_k],
2350 USE_SBM,
2351 x,y,z,
2352 use_ball_as_particle,
2353 ball_center.data(),
2354 ball_radius.data(),
2355 ball_velocity.data(),
2356 ball_angular_velocity.data(),
2357 INT_BY_PARTS_PRESSURE);
2358
2359 //VRANS
2360 mass_source = q_mass_source[eN_k];
2361 for (int I=0;I<nSpace;I++)
2362 {
2363 dmom_u_source[I] = 0.0;
2364 dmom_v_source[I] = 0.0;
2365 dmom_w_source[I] = 0.0;
2366 }
2367 updateDarcyForchheimerTerms_Ergun(
2368 q_dragAlpha[eN_k],
2369 q_dragBeta[eN_k],
2370 eps_rho,
2371 eps_mu,
2372 rho_0,
2373 nu_0,
2374 rho_1,
2375 nu_1,
2376 q_eddy_viscosity[eN_k],
2377 useVF,
2378 vf[eN_k],
2379 phi[eN_k],
2380 u,
2381 v,
2382 w,
2383 q_velocity_sge[eN_k_nSpace+0],
2384 q_velocity_sge[eN_k_nSpace+1],
2385 q_velocity_sge[eN_k_nSpace+2],
2386 eps_solid[elementFlags[eN]],
2387 porosity,
2388 q_velocity_solid[eN_k_nSpace+0],
2389 q_velocity_solid[eN_k_nSpace+1],
2390 q_velocity_solid[eN_k_nSpace+2],
2391 q_velocityStar_solid[eN_k_nSpace+0],
2392 q_velocityStar_solid[eN_k_nSpace+1],
2393 q_velocityStar_solid[eN_k_nSpace+2],
2394 mom_u_source,
2395 mom_v_source,
2396 mom_w_source,
2397 dmom_u_source,
2398 dmom_v_source,
2399 dmom_w_source,
2400 q_grad_vos[eN_k_nSpace+0],
2401 q_grad_vos[eN_k_nSpace+1],
2402 q_grad_vos[eN_k_nSpace+2]);
2403 double C_particles = 0.0;
2404 if (nParticles > 0 && USE_SBM==0)
2405 updateSolidParticleTerms(eN < nElements_owned,
2406 particle_nitsche,
2407 dV,
2408 nParticles,
2409 nQuadraturePoints_global,
2410 &particle_signed_distances[eN_k],
2411 &particle_signed_distance_normals[eN_k_nSpace],
2412 &particle_velocities[eN_k_nSpace],
2413 particle_centroids.data(),
2414 use_ball_as_particle,
2415 ball_center.data(),
2416 ball_radius.data(),
2417 ball_velocity.data(),
2418 ball_angular_velocity.data(),
2419 porosity,
2420 particle_penalty_constant/h_phi,
2421 particle_alpha/h_phi,
2422 particle_beta/h_phi,
2423 eps_rho,
2424 eps_mu,
2425 rho_0,
2426 nu_0,
2427 rho_1,
2428 nu_1,
2429 useVF,
2430 vf[eN_k],
2431 phi[eN_k],
2432 x,
2433 y,
2434 z,
2435 p,
2436 u,
2437 v,
2438 w,
2439 q_velocity_sge[eN_k_nSpace + 0],
2440 q_velocity_sge[eN_k_nSpace + 1],
2441 q_velocity_sge[eN_k_nSpace + 2],
2442 particle_eps,
2443 grad_u,
2444 grad_v,
2445 grad_w,
2446 mom_u_source,
2447 mom_v_source,
2448 mom_w_source,
2449 dmom_u_source,
2450 dmom_v_source,
2451 dmom_w_source,
2452 mom_u_adv,
2453 mom_v_adv,
2454 mom_w_adv,
2455 dmom_u_adv_u,
2456 dmom_v_adv_v,
2457 dmom_w_adv_w,
2458 mom_u_ham,
2459 dmom_u_ham_grad_u,
2460 mom_v_ham,
2461 dmom_v_ham_grad_v,
2462 mom_w_ham,
2463 dmom_w_ham_grad_w,
2464 particle_netForces.data(),
2465 particle_netMoments.data(),
2466 particle_surfaceArea.data());
2467 //Turbulence closure model
2468 if (turbulenceClosureModel >= 3)
2469 {
2470 const double c_mu = 0.09;//mwf hack
2471 updateTurbulenceClosure(turbulenceClosureModel,
2472 eps_rho,
2473 eps_mu,
2474 rho_0,
2475 nu_0,
2476 rho_1,
2477 nu_1,
2478 useVF,
2479 vf[eN_k],
2480 phi[eN_k],
2481 porosity,
2482 c_mu, //mwf hack
2483 q_turb_var_0[eN_k],
2484 q_turb_var_1[eN_k],
2485 &q_turb_var_grad_0[eN_k_nSpace],
2486 q_eddy_viscosity[eN_k],
2487 mom_uu_diff_ten,
2488 mom_vv_diff_ten,
2489 mom_ww_diff_ten,
2490 mom_uv_diff_ten,
2491 mom_uw_diff_ten,
2492 mom_vu_diff_ten,
2493 mom_vw_diff_ten,
2494 mom_wu_diff_ten,
2495 mom_wv_diff_ten,
2496 mom_u_source,
2497 mom_v_source,
2498 mom_w_source);
2499
2500 }
2501 //
2502 //save momentum for time history and velocity for subgrid error
2503 //
2504 q_mom_u_acc[eN_k] = mom_u_acc;
2505 q_mom_v_acc[eN_k] = mom_v_acc;
2506 q_mom_w_acc[eN_k] = mom_w_acc;
2507 //subgrid error uses grid scale velocity
2508 q_mass_adv[eN_k_nSpace+0] = u;
2509 q_mass_adv[eN_k_nSpace+1] = v;
2510 q_mass_adv[eN_k_nSpace+2] = w;
2511 //
2512 //moving mesh
2513 //
2514 mom_u_adv[0] -= MOVING_DOMAIN*dmom_u_acc_u*mom_u_acc*xt; // multiply by rho*porosity. mql. CHECK.
2515 mom_u_adv[1] -= MOVING_DOMAIN*dmom_u_acc_u*mom_u_acc*yt;
2516 mom_u_adv[2] -= MOVING_DOMAIN*dmom_u_acc_u*mom_u_acc*zt;
2517 dmom_u_adv_u[0] -= MOVING_DOMAIN*dmom_u_acc_u*xt;
2518 dmom_u_adv_u[1] -= MOVING_DOMAIN*dmom_u_acc_u*yt;
2519 dmom_u_adv_u[2] -= MOVING_DOMAIN*dmom_u_acc_u*zt;
2520
2521 mom_v_adv[0] -= MOVING_DOMAIN*dmom_v_acc_v*mom_v_acc*xt;
2522 mom_v_adv[1] -= MOVING_DOMAIN*dmom_v_acc_v*mom_v_acc*yt;
2523 mom_v_adv[2] -= MOVING_DOMAIN*dmom_v_acc_v*mom_v_acc*zt;
2524 dmom_v_adv_v[0] -= MOVING_DOMAIN*dmom_v_acc_v*xt;
2525 dmom_v_adv_v[1] -= MOVING_DOMAIN*dmom_v_acc_v*yt;
2526 dmom_v_adv_v[2] -= MOVING_DOMAIN*dmom_v_acc_v*zt;
2527
2528 mom_w_adv[0] -= MOVING_DOMAIN*dmom_w_acc_w*mom_w_acc*xt;
2529 mom_w_adv[1] -= MOVING_DOMAIN*dmom_w_acc_w*mom_w_acc*yt;
2530 mom_w_adv[2] -= MOVING_DOMAIN*dmom_w_acc_w*mom_w_acc*zt;
2531 dmom_w_adv_w[0] -= MOVING_DOMAIN*dmom_w_acc_w*xt;
2532 dmom_w_adv_w[1] -= MOVING_DOMAIN*dmom_w_acc_w*yt;
2533 dmom_w_adv_w[2] -= MOVING_DOMAIN*dmom_w_acc_w*zt;
2534
2535 //
2536 //calculate time derivative at quadrature points
2537 //
2538 if (q_dV_last[eN_k] <= -100)
2539 q_dV_last[eN_k] = dV;
2540 q_dV[eN_k] = dV;
2541 ck.bdf(alphaBDF,
2542 q_mom_u_acc_beta_bdf[eN_k]*q_dV_last[eN_k]/dV,
2543 mom_u_acc,
2544 dmom_u_acc_u,
2545 mom_u_acc_t,
2546 dmom_u_acc_u_t);
2547 ck.bdf(alphaBDF,
2548 q_mom_v_acc_beta_bdf[eN_k]*q_dV_last[eN_k]/dV,
2549 mom_v_acc,
2550 dmom_v_acc_v,
2551 mom_v_acc_t,
2552 dmom_v_acc_v_t);
2553 ck.bdf(alphaBDF,
2554 q_mom_w_acc_beta_bdf[eN_k]*q_dV_last[eN_k]/dV,
2555 mom_w_acc,
2556 dmom_w_acc_w,
2557 mom_w_acc_t,
2558 dmom_w_acc_w_t);
2559
2560 mom_u_acc_t *= dmom_u_acc_u; //multiply by rho*porosity. mql. CHECK.
2561 mom_v_acc_t *= dmom_v_acc_v;
2562 mom_w_acc_t *= dmom_w_acc_w;
2563
2564
2565 //
2566 //calculate subgrid error (strong residual and adjoint)
2567 //
2568 //calculate strong residual
2569 pdeResidual_p =
2570 ck.Mass_strong(-q_dvos_dt[eN_k]) + // mql. CHECK.
2571 ck.Advection_strong(dmass_adv_u,grad_u) +
2572 ck.Advection_strong(dmass_adv_v,grad_v) +
2573 ck.Advection_strong(dmass_adv_w,grad_w) +
2574 DM2*MOVING_DOMAIN*ck.Reaction_strong(alphaBDF*(dV-q_dV_last[eN_k])/dV - div_mesh_velocity) +
2575 //VRANS
2576 ck.Reaction_strong(mass_source);
2577 //
2578
2579 dmom_adv_sge[0] = dmom_u_acc_u*(q_velocity_sge[eN_k_nSpace+0] - MOVING_DOMAIN*xt);
2580 dmom_adv_sge[1] = dmom_u_acc_u*(q_velocity_sge[eN_k_nSpace+1] - MOVING_DOMAIN*yt);
2581 dmom_adv_sge[2] = dmom_u_acc_u*(q_velocity_sge[eN_k_nSpace+2] - MOVING_DOMAIN*zt);
2582
2583 pdeResidual_u =
2584 ck.Mass_strong(mom_u_acc_t) + // mql. CHECK.
2585 ck.Advection_strong(dmom_adv_sge,grad_u) + //note here and below: same in cons. and non-cons.
2586 ck.Hamiltonian_strong(dmom_u_ham_grad_p,grad_p) +
2587 ck.Reaction_strong(mom_u_source) -
2588 ck.Reaction_strong(u*div_mesh_velocity);
2589
2590 pdeResidual_v =
2591 ck.Mass_strong(mom_v_acc_t) +
2592 ck.Advection_strong(dmom_adv_sge,grad_v) +
2593 ck.Hamiltonian_strong(dmom_v_ham_grad_p,grad_p) +
2594 ck.Reaction_strong(mom_v_source) -
2595 ck.Reaction_strong(v*div_mesh_velocity);
2596
2597 pdeResidual_w =
2598 ck.Mass_strong(mom_w_acc_t) +
2599 ck.Advection_strong(dmom_adv_sge,grad_w) +
2600 ck.Hamiltonian_strong(dmom_w_ham_grad_p,grad_p) +
2601 ck.Reaction_strong(mom_w_source) -
2602 ck.Reaction_strong(w*div_mesh_velocity);
2603
2604 //calculate tau and tau*Res
2605 //cek debug
2606 double tmpR=dmom_u_acc_u_t + dmom_u_source[0];
2607 calculateSubgridError_tau(hFactor,
2608 elementDiameter[eN],
2609 tmpR,//dmom_u_acc_u_t,
2610 dmom_u_acc_u,
2611 dmom_adv_sge,
2612 mom_uu_diff_ten[1],
2613 dmom_u_ham_grad_p[0],
2614 tau_v0,
2615 tau_p0,
2616 q_cfl[eN_k]);
2617
2618 calculateSubgridError_tau(Ct_sge,Cd_sge,
2619 G,G_dd_G,tr_G,
2620 tmpR,//dmom_u_acc_u_t,
2621 dmom_adv_sge,
2622 mom_uu_diff_ten[1],
2623 dmom_u_ham_grad_p[0],
2624 tau_v1,
2625 tau_p1,
2626 q_cfl[eN_k]);
2627
2628 tau_v = useMetrics*tau_v1+(1.0-useMetrics)*tau_v0;
2629 tau_p = KILL_PRESSURE_TERM == 1 ? 0. : PSTAB*(useMetrics*tau_p1+(1.0-useMetrics)*tau_p0);
2630
2631 calculateSubgridError_tauRes(tau_p,
2632 tau_v,
2633 pdeResidual_p,
2634 pdeResidual_u,
2635 pdeResidual_v,
2636 pdeResidual_w,
2637 subgridError_p,
2638 subgridError_u,
2639 subgridError_v,
2640 subgridError_w);
2641 // velocity used in adjoint (VMS or RBLES, with or without lagging the grid scale velocity)
2642 dmom_adv_star[0] = dmom_u_acc_u*(q_velocity_sge[eN_k_nSpace+0] - MOVING_DOMAIN*xt + useRBLES*subgridError_u);
2643 dmom_adv_star[1] = dmom_u_acc_u*(q_velocity_sge[eN_k_nSpace+1] - MOVING_DOMAIN*yt + useRBLES*subgridError_v);
2644 dmom_adv_star[2] = dmom_u_acc_u*(q_velocity_sge[eN_k_nSpace+2] - MOVING_DOMAIN*zt + useRBLES*subgridError_w);
2645
2646 mom_u_adv[0] += dmom_u_acc_u*(useRBLES*subgridError_u*q_velocity_sge[eN_k_nSpace+0]);
2647 mom_u_adv[1] += dmom_u_acc_u*(useRBLES*subgridError_v*q_velocity_sge[eN_k_nSpace+1]);
2648 mom_u_adv[2] += dmom_u_acc_u*(useRBLES*subgridError_w*q_velocity_sge[eN_k_nSpace+2]);
2649
2650 // adjoint times the test functions
2651 for (int i=0;i<nDOF_test_element;i++)
2652 {
2653 int i_nSpace = i*nSpace;
2654 /* Lstar_u_p[i]=ck.Advection_adjoint(dmass_adv_u,&p_grad_test_dV[i_nSpace]); */
2655 /* Lstar_v_p[i]=ck.Advection_adjoint(dmass_adv_v,&p_grad_test_dV[i_nSpace]); */
2656 /* Lstar_w_p[i]=ck.Advection_adjoint(dmass_adv_w,&p_grad_test_dV[i_nSpace]); */
2657 //use the same advection adjoint for all three since we're approximating the linearized adjoint
2658 Lstar_u_u[i]=ck.Advection_adjoint(dmom_adv_star,&vel_grad_test_dV[i_nSpace]);
2659 Lstar_v_v[i]=ck.Advection_adjoint(dmom_adv_star,&vel_grad_test_dV[i_nSpace]);
2660 Lstar_w_w[i]=ck.Advection_adjoint(dmom_adv_star,&vel_grad_test_dV[i_nSpace]);
2661 Lstar_p_u[i]=ck.Hamiltonian_adjoint(dmom_u_ham_grad_p,&vel_grad_test_dV[i_nSpace]);
2662 Lstar_p_v[i]=ck.Hamiltonian_adjoint(dmom_v_ham_grad_p,&vel_grad_test_dV[i_nSpace]);
2663 Lstar_p_w[i]=ck.Hamiltonian_adjoint(dmom_w_ham_grad_p,&vel_grad_test_dV[i_nSpace]);
2664
2665 //VRANS account for drag terms, diagonal only here ... decide if need off diagonal terms too
2666 Lstar_u_u[i]+=ck.Reaction_adjoint(dmom_u_source[0],vel_test_dV[i]);
2667 Lstar_v_v[i]+=ck.Reaction_adjoint(dmom_v_source[1],vel_test_dV[i]);
2668 Lstar_w_w[i]+=ck.Reaction_adjoint(dmom_w_source[2],vel_test_dV[i]);
2669 //
2670 }
2671
2672 if (ARTIFICIAL_VISCOSITY==0 || ARTIFICIAL_VISCOSITY==3 || ARTIFICIAL_VISCOSITY==4)
2673 {
2674 q_numDiff_u[eN_k] = 0;
2675 q_numDiff_v[eN_k] = 0;
2676 q_numDiff_w[eN_k] = 0;
2677 }
2678 else if (ARTIFICIAL_VISCOSITY==1) // SHOCK CAPTURING
2679 {
2680 norm_Rv = sqrt(pdeResidual_u*pdeResidual_u + pdeResidual_v*pdeResidual_v + pdeResidual_w*pdeResidual_w);
2681 q_numDiff_u[eN_k] = C_dc*norm_Rv*(useMetrics/sqrt(G_dd_G+1.0e-12) +
2682 (1.0-useMetrics)*hFactor*hFactor*elementDiameter[eN]*elementDiameter[eN]);
2683 q_numDiff_v[eN_k] = q_numDiff_u[eN_k];
2684 q_numDiff_w[eN_k] = q_numDiff_u[eN_k];
2685 }
2686 else // ARTIFICIAL_VISCOSITY==2; i.e, ENTROPY VISCOSITY
2687 {
2688 double rho = q_rho[eN_k];
2689 double mu = q_rho[eN_k]*q_nu[eN_k];
2690
2691 double vel2 = u*u + v*v + w*w;
2692
2693 // entropy residual
2694 double Res_in_x =
2695 porosity*rho*((u-un)/dt + (u*grad_u[0]+v*grad_u[1]+w*grad_u[2]) - g[0])
2696 + (KILL_PRESSURE_TERM == 1 ? 0 : 1.)*grad_p[0]
2697 - (MULTIPLY_EXTERNAL_FORCE_BY_DENSITY == 1 ? porosity*rho : 1.0)*forcex[eN_k]
2698 - mu*(hess_u[0] + hess_u[4] + hess_u[8]) // u_xx + u_yy + u_zz
2699 - mu*(hess_u[0] + hess_v[1] + hess_w[2]); // u_xx + v_xy + w_xz
2700 double Res_in_y =
2701 porosity*rho*((v-vn)/dt + (u*grad_v[0]+v*grad_v[1]+w*grad_v[2]) - g[1])
2702 + (KILL_PRESSURE_TERM == 1 ? 0 : 1.)*grad_p[1]
2703 - (MULTIPLY_EXTERNAL_FORCE_BY_DENSITY == 1 ? porosity*rho : 1.0)*forcey[eN_k]
2704 - mu*(hess_v[0] + hess_v[4] + hess_v[8]) // v_xx + v_yy + v_zz
2705 - mu*(hess_u[1] + hess_v[4] + hess_w[5]); // u_xy + v_yy + w_yz
2706 double Res_in_z =
2707 porosity*rho*((w-wn)/dt + (u*grad_w[0]+v*grad_w[1]+w*grad_w[2]) - g[2])
2708 + (KILL_PRESSURE_TERM == 1 ? 0 : 1.)*grad_p[2]
2709 - (MULTIPLY_EXTERNAL_FORCE_BY_DENSITY == 1 ? porosity*rho : 1.0)*forcez[eN_k]
2710 - mu*(hess_w[0] + hess_w[4] + hess_w[8]) // w_xx + w_yy + w_zz
2711 - mu*(hess_u[2] + hess_v[5] + hess_w[8]); // u_xz + v_yz + w_zz
2712
2713 // compute entropy residual
2714 double entRes_times_u = Res_in_x*u + Res_in_y*v + Res_in_z*w;
2715
2716 double hK = elementDiameter[eN]/order_polynomial;
2717 q_numDiff_u[eN_k] = fmin(cMax*porosity*rho*hK*std::sqrt(vel2),
2718 cE*hK*hK*fabs(entRes_times_u)/(vel2+1E-10));
2719 q_numDiff_v[eN_k] = q_numDiff_u[eN_k];
2720 q_numDiff_w[eN_k] = q_numDiff_u[eN_k];
2721
2722 if (CELL_BASED_EV_COEFF)
2723 {
2724 linVisc_eN = fmax(porosity*rho*std::sqrt(vel2),linVisc_eN);
2725 nlinVisc_eN_num = fmax(fabs(entRes_times_u),nlinVisc_eN_num);
2726 nlinVisc_eN_den = fmax(vel2,nlinVisc_eN_den);
2727 }
2728 }
2729
2730 //
2731 //update element residual
2732 //
2733 double mesh_vel[3];
2734 mesh_vel[0] = xt;
2735 mesh_vel[1] = yt;
2736 mesh_vel[2] = zt;
2737 q_velocity[eN_k_nSpace+0]=u;
2738 q_velocity[eN_k_nSpace+1]=v;
2739 q_velocity[eN_k_nSpace+2]=w;
2740 for (int I=0;I<nSpace;I++)
2741 {
2742 q_grad_u[eN_k_nSpace+I] = grad_u[I];
2743 q_grad_v[eN_k_nSpace+I] = grad_v[I];
2744 q_grad_w[eN_k_nSpace+I] = grad_w[I];
2745 }
2746 // save divergence of velocity
2747 q_divU[eN_k] = q_grad_u[eN_k_nSpace+0] + q_grad_v[eN_k_nSpace+1] + q_grad_w[eN_k_nSpace+2];
2748
2749 // SURFACE TENSION //
2750 double unit_normal[nSpace];
2751 double norm_grad_phi = 0.;
2752 for (int I=0;I<nSpace;I++)
2753 norm_grad_phi += normal_phi[eN_k_nSpace+I]*normal_phi[eN_k_nSpace+I];
2754 norm_grad_phi = std::sqrt(norm_grad_phi) + 1E-10;
2755 for (int I=0;I<nSpace;I++)
2756 unit_normal[I] = normal_phi[eN_k_nSpace+I]/norm_grad_phi;
2757 // compute auxiliary vectors for explicit term of 2D surf tension
2758 // v1 = [1-nx^2 -nx*ny -nx*ny]^T
2759 double v1[nSpace];
2760 v1[0]=1.-unit_normal[0]*unit_normal[0];
2761 v1[1]=-unit_normal[0]*unit_normal[1];
2762 v1[2]=-unit_normal[0]*unit_normal[2];
2763 // v2 = [-nx*ny 1-ny^2 -ny*nz]^T
2764 double v2[nSpace];
2765 v2[0]=-unit_normal[0]*unit_normal[1];
2766 v2[1]=1.-unit_normal[1]*unit_normal[1];
2767 v2[2]=-unit_normal[1]*unit_normal[2];
2768 // v3 = [-nx*nz -ny*nz 1-nz^2]^T
2769 double v3[nSpace];
2770 v3[0]=-unit_normal[0]*unit_normal[2];
2771 v3[1]=-unit_normal[1]*unit_normal[2];
2772 v3[2]=1.-unit_normal[2]*unit_normal[2];
2773 double delta = gf.D(eps_mu,phi[eN_k]); //use eps_rho instead?
2774 double vel_tgrad_test_i[nSpace],
2775 tgrad_u[nSpace], tgrad_v[nSpace], tgrad_w[nSpace];
2776 calculateTangentialGradient(unit_normal,
2777 grad_u,
2778 tgrad_u);
2779 calculateTangentialGradient(unit_normal,
2780 grad_v,
2781 tgrad_v);
2782 calculateTangentialGradient(unit_normal,
2783 grad_w,
2784 tgrad_w);
2785 // END OF SURFACE TENSION //
2786
2787 if (ARTIFICIAL_VISCOSITY==3 || ARTIFICIAL_VISCOSITY==4)
2788 {
2789 velStar[0] = q_velocity_sge[eN_k_nSpace+0];
2790 velStar[1] = q_velocity_sge[eN_k_nSpace+1];
2791 velStar[2] = q_velocity_sge[eN_k_nSpace+2];
2792 }
2793 for(int i=0;i<nDOF_test_element;i++)
2794 {
2795 int i_nSpace=i*nSpace;
2796 calculateTangentialGradient(unit_normal,
2797 &vel_grad_trial[i_nSpace],
2798 vel_tgrad_test_i);
2799 phisErrorElement[i]+=std::abs(phisError[eN_k_nSpace+0])*p_test_dV[i];
2800 /* std::cout<<"elemRes_mesh "<<mesh_vel[0]<<'\t'<<mesh_vel[2]<<'\t'<<p_test_dV[i]<<'\t'<<(q_dV_last[eN_k]/dV)<<'\t'<<dV<<std::endl; */
2801 /* elementResidual_mesh[i] += ck.Reaction_weak(1.0,p_test_dV[i]) - */
2802 /* ck.Reaction_weak(1.0,p_test_dV[i]*q_dV_last[eN_k]/dV) - */
2803 /* ck.Advection_weak(mesh_vel,&p_grad_test_dV[i_nSpace]); */
2804
2805 /* elementResidual_p[i] += ck.Mass_weak(-q_dvos_dt[eN_k],p_test_dV[i]) + */
2806 /* ck.Advection_weak(mass_adv,&p_grad_test_dV[i_nSpace]) + */
2807 /* DM*MOVING_DOMAIN*(ck.Reaction_weak(alphaBDF*1.0,p_test_dV[i]) - */
2808 /* ck.Reaction_weak(alphaBDF*1.0,p_test_dV[i]*q_dV_last[eN_k]/dV) - */
2809 /* ck.Advection_weak(mesh_vel,&p_grad_test_dV[i_nSpace])) + */
2810 /* //VRANS */
2811 /* ck.Reaction_weak(mass_source,p_test_dV[i]) + //VRANS source term for wave maker */
2812 /* // */
2813 /* ck.SubgridError(subgridError_u,Lstar_u_p[i]) + */
2814 /* ck.SubgridError(subgridError_v,Lstar_v_p[i]);// + */
2815 /* /\* ck.SubgridError(subgridError_w,Lstar_w_p[i]); *\/ */
2816
2817 elementResidual_u[i] += // mql. CHECK.
2818 ck.Mass_weak(mom_u_acc_t,vel_test_dV[i]) +
2819 ck.Advection_weak(mom_u_adv,&vel_grad_test_dV[i_nSpace]) +
2820 ck.Diffusion_weak(sdInfo_u_u_rowptr.data(),sdInfo_u_u_colind.data(),mom_uu_diff_ten,grad_u,&vel_grad_test_dV[i_nSpace]) +
2821 ck.Diffusion_weak(sdInfo_u_v_rowptr.data(),sdInfo_u_v_colind.data(),mom_uv_diff_ten,grad_v,&vel_grad_test_dV[i_nSpace]) +
2822 ck.Diffusion_weak(sdInfo_u_w_rowptr.data(),sdInfo_u_w_colind.data(),mom_uw_diff_ten,grad_w,&vel_grad_test_dV[i_nSpace]) +
2823 ck.Reaction_weak(mom_u_source,vel_test_dV[i]) +
2824 ck.Hamiltonian_weak(mom_u_ham,vel_test_dV[i]) +
2825 (INT_BY_PARTS_PRESSURE==1 ? -1.0*p*vel_grad_test_dV[i_nSpace+0] : 0.) +
2826 //ck.SubgridError(subgridError_p,Lstar_p_u[i]) +
2827 USE_SUPG*ck.SubgridError(subgridError_u,Lstar_u_u[i]) +
2828 ck.NumericalDiffusion(q_numDiff_u_last[eN_k],grad_u,&vel_grad_test_dV[i_nSpace]) +
2829 //surface tension
2830 ck.NumericalDiffusion(delta*sigma*dV,v1,vel_tgrad_test_i) + //exp.
2831 ck.NumericalDiffusion(dt*delta*sigma*dV,tgrad_u,vel_tgrad_test_i); //imp.
2832 mom_u_source_i[i] += ck.Reaction_weak(mom_u_source,vel_test_dV[i]);
2833 betaDrag_i[i] += ck.Reaction_weak(dmom_u_source[0],
2834 vel_test_dV[i]);
2835 vos_i[i] += ck.Reaction_weak(1.0-porosity,
2836 vel_test_dV[i]);
2837
2838 elementResidual_v[i] +=
2839 ck.Mass_weak(mom_v_acc_t,vel_test_dV[i]) +
2840 ck.Advection_weak(mom_v_adv,&vel_grad_test_dV[i_nSpace]) +
2841 ck.Diffusion_weak(sdInfo_v_u_rowptr.data(),sdInfo_v_u_colind.data(),mom_vu_diff_ten,grad_u,&vel_grad_test_dV[i_nSpace]) +
2842 ck.Diffusion_weak(sdInfo_v_v_rowptr.data(),sdInfo_v_v_colind.data(),mom_vv_diff_ten,grad_v,&vel_grad_test_dV[i_nSpace]) +
2843 ck.Diffusion_weak(sdInfo_v_w_rowptr.data(),sdInfo_v_w_colind.data(),mom_vw_diff_ten,grad_w,&vel_grad_test_dV[i_nSpace]) +
2844 ck.Reaction_weak(mom_v_source,vel_test_dV[i]) +
2845 ck.Hamiltonian_weak(mom_v_ham,vel_test_dV[i]) +
2846 (INT_BY_PARTS_PRESSURE==1 ? -1.0*p*vel_grad_test_dV[i_nSpace+1] : 0.) +
2847 //ck.SubgridError(subgridError_p,Lstar_p_v[i]) +
2848 USE_SUPG*ck.SubgridError(subgridError_v,Lstar_v_v[i]) +
2849 ck.NumericalDiffusion(q_numDiff_v_last[eN_k],grad_v,&vel_grad_test_dV[i_nSpace]) +
2850 //surface tension
2851 ck.NumericalDiffusion(delta*sigma*dV,v2,vel_tgrad_test_i) + //exp.
2852 ck.NumericalDiffusion(dt*delta*sigma*dV,tgrad_v,vel_tgrad_test_i); //imp.
2853 mom_v_source_i[i] += ck.Reaction_weak(mom_v_source,vel_test_dV[i]);
2854
2855 elementResidual_w[i] +=
2856 ck.Mass_weak(mom_w_acc_t,vel_test_dV[i]) +
2857 ck.Advection_weak(mom_w_adv,&vel_grad_test_dV[i_nSpace]) +
2858 ck.Diffusion_weak(sdInfo_w_u_rowptr.data(),sdInfo_w_u_colind.data(),mom_wu_diff_ten,grad_u,&vel_grad_test_dV[i_nSpace]) +
2859 ck.Diffusion_weak(sdInfo_w_v_rowptr.data(),sdInfo_w_v_colind.data(),mom_wv_diff_ten,grad_v,&vel_grad_test_dV[i_nSpace]) +
2860 ck.Diffusion_weak(sdInfo_w_w_rowptr.data(),sdInfo_w_w_colind.data(),mom_ww_diff_ten,grad_w,&vel_grad_test_dV[i_nSpace]) +
2861 ck.Reaction_weak(mom_w_source,vel_test_dV[i]) +
2862 ck.Hamiltonian_weak(mom_w_ham,vel_test_dV[i]) +
2863 (INT_BY_PARTS_PRESSURE==1 ? -1.0*p*vel_grad_test_dV[i_nSpace+2] : 0.) +
2864 //ck.SubgridError(subgridError_p,Lstar_p_w[i]) +
2865 USE_SUPG*ck.SubgridError(subgridError_w,Lstar_w_w[i]) +
2866 ck.NumericalDiffusion(q_numDiff_w_last[eN_k],grad_w,&vel_grad_test_dV[i_nSpace]) +
2867 //surface tension
2868 ck.NumericalDiffusion(delta*sigma*dV,v3,vel_tgrad_test_i) + //exp.
2869 ck.NumericalDiffusion(dt*delta*sigma*dV,tgrad_w,vel_tgrad_test_i); //imp.
2870 mom_w_source_i[i] += ck.Reaction_weak(mom_w_source,vel_test_dV[i]);
2871
2872 if (ARTIFICIAL_VISCOSITY==4)
2873 {
2874 // ***** COMPUTE ENTROPY RESIDUAL ***** //
2875 // mql. NOTE that the test functions are weighted by the velocity
2876 elementEntropyResidual[i] +=
2877 // x-component
2878 ck.Mass_weak(mom_u_acc_t,u*vel_test_dV[i]) + // time derivative
2879 ck.Advection_weak(mom_u_adv,&u_times_vel_grad_test_dV[i_nSpace])+//m.mesh
2880 ck.Diffusion_weak(sdInfo_u_u_rowptr.data(),
2881 sdInfo_u_u_colind.data(),
2882 mom_uu_diff_ten,
2883 grad_u,
2884 &u_times_vel_grad_test_dV[i_nSpace]) +
2885 ck.Diffusion_weak(sdInfo_u_v_rowptr.data(),
2886 sdInfo_u_v_colind.data(),
2887 mom_uv_diff_ten,
2888 grad_v,
2889 &u_times_vel_grad_test_dV[i_nSpace]) +
2890 ck.Diffusion_weak(sdInfo_u_w_rowptr.data(),
2891 sdInfo_u_w_colind.data(),
2892 mom_uw_diff_ten,
2893 grad_w,
2894 &u_times_vel_grad_test_dV[i_nSpace]) +
2895 ck.Reaction_weak(mom_u_source,u*vel_test_dV[i]) + // Force term
2896 ck.Hamiltonian_weak(mom_u_ham,u*vel_test_dV[i]) // Pres + Non-linearity
2897 + // y-component
2898 ck.Mass_weak(mom_v_acc_t,v*vel_test_dV[i]) + // time derivative
2899 ck.Advection_weak(mom_v_adv,&v_times_vel_grad_test_dV[i_nSpace])+//m.mesh
2900 ck.Diffusion_weak(sdInfo_v_u_rowptr.data(),
2901 sdInfo_v_u_colind.data(),
2902 mom_vu_diff_ten,
2903 grad_u,
2904 &v_times_vel_grad_test_dV[i_nSpace])+
2905 ck.Diffusion_weak(sdInfo_v_v_rowptr.data(),
2906 sdInfo_v_v_colind.data(),
2907 mom_vv_diff_ten,
2908 grad_v,
2909 &v_times_vel_grad_test_dV[i_nSpace])+
2910 ck.Diffusion_weak(sdInfo_v_w_rowptr.data(),
2911 sdInfo_v_w_colind.data(),
2912 mom_vw_diff_ten,
2913 grad_w,
2914 &v_times_vel_grad_test_dV[i_nSpace]) +
2915 ck.Reaction_weak(mom_v_source,v*vel_test_dV[i]) + // force term
2916 ck.Hamiltonian_weak(mom_v_ham,v*vel_test_dV[i]) // Pres + Non-linearity
2917 + // z-component
2918 ck.Mass_weak(mom_w_acc_t,w*vel_test_dV[i]) + // time derivative
2919 ck.Advection_weak(mom_w_adv,&w_times_vel_grad_test_dV[i_nSpace])+//m.mesh
2920 ck.Diffusion_weak(sdInfo_w_u_rowptr.data(),
2921 sdInfo_w_u_colind.data(),
2922 mom_wu_diff_ten,
2923 grad_u,
2924 &w_times_vel_grad_test_dV[i_nSpace]) +
2925 ck.Diffusion_weak(sdInfo_w_v_rowptr.data(),
2926 sdInfo_w_v_colind.data(),
2927 mom_wv_diff_ten,
2928 grad_v,
2929 &w_times_vel_grad_test_dV[i_nSpace]) +
2930 ck.Diffusion_weak(sdInfo_w_w_rowptr.data(),
2931 sdInfo_w_w_colind.data(),
2932 mom_ww_diff_ten,
2933 grad_w,
2934 &w_times_vel_grad_test_dV[i_nSpace]) +
2935 ck.Reaction_weak(mom_w_source,w*vel_test_dV[i]) + // force term
2936 ck.Hamiltonian_weak(mom_w_ham,w*vel_test_dV[i]); // Pres + Non-linearity
2937 }
2938 if (ARTIFICIAL_VISCOSITY==3 || ARTIFICIAL_VISCOSITY==4)
2939 {
2940 for(int j=0;j<nDOF_trial_element;j++)
2941 {
2942 int j_nSpace = j*nSpace;
2943 int i_nSpace = i*nSpace;
2944 elementTransport[i][j] += // int[rho*(velStar.grad_wj)*wi*dx]
2945 q_rho[eN_k]*porosity*
2946 ck.AdvectionJacobian_strong(velStar,
2947 &vel_grad_test_dV[j_nSpace])
2948 *vel_trial_ref[k*nDOF_trial_element+i];
2949 elementTransposeTransport[i][j] += // int[rho*(velStar.grad_wi)*wj*dx]
2950 q_rho[eN_k]*porosity*
2951 ck.AdvectionJacobian_strong(velStar,
2952 &vel_grad_test_dV[i_nSpace])
2953 *vel_trial_ref[k*nDOF_trial_element+j];
2954 }
2955 }//j
2956 }//i
2957 }
2958 element_uStar_He[eN] = det_hess_uStar_Ke/area_Ke;
2959 element_vStar_He[eN] = det_hess_vStar_Ke/area_Ke;
2960 element_wStar_He[eN] = det_hess_wStar_Ke/area_Ke;
2961
2962 // End computation of cell based EV coeff //
2963 if (CELL_BASED_EV_COEFF && ARTIFICIAL_VISCOSITY==2)
2964 {
2965 double hK = elementDiameter[eN];
2966 double artVisc = fmin(cMax*hK*linVisc_eN,
2967 cE*hK*hK*nlinVisc_eN_num/(nlinVisc_eN_den+1E-10));
2968 for(int k=0;k<nQuadraturePoints_element;k++)
2969 {
2970 int eN_k = eN*nQuadraturePoints_element+k;
2971 q_numDiff_u[eN_k] = artVisc;
2972 q_numDiff_v[eN_k] = artVisc;
2973 q_numDiff_w[eN_k] = artVisc;
2974 }
2975 }
2976 //
2977 //load element into global residual and save element residual
2978 //
2979 for(int i=0;i<nDOF_test_element;i++)
2980 {
2981 int eN_i=eN*nDOF_test_element+i;
2982 phisErrorNodal[vel_l2g[eN_i]]+= element_active*phisErrorElement[i];
2983 /* elementResidual_p_save[eN_i] += elementResidual_p[i]; */
2984 /* mesh_volume_conservation_element_weak += elementResidual_mesh[i]; */
2985 /* globalResidual[offset_p+stride_p*p_l2g[eN_i]]+=elementResidual_p[i]; */
2986 globalResidual[offset_u+stride_u*vel_l2g[eN_i]]+=element_active*elementResidual_u[i];
2987 globalResidual[offset_v+stride_v*vel_l2g[eN_i]]+=element_active*elementResidual_v[i];
2988 globalResidual[offset_w+stride_w*vel_l2g[eN_i]]+=element_active*elementResidual_w[i];
2989 ncDrag[offset_u+stride_u*vel_l2g[eN_i]]+=mom_u_source_i[i];
2990 ncDrag[offset_v+stride_v*vel_l2g[eN_i]]+=mom_v_source_i[i];
2991 ncDrag[offset_w+stride_w*vel_l2g[eN_i]]+=mom_w_source_i[i];
2992 betaDrag[vel_l2g[eN_i]] += betaDrag_i[i];
2993 vos_vel_nodes[vel_l2g[eN_i]] += vos_i[i];
2994
2995 // compute numerator and denominator of uStar_hi and vStar_hi
2996 if (ARTIFICIAL_VISCOSITY==3)
2997 {
2998 uStar_hi[vel_l2g[eN_i]] += element_uStar_He[eN]; // offset=0, stride=1 since this is per component of the equation
2999 vStar_hi[vel_l2g[eN_i]] += element_vStar_He[eN];
3000 wStar_hi[vel_l2g[eN_i]] += element_wStar_He[eN];
3001 den_hi[vel_l2g[eN_i]] += 1;
3002 }
3003 if (ARTIFICIAL_VISCOSITY==4)
3004 {
3005 // DISTRIBUTE ENTROPY RESIDUAL //
3006 entropyResidualPerNode[vel_l2g[eN_i]] += elementEntropyResidual[i];
3007 }
3008 if (ARTIFICIAL_VISCOSITY==3 || ARTIFICIAL_VISCOSITY==4)
3009 {
3010 for (int j=0;j<nDOF_trial_element;j++)
3011 {
3012 int eN_i_j = eN_i*nDOF_trial_element+j;
3013 TransportMatrix[csrRowIndeces_1D[eN_i]
3014 + csrColumnOffsets_1D[eN_i_j]]
3015 += elementTransport[i][j];
3016 // transpose
3017 TransposeTransportMatrix[csrRowIndeces_1D[eN_i]
3018 + csrColumnOffsets_1D[eN_i_j]]
3019 += elementTransposeTransport[i][j];
3020 }//j
3021 }
3022 }//i
3023 /* mesh_volume_conservation += mesh_volume_conservation_element; */
3024 /* mesh_volume_conservation_weak += mesh_volume_conservation_element_weak; */
3025 /* mesh_volume_conservation_err_max=fmax(mesh_volume_conservation_err_max,fabs(mesh_volume_conservation_element)); */
3026 /* mesh_volume_conservation_err_max_weak=fmax(mesh_volume_conservation_err_max_weak,fabs(mesh_volume_conservation_element_weak)); */
3027 }//elements
3028
3029 // loop in DOFs for discrete upwinding
3030 if (ARTIFICIAL_VISCOSITY==3 || ARTIFICIAL_VISCOSITY==4)
3031 {
3032 // FIRST LOOP ON DOFs //
3033 for (int i=0; i<numDOFs_1D; i++)
3034 {
3035 if (ARTIFICIAL_VISCOSITY==4) // via entropy viscosity
3036 {
3037 // normalize entropy residual per node
3038 double max_u2i = (std::pow(u_dof[i],2.) +
3039 std::pow(v_dof[i],2.) +
3040 std::pow(w_dof[i],2.));
3041 double min_u2i = max_u2i;
3042 for (int offset=rowptr_1D[i]; offset<rowptr_1D[i+1]; offset++)
3043 {
3044 int j = colind_1D[offset];
3045 double u2j = (std::pow(u_dof[j],2.) +
3046 std::pow(v_dof[j],2.) +
3047 std::pow(w_dof[j],2.));
3048 max_u2i = fmax(max_u2i,u2j);
3049 min_u2i = fmin(min_u2i,u2j);
3050 }
3051 double normi = 0.5*(max_u2i + min_u2i) + 1E-10;
3052 entropyResidualPerNode[i] = fabs(entropyResidualPerNode[i])/normi;
3053 }
3054 else // via smoothness indicator
3055 {
3056 // computation of beta
3057 double uStari = uStar_dof[i];
3058 double vStari = vStar_dof[i];
3059 double wStari = wStar_dof[i];
3060
3061 double u_beta_numerator = 0., u_beta_denominator = 0.;
3062 double v_beta_numerator = 0., v_beta_denominator = 0.;
3063 double w_beta_numerator = 0., w_beta_denominator = 0.;
3064
3065 // loop on sparsity pattern
3066 for (int offset=rowptr_1D[i]; offset<rowptr_1D[i+1]; offset++)
3067 {
3068 int j = colind_1D[offset];
3069 double uStarj = uStar_dof[j];
3070 double vStarj = vStar_dof[j];
3071 double wStarj = wStar_dof[j];
3072
3073 // for u component
3074 u_beta_numerator += (uStarj - uStari);
3075 u_beta_denominator += fabs(uStarj - uStari);
3076 // for v component
3077 v_beta_numerator += (vStarj - vStari);
3078 v_beta_denominator += fabs(vStarj - vStari);
3079 // for w component
3080 w_beta_numerator += (wStarj - wStari);
3081 w_beta_denominator += fabs(wStarj - wStari);
3082 }
3083 double u_beta = fabs(u_beta_numerator)/(u_beta_denominator+1E-10);
3084 double v_beta = fabs(v_beta_numerator)/(v_beta_denominator+1E-10);
3085 double w_beta = fabs(w_beta_numerator)/(w_beta_denominator+1E-10);
3086 // compute psi=beta^power
3087 if (ANISOTROPIC_DIFFUSION==1)
3088 {
3089 uStar_psi[i] = (POWER_SMOOTHNESS_INDICATOR==0 ? 1.0 : std::pow(u_beta, POWER_SMOOTHNESS_INDICATOR));
3090 vStar_psi[i] = (POWER_SMOOTHNESS_INDICATOR==0 ? 1.0 : std::pow(v_beta, POWER_SMOOTHNESS_INDICATOR));
3091 wStar_psi[i] = (POWER_SMOOTHNESS_INDICATOR==0 ? 1.0 : std::pow(w_beta, POWER_SMOOTHNESS_INDICATOR));
3092 }
3093 else // ISOTROPIC ARTIFICIAL DIFFUSION
3094 {
3095 double psi = (POWER_SMOOTHNESS_INDICATOR==0 ? 1.0 : std::pow(fmax(fmax(u_beta,v_beta),w_beta), POWER_SMOOTHNESS_INDICATOR));
3096 uStar_psi[i] = psi;
3097 vStar_psi[i] = psi;
3098 wStar_psi[i] = psi;
3099 }
3100 // for computation of gamma
3101 uStar_hi[i] /= den_hi[i];
3102 vStar_hi[i] /= den_hi[i];
3103 wStar_hi[i] /= den_hi[i];
3104 }
3105 }
3106
3107 if (ARTIFICIAL_VISCOSITY==3)
3108 {
3109 for(int eN=0;eN<nElements_global;eN++)
3110 {
3111 double uStar_He = element_uStar_He[eN];
3112 double vStar_He = element_vStar_He[eN];
3113 double wStar_He = element_wStar_He[eN];
3114 for(int i=0;i<nDOF_test_element;i++)
3115 {
3116 int eN_i=eN*nDOF_test_element+i;
3117 int gi = vel_l2g[eN_i]; // offset=0, stride=1
3118 uStar_min_hiHe[gi] = fmin(uStar_min_hiHe[gi], uStar_hi[gi]*uStar_He);
3119 vStar_min_hiHe[gi] = fmin(vStar_min_hiHe[gi], vStar_hi[gi]*vStar_He);
3120 wStar_min_hiHe[gi] = fmin(wStar_min_hiHe[gi], wStar_hi[gi]*wStar_He);
3121 }
3122 }
3123 }
3124
3125 // EXTRA LOOP ON DOFs to COMPUTE GAMMA INDICATOR//
3126 if (ARTIFICIAL_VISCOSITY==3)
3127 {
3128 for (int i=0; i<numDOFs_1D; i++)
3129 {
3130 // for gamma indicator
3131 double uStar_hi2 = uStar_hi[i]*uStar_hi[i];
3132 double vStar_hi2 = vStar_hi[i]*vStar_hi[i];
3133 double wStar_hi2 = wStar_hi[i]*wStar_hi[i];
3134 if (isBoundary_1D[i] == 1)
3135 {
3136 uStar_gamma[i] = 1; // set gamma=1 since at boundary we don't have enough information
3137 vStar_gamma[i] = 1;
3138 wStar_gamma[i] = 1;
3139 }
3140 else
3141 {
3142 if (ANISOTROPIC_DIFFUSION==1)
3143 {
3144 uStar_gamma[i] = 1.-fmax(0, fmin(uStar_hi2, C_FOR_GAMMA_INDICATOR*uStar_min_hiHe[i]))/(uStar_hi2+EPS_FOR_GAMMA_INDICATOR);
3145 vStar_gamma[i] = 1.-fmax(0, fmin(vStar_hi2, C_FOR_GAMMA_INDICATOR*vStar_min_hiHe[i]))/(vStar_hi2+EPS_FOR_GAMMA_INDICATOR);
3146 wStar_gamma[i] = 1.-fmax(0, fmin(wStar_hi2, C_FOR_GAMMA_INDICATOR*wStar_min_hiHe[i]))/(wStar_hi2+EPS_FOR_GAMMA_INDICATOR);
3147 }
3148 else // ISOTROPIC ARTIFICIAL DIFFUSION
3149 {
3150 double gamma=fmax(fmax(1.-fmax(0,fmin(uStar_hi2,C_FOR_GAMMA_INDICATOR*uStar_min_hiHe[i]))/(uStar_hi2+EPS_FOR_GAMMA_INDICATOR),
3151 1.-fmax(0,fmin(vStar_hi2,C_FOR_GAMMA_INDICATOR*vStar_min_hiHe[i]))/(vStar_hi2+EPS_FOR_GAMMA_INDICATOR)),
3152 1.-fmax(0, fmin(wStar_hi2, C_FOR_GAMMA_INDICATOR*wStar_min_hiHe[i]))/(wStar_hi2+EPS_FOR_GAMMA_INDICATOR));
3153 uStar_gamma[i] = gamma;
3154 vStar_gamma[i] = gamma;
3155 wStar_gamma[i] = gamma;
3156 }
3157 }
3158 }
3159 }
3160 // SECOND LOOP ON DOFs //
3161 int ij=0;
3162 for (int i=0; i<numDOFs_1D; i++)
3163 {
3164 int ii;
3165 double uStar_dii = 0;
3166 double vStar_dii = 0;
3167 double wStar_dii = 0;
3168 double ui = u_dof[i];
3169 double vi = v_dof[i];
3170 double wi = w_dof[i];
3171
3172 double ith_u_dissipative_term = 0;
3173 double ith_v_dissipative_term = 0;
3174 double ith_w_dissipative_term = 0;
3175
3176 double uStar_alphai = USE_GAMMA_INDICATOR==1 ? fmin(uStar_psi[i], uStar_gamma[i]) : uStar_psi[i];
3177 double vStar_alphai = USE_GAMMA_INDICATOR==1 ? fmin(vStar_psi[i], vStar_gamma[i]) : vStar_psi[i];
3178 double wStar_alphai = USE_GAMMA_INDICATOR==1 ? fmin(wStar_psi[i], wStar_gamma[i]) : wStar_psi[i];
3179
3180 for (int offset=rowptr_1D[i]; offset<rowptr_1D[i+1]; offset++)
3181 {
3182 int j = colind_1D[offset];
3183 if (i!=j)
3184 {
3185 double uj = u_dof[j];
3186 double vj = v_dof[j];
3187 double wj = w_dof[j];
3188
3189 double uStar_alphaj = USE_GAMMA_INDICATOR==1 ? fmin(uStar_psi[j], uStar_gamma[j]) : uStar_psi[j];
3190 double vStar_alphaj = USE_GAMMA_INDICATOR==1 ? fmin(vStar_psi[j], vStar_gamma[j]) : vStar_psi[j];
3191 double wStar_alphaj = USE_GAMMA_INDICATOR==1 ? fmin(wStar_psi[j], wStar_gamma[j]) : wStar_psi[j];
3192
3193 if (ARTIFICIAL_VISCOSITY==4) // via entropy viscosity
3194 {
3195 double dEVij = fmax(laggedEntropyResidualPerNode[i],
3196 laggedEntropyResidualPerNode[j]);
3197 double dLij = fmax(0.,fmax(TransportMatrix[ij],
3198 TransposeTransportMatrix[ij]));
3199 uStar_dMatrix[ij] = fmin(dLij,cE*dEVij);
3200 vStar_dMatrix[i] = uStar_dMatrix[ij];
3201 wStar_dMatrix[i] = uStar_dMatrix[ij];
3202 }
3203 else // via smoothness indicator
3204 {
3205 uStar_dMatrix[ij] = fmax(0.,fmax(uStar_alphai*TransportMatrix[ij], // by S. Badia
3206 uStar_alphaj*TransposeTransportMatrix[ij]));
3207 vStar_dMatrix[ij] = fmax(0.,fmax(vStar_alphai*TransportMatrix[ij], // by S. Badia
3208 vStar_alphaj*TransposeTransportMatrix[ij]));
3209 wStar_dMatrix[ij] = fmax(0.,fmax(wStar_alphai*TransportMatrix[ij], // by S. Badia
3210 wStar_alphaj*TransposeTransportMatrix[ij]));
3211 }
3212 uStar_dii -= uStar_dMatrix[ij];
3213 vStar_dii -= vStar_dMatrix[ij];
3214 wStar_dii -= wStar_dMatrix[ij];
3215 //dissipative terms
3216 ith_u_dissipative_term += uStar_dMatrix[ij]*(uj-ui);
3217 ith_v_dissipative_term += vStar_dMatrix[ij]*(vj-vi);
3218 ith_w_dissipative_term += wStar_dMatrix[ij]*(wj-wi);
3219 }
3220 else
3221 {
3222 ii = ij;
3223 }
3224 // update ij
3225 ij++;
3226 }
3227 uStar_dMatrix[ii] = uStar_dii;
3228 vStar_dMatrix[ii] = vStar_dii;
3229 wStar_dMatrix[ii] = wStar_dii;
3230 globalResidual[offset_u+stride_u*i] += -ith_u_dissipative_term;
3231 globalResidual[offset_v+stride_v*i] += -ith_v_dissipative_term;
3232 globalResidual[offset_w+stride_w*i] += -ith_w_dissipative_term;
3233 }
3234 }
3235
3236 //
3237 //loop over the surrogate boundaries in SB method and assembly into residual
3238 //
3239 if(USE_SBM>0)
3240 {
3241 std::memset(particle_netForces.data(),0,nParticles*3*sizeof(double));
3242 std::memset(particle_netMoments.data(),0,nParticles*3*sizeof(double));
3243 for (int ebN_s=0;ebN_s < surrogate_boundaries.size();ebN_s++)
3244 {
3245 int ebN = surrogate_boundaries[ebN_s],
3246 eN = elementBoundaryElementsArray[ebN*2+surrogate_boundary_elements[ebN_s]],
3247 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+surrogate_boundary_elements[ebN_s]],
3248 eN_nDOF_trial_element = eN*nDOF_trial_element;
3249 double elementResidual_mesh[nDOF_test_element],
3250 elementResidual_p[nDOF_test_element],
3251 elementResidual_u[nDOF_test_element],
3252 elementResidual_v[nDOF_test_element],
3253 elementResidual_w[nDOF_test_element],
3254 eps_rho,eps_mu;
3255 //This assumption is wrong for parallel: If one of nodes of this edge is owned by this processor,
3256 //then the integral over this edge has contribution to the residual and Jacobian.
3257 //if (ebN >= nElementBoundaries_owned) continue;
3258 for (int i=0;i<nDOF_test_element;i++)
3259 {
3260 elementResidual_mesh[i]=0.0;
3261 elementResidual_p[i]=0.0;
3262 elementResidual_u[i]=0.0;
3263 elementResidual_v[i]=0.0;
3264 elementResidual_w[i]=0.0;
3265 }
3266 for (int kb=0;kb<nQuadraturePoints_elementBoundary;kb++)
3267 {
3268 int ebN_kb = ebN*nQuadraturePoints_elementBoundary+kb,
3269 /* ebNE_kb_nSpace = ebNE_kb*nSpace, */
3270 ebN_local_kb = ebN_local*nQuadraturePoints_elementBoundary+kb,
3271 ebN_local_kb_nSpace = ebN_local_kb*nSpace;
3272 double u_ext=0.0, v_ext=0.0, w_ext=0.0,
3273 bc_u_ext=0.0, bc_v_ext=0.0, bc_w_ext=0.0,
3274 grad_u_ext[nSpace], grad_v_ext[nSpace], grad_w_ext[nSpace],
3275 jac_ext[nSpace*nSpace],
3276 jacDet_ext,
3277 jacInv_ext[nSpace*nSpace],
3278 boundaryJac[nSpace*(nSpace-1)],
3279 metricTensor[(nSpace-1)*(nSpace-1)],
3280 metricTensorDetSqrt,
3281 dS,
3282 p_test_dS[nDOF_test_element],p_grad_trial_trace[nDOF_trial_element*nSpace],
3283 vel_test_dS[nDOF_test_element],
3284 vel_grad_trial_trace[nDOF_trial_element*nSpace],
3285 vel_grad_test_dS[nDOF_trial_element*nSpace],
3286 normal[3],
3287 x_ext,y_ext,z_ext,xt_ext,yt_ext,zt_ext,integralScaling,
3288 G[nSpace*nSpace],G_dd_G,tr_G,h_phi,h_penalty,penalty,
3289 force_x,force_y,force_z,
3290 force_p_x,force_p_y,force_p_z,
3291 force_v_x,force_v_y,force_v_z,
3292 r_x,r_y,r_z;
3293 //compute information about mapping from reference element to physical element
3294 ck.calculateMapping_elementBoundary(eN,
3295 ebN_local,
3296 kb,
3297 ebN_local_kb,
3298 mesh_dof.data(),
3299 mesh_l2g.data(),
3300 mesh_trial_trace_ref.data(),
3301 mesh_grad_trial_trace_ref.data(),
3302 boundaryJac_ref.data(),
3303 jac_ext,
3304 jacDet_ext,
3305 jacInv_ext,
3306 boundaryJac,
3307 metricTensor,
3308 metricTensorDetSqrt,
3309 normal_ref.data(),
3310 normal,
3311 x_ext,y_ext,z_ext);
3312 ck.calculateMappingVelocity_elementBoundary(eN,
3313 ebN_local,
3314 kb,
3315 ebN_local_kb,
3316 mesh_velocity_dof.data(),
3317 mesh_l2g.data(),
3318 mesh_trial_trace_ref.data(),
3319 xt_ext,yt_ext,zt_ext,
3320 normal,
3321 boundaryJac,
3322 metricTensor,
3323 integralScaling);
3324 dS = metricTensorDetSqrt*dS_ref[kb];
3325 //get the metric tensor
3326 ck.calculateG(jacInv_ext,G,G_dd_G,tr_G);
3327 //compute shape and solution information
3328 //shape
3329 ck.gradTrialFromRef(&vel_grad_trial_trace_ref[ebN_local_kb_nSpace*nDOF_trial_element],jacInv_ext,vel_grad_trial_trace);
3330 //solution and gradients
3331 ck.valFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_trace_ref[ebN_local_kb*nDOF_test_element],u_ext);
3332 ck.valFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_trace_ref[ebN_local_kb*nDOF_test_element],v_ext);
3333 ck.valFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_trace_ref[ebN_local_kb*nDOF_test_element],w_ext);
3334
3335 ck.gradFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial_trace,grad_u_ext);
3336 ck.gradFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial_trace,grad_v_ext);
3337 ck.gradFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial_trace,grad_w_ext);
3338 for (int j=0;j<nDOF_trial_element;j++)
3339 {
3340 vel_test_dS[j] = vel_test_trace_ref[ebN_local_kb*nDOF_test_element+j]*dS;
3341 for (int I=0;I<nSpace;I++)
3342 vel_grad_test_dS[j*nSpace+I] = vel_grad_trial_trace[j*nSpace+I]*dS;//cek hack, using trial
3343 }
3344 ck.calculateGScale(G,normal,h_penalty);
3345 //
3346 //update the element and global residual storage
3347 //
3348 double dist;
3349 double distance[3], P_normal[3], P_tangent[3]; // distance vector, normal and tangent of the physical boundary
3350 if(use_ball_as_particle==1)
3351 {
3352 get_distance_to_ball(nParticles,ball_center.data(),ball_radius.data(),
3353 x_ext,y_ext,z_ext,
3354 dist);
3355 get_normal_to_ith_ball(nParticles,ball_center.data(),ball_radius.data(),
3356 surrogate_boundary_particle[ebN_s],
3357 x_ext,y_ext,z_ext,
3358 P_normal[0],P_normal[1],P_normal[2]);
3359 get_velocity_to_ith_ball(nParticles,ball_center.data(),ball_radius.data(),
3360 ball_velocity.data(),ball_angular_velocity.data(),
3361 surrogate_boundary_particle[ebN_s],
3362 x_ext-dist*P_normal[0],//corresponding point on the boundary of the particle
3363 y_ext-dist*P_normal[1],
3364 z_ext-dist*P_normal[2],
3365 bc_u_ext,bc_v_ext,bc_w_ext);
3366
3367 }
3368 else
3369 {
3370 dist = ebq_global_phi_solid[ebN_kb];
3371 P_normal[0] = ebq_global_grad_phi_solid[ebN_kb*nSpace+0];
3372 P_normal[1] = ebq_global_grad_phi_solid[ebN_kb*nSpace+1];
3373 P_normal[2] = ebq_global_grad_phi_solid[ebN_kb*nSpace+2];
3374 bc_u_ext = ebq_particle_velocity_solid [ebN_kb*nSpace+0];
3375 bc_v_ext = ebq_particle_velocity_solid [ebN_kb*nSpace+1];
3376 bc_w_ext = ebq_particle_velocity_solid [ebN_kb*nSpace+2];
3377 }
3378 distance[0] = -P_normal[0]*dist;//distance=vector from \tilde{x} to x
3379 distance[1] = -P_normal[1]*dist;
3380 distance[2] = -P_normal[2]*dist;
3381 assert(h_penalty>0.0);
3382 if (h_penalty < std::abs(dist))
3383 h_penalty = std::abs(dist);
3384
3385 if(get_dot_product(P_normal,normal)>0)
3386 {
3387 for(int i=0;i<3;++i)
3388 {
3389 normal[i] *= -1.0;
3390 }
3391 }
3392 //hack: this won't work for two-phase flow, need mixture viscosity
3393 double visco = nu_0*rho_0;
3394 double C_adim = C_sbm*visco/h_penalty;
3395 double beta_adim = beta_sbm*h_penalty*visco;
3396
3397 const double grad_u_d[3] = {get_dot_product(distance,grad_u_ext),
3398 get_dot_product(distance,grad_v_ext),
3399 get_dot_product(distance,grad_w_ext)};
3400 double res[3];
3401 const double u_m_uD[3] = {u_ext - bc_u_ext,v_ext - bc_v_ext,w_ext - bc_w_ext};
3402 const double zero_vec[3]={0.,0.,0.};
3403 //YY: How to define tangent penalty? There are two directions.
3404// double dt1 = P_tangent[0]*grad_u_ext[0] + P_tangent[1]*grad_u_ext[1];
3405// double dt2 = P_tangent[0]*grad_v_ext[0] + P_tangent[1]*grad_v_ext[1];
3406 for (int i=0;i<nDOF_test_element;i++)
3407 {
3408 int eN_i = eN*nDOF_test_element+i;
3409
3410 int GlobPos_u = offset_u+stride_u*vel_l2g[eN_i];
3411 int GlobPos_v = offset_v+stride_v*vel_l2g[eN_i];
3412 int GlobPos_w = offset_w+stride_w*vel_l2g[eN_i];
3413 const double phi_i = vel_test_dS[i];
3414 double *grad_phi_i = &vel_grad_test_dS[i*nSpace+0];
3415 const double grad_phi_i_dot_d = get_dot_product(distance,grad_phi_i);
3416
3417 // (1)
3418 globalResidual[GlobPos_u] += C_adim*phi_i*u_m_uD[0];
3419 globalResidual[GlobPos_v] += C_adim*phi_i*u_m_uD[1];
3420 globalResidual[GlobPos_w] += C_adim*phi_i*u_m_uD[2];
3421
3422 // (2)
3423 get_symmetric_gradient_dot_vec(grad_u_ext,grad_v_ext,grad_w_ext,normal,res);
3424 globalResidual[GlobPos_u] -= visco * phi_i*res[0];
3425 globalResidual[GlobPos_v] -= visco * phi_i*res[1];
3426 globalResidual[GlobPos_w] -= visco * phi_i*res[2];
3427
3428 // (3)
3429 get_symmetric_gradient_dot_vec(grad_phi_i,zero_vec,zero_vec,normal,res);
3430 globalResidual[GlobPos_u] -= visco * get_dot_product(u_m_uD,res);
3431 get_symmetric_gradient_dot_vec(zero_vec,grad_phi_i,zero_vec,normal,res);
3432 globalResidual[GlobPos_v] -= visco * get_dot_product(u_m_uD,res);
3433 get_symmetric_gradient_dot_vec(zero_vec,zero_vec,grad_phi_i,normal,res);
3434 globalResidual[GlobPos_w] -= visco * get_dot_product(u_m_uD,res);
3435
3436 // (4)
3437 globalResidual[GlobPos_u] += C_adim*grad_phi_i_dot_d*u_m_uD[0];
3438 globalResidual[GlobPos_v] += C_adim*grad_phi_i_dot_d*u_m_uD[1];
3439 globalResidual[GlobPos_w] += C_adim*grad_phi_i_dot_d*u_m_uD[2];
3440
3441 // (5)
3442 globalResidual[GlobPos_u] += C_adim*grad_phi_i_dot_d*grad_u_d[0];
3443 globalResidual[GlobPos_v] += C_adim*grad_phi_i_dot_d*grad_u_d[1];
3444 globalResidual[GlobPos_w] += C_adim*grad_phi_i_dot_d*grad_u_d[2];
3445
3446 // (6)
3447 globalResidual[GlobPos_u] += C_adim*phi_i*grad_u_d[0];
3448 globalResidual[GlobPos_v] += C_adim*phi_i*grad_u_d[1];
3449 globalResidual[GlobPos_w] += C_adim*phi_i*grad_u_d[2];
3450
3451 // (7)
3452 get_symmetric_gradient_dot_vec(grad_phi_i,zero_vec,zero_vec,normal,res);
3453 globalResidual[GlobPos_u] -= visco*get_dot_product(grad_u_d,res);
3454 get_symmetric_gradient_dot_vec(zero_vec,grad_phi_i,zero_vec,normal,res);
3455 globalResidual[GlobPos_v] -=visco*get_dot_product(grad_u_d,res);
3456 get_symmetric_gradient_dot_vec(zero_vec,zero_vec,grad_phi_i,normal,res);
3457 globalResidual[GlobPos_w] -= visco*get_dot_product(grad_u_d,res);
3458
3459 // the penalization on the tangential derivative (8)
3460// globalResidual[GlobPos_u] += beta_adim*dt1*(Gxphi_i*P_tangent[0] + Gyphi_i*P_tangent[1]);
3461// globalResidual[GlobPos_v] += beta_adim*dt2*(Gxphi_i*P_tangent[0] + Gyphi_i*P_tangent[1]);
3462
3463 }//i
3464
3465 //
3466 // Forces
3467 //
3468 //compute pressure at the quadrature point of the edge from dof-value of the pressure
3469 double p_ext = 0.0;
3470 for (int i=0; i<nDOF_per_element_pressure;++i)
3471 {
3472 p_ext += p_dof[p_l2g[eN*nDOF_per_element_pressure+i]]*p_trial_trace_ref[ebN_local_kb*nDOF_per_element_pressure+i];
3473 }
3474 get_symmetric_gradient_dot_vec(grad_u_ext,grad_v_ext,grad_w_ext,P_normal,res);
3475 double force_quad_pt[3]={0.0,0.0,0.0},torque_quad_pt[3]={0.0,0.0,0.0},position_vector_to_mass_center[3];
3476
3477 get_stress_in_n(grad_u_ext,grad_v_ext,grad_w_ext,P_normal,p_ext,visco,force_quad_pt);
3478
3479 force_quad_pt[0] *= dS;
3480 force_quad_pt[1] *= dS;
3481 force_quad_pt[2] *= dS;
3482 if(use_ball_as_particle==1)
3483 {
3484 position_vector_to_mass_center[0] = x_ext - ball_center[surrogate_boundary_particle[ebN_s] * 3 + 0];
3485 position_vector_to_mass_center[1] = y_ext - ball_center[surrogate_boundary_particle[ebN_s] * 3 + 1];
3486 position_vector_to_mass_center[2] = z_ext - ball_center[surrogate_boundary_particle[ebN_s] * 3 + 2];
3487 }
3488 else
3489 {
3490 position_vector_to_mass_center[0] = x_ext - particle_centroids[surrogate_boundary_particle[ebN_s] * 3 + 0];
3491 position_vector_to_mass_center[1] = y_ext - particle_centroids[surrogate_boundary_particle[ebN_s] * 3 + 1];
3492 position_vector_to_mass_center[2] = z_ext - particle_centroids[surrogate_boundary_particle[ebN_s] * 3 + 2];
3493 }
3494 get_cross_product(position_vector_to_mass_center,force_quad_pt,torque_quad_pt);
3495 if(ebN < nElementBoundaries_owned)//avoid double counting
3496 {
3497 particle_netForces[3*surrogate_boundary_particle[ebN_s]+0] += force_quad_pt[0];
3498 particle_netForces[3*surrogate_boundary_particle[ebN_s]+1] += force_quad_pt[1];
3499 particle_netForces[3*surrogate_boundary_particle[ebN_s]+2] += force_quad_pt[2];
3500 particle_netMoments[3*surrogate_boundary_particle[ebN_s]+0] += torque_quad_pt[0];
3501 particle_netMoments[3*surrogate_boundary_particle[ebN_s]+1] += torque_quad_pt[1];
3502 particle_netMoments[3*surrogate_boundary_particle[ebN_s]+2] += torque_quad_pt[2];
3503 }
3504 }//kb
3505 }//ebN_s
3506 }
3507 //
3508 //loop over exterior element boundaries to calculate surface integrals and load into element and global residuals
3509 //
3510 //ebNE is the Exterior element boundary INdex
3511 //ebN is the element boundary INdex
3512 //eN is the element index
3513 gf.useExact=false;
3514 gf_s.useExact=false;
3515 for (int ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
3516 {
3517 int ebN = exteriorElementBoundariesArray[ebNE],
3518 eN = elementBoundaryElementsArray[ebN*2+0],
3519 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0],
3520 eN_nDOF_trial_element = eN*nDOF_trial_element;
3521 double elementResidual_mesh[nDOF_test_element],
3522 elementResidual_p[nDOF_test_element],
3523 elementResidual_u[nDOF_test_element],
3524 elementResidual_v[nDOF_test_element],
3525 elementResidual_w[nDOF_test_element],
3526 eps_rho,eps_mu;
3527 for (int i=0;i<nDOF_test_element;i++)
3528 {
3529 elementResidual_mesh[i]=0.0;
3530 elementResidual_p[i]=0.0;
3531 elementResidual_u[i]=0.0;
3532 elementResidual_v[i]=0.0;
3533 elementResidual_w[i]=0.0;
3534 }
3535 for (int kb=0;kb<nQuadraturePoints_elementBoundary;kb++)
3536 {
3537 int ebNE_kb = ebNE*nQuadraturePoints_elementBoundary+kb,
3538 ebNE_kb_nSpace = ebNE_kb*nSpace,
3539 ebN_local_kb = ebN_local*nQuadraturePoints_elementBoundary+kb,
3540 ebN_local_kb_nSpace = ebN_local_kb*nSpace;
3541 double p_ext=0.0,
3542 u_ext=0.0,
3543 v_ext=0.0,
3544 w_ext=0.0,
3545 grad_p_ext[nSpace],
3546 grad_u_ext[nSpace],
3547 grad_v_ext[nSpace],
3548 grad_w_ext[nSpace],
3549 mom_u_acc_ext=0.0,
3550 dmom_u_acc_u_ext=0.0,
3551 mom_v_acc_ext=0.0,
3552 dmom_v_acc_v_ext=0.0,
3553 mom_w_acc_ext=0.0,
3554 dmom_w_acc_w_ext=0.0,
3555 mass_adv_ext[nSpace],
3556 dmass_adv_u_ext[nSpace],
3557 dmass_adv_v_ext[nSpace],
3558 dmass_adv_w_ext[nSpace],
3559 mom_u_adv_ext[nSpace],
3560 dmom_u_adv_u_ext[nSpace],
3561 dmom_u_adv_v_ext[nSpace],
3562 dmom_u_adv_w_ext[nSpace],
3563 mom_v_adv_ext[nSpace],
3564 dmom_v_adv_u_ext[nSpace],
3565 dmom_v_adv_v_ext[nSpace],
3566 dmom_v_adv_w_ext[nSpace],
3567 mom_w_adv_ext[nSpace],
3568 dmom_w_adv_u_ext[nSpace],
3569 dmom_w_adv_v_ext[nSpace],
3570 dmom_w_adv_w_ext[nSpace],
3571 mom_uu_diff_ten_ext[nSpace],
3572 mom_vv_diff_ten_ext[nSpace],
3573 mom_ww_diff_ten_ext[nSpace],
3574 mom_uv_diff_ten_ext[1],
3575 mom_uw_diff_ten_ext[1],
3576 mom_vu_diff_ten_ext[1],
3577 mom_vw_diff_ten_ext[1],
3578 mom_wu_diff_ten_ext[1],
3579 mom_wv_diff_ten_ext[1],
3580 mom_u_source_ext=0.0,
3581 mom_v_source_ext=0.0,
3582 mom_w_source_ext=0.0,
3583 mom_u_ham_ext=0.0,
3584 dmom_u_ham_grad_p_ext[nSpace],
3585 dmom_u_ham_grad_u_ext[nSpace],
3586 mom_v_ham_ext=0.0,
3587 dmom_v_ham_grad_p_ext[nSpace],
3588 dmom_v_ham_grad_v_ext[nSpace],
3589 mom_w_ham_ext=0.0,
3590 dmom_w_ham_grad_p_ext[nSpace],
3591 dmom_w_ham_grad_w_ext[nSpace],
3592 dmom_u_adv_p_ext[nSpace],
3593 dmom_v_adv_p_ext[nSpace],
3594 dmom_w_adv_p_ext[nSpace],
3595 flux_mass_ext=0.0,
3596 flux_mom_u_adv_ext=0.0,
3597 flux_mom_v_adv_ext=0.0,
3598 flux_mom_w_adv_ext=0.0,
3599 flux_mom_uu_diff_ext=0.0,
3600 flux_mom_uv_diff_ext=0.0,
3601 flux_mom_uw_diff_ext=0.0,
3602 flux_mom_vu_diff_ext=0.0,
3603 flux_mom_vv_diff_ext=0.0,
3604 flux_mom_vw_diff_ext=0.0,
3605 flux_mom_wu_diff_ext=0.0,
3606 flux_mom_wv_diff_ext=0.0,
3607 flux_mom_ww_diff_ext=0.0,
3608 bc_p_ext=0.0,
3609 bc_u_ext=0.0,
3610 bc_v_ext=0.0,
3611 bc_w_ext=0.0,
3612 bc_mom_u_acc_ext=0.0,
3613 bc_dmom_u_acc_u_ext=0.0,
3614 bc_mom_v_acc_ext=0.0,
3615 bc_dmom_v_acc_v_ext=0.0,
3616 bc_mom_w_acc_ext=0.0,
3617 bc_dmom_w_acc_w_ext=0.0,
3618 bc_mass_adv_ext[nSpace],
3619 bc_dmass_adv_u_ext[nSpace],
3620 bc_dmass_adv_v_ext[nSpace],
3621 bc_dmass_adv_w_ext[nSpace],
3622 bc_mom_u_adv_ext[nSpace],
3623 bc_dmom_u_adv_u_ext[nSpace],
3624 bc_dmom_u_adv_v_ext[nSpace],
3625 bc_dmom_u_adv_w_ext[nSpace],
3626 bc_mom_v_adv_ext[nSpace],
3627 bc_dmom_v_adv_u_ext[nSpace],
3628 bc_dmom_v_adv_v_ext[nSpace],
3629 bc_dmom_v_adv_w_ext[nSpace],
3630 bc_mom_w_adv_ext[nSpace],
3631 bc_dmom_w_adv_u_ext[nSpace],
3632 bc_dmom_w_adv_v_ext[nSpace],
3633 bc_dmom_w_adv_w_ext[nSpace],
3634 bc_mom_uu_diff_ten_ext[nSpace],
3635 bc_mom_vv_diff_ten_ext[nSpace],
3636 bc_mom_ww_diff_ten_ext[nSpace],
3637 bc_mom_uv_diff_ten_ext[1],
3638 bc_mom_uw_diff_ten_ext[1],
3639 bc_mom_vu_diff_ten_ext[1],
3640 bc_mom_vw_diff_ten_ext[1],
3641 bc_mom_wu_diff_ten_ext[1],
3642 bc_mom_wv_diff_ten_ext[1],
3643 bc_mom_u_source_ext=0.0,
3644 bc_mom_v_source_ext=0.0,
3645 bc_mom_w_source_ext=0.0,
3646 bc_mom_u_ham_ext=0.0,
3647 bc_dmom_u_ham_grad_p_ext[nSpace],
3648 bc_dmom_u_ham_grad_u_ext[nSpace],
3649 bc_mom_v_ham_ext=0.0,
3650 bc_dmom_v_ham_grad_p_ext[nSpace],
3651 bc_dmom_v_ham_grad_v_ext[nSpace],
3652 bc_mom_w_ham_ext=0.0,
3653 bc_dmom_w_ham_grad_p_ext[nSpace],
3654 bc_dmom_w_ham_grad_w_ext[nSpace],
3655 jac_ext[nSpace*nSpace],
3656 jacDet_ext,
3657 jacInv_ext[nSpace*nSpace],
3658 boundaryJac[nSpace*(nSpace-1)],
3659 metricTensor[(nSpace-1)*(nSpace-1)],
3660 metricTensorDetSqrt,
3661 dS,p_test_dS[nDOF_test_element],vel_test_dS[nDOF_test_element],
3662 p_grad_trial_trace[nDOF_trial_element*nSpace],vel_grad_trial_trace[nDOF_trial_element*nSpace],
3663 vel_grad_test_dS[nDOF_trial_element*nSpace],
3664 normal[3],x_ext,y_ext,z_ext,xt_ext,yt_ext,zt_ext,integralScaling,
3665 //VRANS
3666 porosity_ext,
3667 //
3668 G[nSpace*nSpace],G_dd_G,tr_G,h_phi,h_penalty,penalty,
3669 force_x,force_y,force_z,force_p_x,force_p_y,force_p_z,force_v_x,force_v_y,force_v_z,r_x,r_y,r_z;
3670 //compute information about mapping from reference element to physical element
3671 ck.calculateMapping_elementBoundary(eN,
3672 ebN_local,
3673 kb,
3674 ebN_local_kb,
3675 mesh_dof.data(),
3676 mesh_l2g.data(),
3677 mesh_trial_trace_ref.data(),
3678 mesh_grad_trial_trace_ref.data(),
3679 boundaryJac_ref.data(),
3680 jac_ext,
3681 jacDet_ext,
3682 jacInv_ext,
3683 boundaryJac,
3684 metricTensor,
3685 metricTensorDetSqrt,
3686 normal_ref.data(),
3687 normal,
3688 x_ext,y_ext,z_ext);
3689 ck.calculateMappingVelocity_elementBoundary(eN,
3690 ebN_local,
3691 kb,
3692 ebN_local_kb,
3693 mesh_velocity_dof.data(),
3694 mesh_l2g.data(),
3695 mesh_trial_trace_ref.data(),
3696 xt_ext,yt_ext,zt_ext,
3697 normal,
3698 boundaryJac,
3699 metricTensor,
3700 integralScaling);
3701 //xt_ext=0.0;yt_ext=0.0;zt_ext=0.0;
3702 //std::cout<<"xt_ext "<<xt_ext<<'\t'<<yt_ext<<'\t'<<zt_ext<<std::endl;
3703 //std::cout<<"x_ext "<<x_ext<<'\t'<<y_ext<<'\t'<<z_ext<<std::endl;
3704 //std::cout<<"integralScaling - metricTensorDetSrt ==============================="<<integralScaling-metricTensorDetSqrt<<std::endl;
3705 /* std::cout<<"metricTensorDetSqrt "<<metricTensorDetSqrt */
3706 /* <<"dS_ref[kb]"<<dS_ref[kb]<<std::endl; */
3707 //dS = ((1.0-MOVING_DOMAIN)*metricTensorDetSqrt + MOVING_DOMAIN*integralScaling)*dS_ref[kb];//cek need to test effect on accuracy
3708 dS = metricTensorDetSqrt*dS_ref[kb];
3709 //get the metric tensor
3710 //cek todo use symmetry
3711 ck.calculateG(jacInv_ext,G,G_dd_G,tr_G);
3712 ck.calculateGScale(G,&ebqe_normal_phi_ext[ebNE_kb_nSpace],h_phi);
3713
3714 eps_rho = epsFact_rho*(useMetrics*h_phi+(1.0-useMetrics)*elementDiameter[eN]);
3715 eps_mu = epsFact_mu *(useMetrics*h_phi+(1.0-useMetrics)*elementDiameter[eN]);
3716 double particle_eps = particle_epsFact*(useMetrics*h_phi+(1.0-useMetrics)*elementDiameter[eN]);
3717
3718 //compute shape and solution information
3719 //shape
3720 /* ck.gradTrialFromRef(&p_grad_trial_trace_ref[ebN_local_kb_nSpace*nDOF_trial_element],jacInv_ext,p_grad_trial_trace); */
3721 ck.gradTrialFromRef(&vel_grad_trial_trace_ref[ebN_local_kb_nSpace*nDOF_trial_element],jacInv_ext,vel_grad_trial_trace);
3722 //cek hack use trial ck.gradTrialFromRef(&vel_grad_test_trace_ref[ebN_local_kb_nSpace*nDOF_trial_element],jacInv_ext,vel_grad_test_trace);
3723 //solution and gradients
3724 /* ck.valFromDOF(p_dof,&p_l2g[eN_nDOF_trial_element],&p_trial_trace_ref[ebN_local_kb*nDOF_test_element],p_ext); */
3725 p_ext = ebqe_p[ebNE_kb];
3726 ck.valFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_trace_ref[ebN_local_kb*nDOF_test_element],u_ext);
3727 ck.valFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_trace_ref[ebN_local_kb*nDOF_test_element],v_ext);
3728 ck.valFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_trace_ref[ebN_local_kb*nDOF_test_element],w_ext);
3729 /* ck.gradFromDOF(p_dof,&p_l2g[eN_nDOF_trial_element],p_grad_trial_trace,grad_p_ext); */
3730 for (int I=0;I<nSpace;I++)
3731 grad_p_ext[I] = ebqe_grad_p[ebNE_kb_nSpace + I];
3732 ck.gradFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial_trace,grad_u_ext);
3733 ck.gradFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial_trace,grad_v_ext);
3734 ck.gradFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial_trace,grad_w_ext);
3735 //precalculate test function products with integration weights
3736 for (int j=0;j<nDOF_trial_element;j++)
3737 {
3738 /* p_test_dS[j] = p_test_trace_ref[ebN_local_kb*nDOF_test_element+j]*dS; */
3739 vel_test_dS[j] = vel_test_trace_ref[ebN_local_kb*nDOF_test_element+j]*dS;
3740 for (int I=0;I<nSpace;I++)
3741 vel_grad_test_dS[j*nSpace+I] = vel_grad_trial_trace[j*nSpace+I]*dS;//cek hack, using trial
3742 }
3743 bc_p_ext = isDOFBoundary_p[ebNE_kb]*ebqe_bc_p_ext[ebNE_kb]+(1-isDOFBoundary_p[ebNE_kb])*p_ext;
3744 //note, our convention is that bc values at moving boundaries are relative to boundary velocity so we add it here
3745 bc_u_ext = isDOFBoundary_u[ebNE_kb]*(ebqe_bc_u_ext[ebNE_kb] + MOVING_DOMAIN*xt_ext) + (1-isDOFBoundary_u[ebNE_kb])*u_ext;
3746 bc_v_ext = isDOFBoundary_v[ebNE_kb]*(ebqe_bc_v_ext[ebNE_kb] + MOVING_DOMAIN*yt_ext) + (1-isDOFBoundary_v[ebNE_kb])*v_ext;
3747 bc_w_ext = isDOFBoundary_w[ebNE_kb]*(ebqe_bc_w_ext[ebNE_kb] + MOVING_DOMAIN*zt_ext) + (1-isDOFBoundary_w[ebNE_kb])*w_ext;
3748 //VRANS
3749 porosity_ext = 1.0 - ebqe_vos_ext[ebNE_kb];
3750 //
3751 //calculate the pde coefficients using the solution and the boundary values for the solution
3752 //
3753 double distance_to_omega_solid = 1e10;
3754 if (use_ball_as_particle == 1)
3755 {
3756 get_distance_to_ball(nParticles, ball_center.data(), ball_radius.data(), x_ext, y_ext, z_ext, distance_to_omega_solid);
3757 }
3758 else
3759 {
3760 for (int i = 0; i < nParticles; i++)
3761 {
3762 double distance_to_i_th_solid = ebq_global_phi_solid[i * nElementBoundaries_global * nQuadraturePoints_elementBoundary + ebNE_kb];
3763 distance_to_omega_solid = (distance_to_i_th_solid < distance_to_omega_solid)?distance_to_i_th_solid:distance_to_omega_solid;
3764 }
3765 }
3766 double eddy_viscosity_ext(0.),bc_eddy_viscosity_ext(0.); //not interested in saving boundary eddy viscosity for now
3767 evaluateCoefficients(eps_rho,
3768 eps_mu,
3769 particle_eps,
3770 sigma,
3771 rho_0,
3772 nu_0,
3773 rho_1,
3774 nu_1,
3775 elementDiameter[eN],
3776 smagorinskyConstant,
3777 turbulenceClosureModel,
3778 g.data(),
3779 useVF,
3780 ebqe_vf_ext[ebNE_kb],
3781 ebqe_phi_ext[ebNE_kb],
3782 &ebqe_normal_phi_ext[ebNE_kb_nSpace],
3783 distance_to_omega_solid,
3784 ebqe_kappa_phi_ext[ebNE_kb],
3785 //VRANS
3786 porosity_ext,
3787 //
3788 p_ext,
3789 grad_p_ext,
3790 grad_u_ext,
3791 grad_v_ext,
3792 grad_w_ext,
3793 u_ext,
3794 v_ext,
3795 w_ext,
3796 ebqe_velocity_star[ebNE_kb_nSpace+0],
3797 ebqe_velocity_star[ebNE_kb_nSpace+1],
3798 ebqe_velocity_star[ebNE_kb_nSpace+2],
3799 eddy_viscosity_ext,
3800 mom_u_acc_ext,
3801 dmom_u_acc_u_ext,
3802 mom_v_acc_ext,
3803 dmom_v_acc_v_ext,
3804 mom_w_acc_ext,
3805 dmom_w_acc_w_ext,
3806 mass_adv_ext,
3807 dmass_adv_u_ext,
3808 dmass_adv_v_ext,
3809 dmass_adv_w_ext,
3810 mom_u_adv_ext,
3811 dmom_u_adv_u_ext,
3812 dmom_u_adv_v_ext,
3813 dmom_u_adv_w_ext,
3814 mom_v_adv_ext,
3815 dmom_v_adv_u_ext,
3816 dmom_v_adv_v_ext,
3817 dmom_v_adv_w_ext,
3818 mom_w_adv_ext,
3819 dmom_w_adv_u_ext,
3820 dmom_w_adv_v_ext,
3821 dmom_w_adv_w_ext,
3822 mom_uu_diff_ten_ext,
3823 mom_vv_diff_ten_ext,
3824 mom_ww_diff_ten_ext,
3825 mom_uv_diff_ten_ext,
3826 mom_uw_diff_ten_ext,
3827 mom_vu_diff_ten_ext,
3828 mom_vw_diff_ten_ext,
3829 mom_wu_diff_ten_ext,
3830 mom_wv_diff_ten_ext,
3831 mom_u_source_ext,
3832 mom_v_source_ext,
3833 mom_w_source_ext,
3834 mom_u_ham_ext,
3835 dmom_u_ham_grad_p_ext,
3836 dmom_u_ham_grad_u_ext,
3837 mom_v_ham_ext,
3838 dmom_v_ham_grad_p_ext,
3839 dmom_v_ham_grad_v_ext,
3840 mom_w_ham_ext,
3841 dmom_w_ham_grad_p_ext,
3842 dmom_w_ham_grad_w_ext,
3843 ebqe_rho[ebNE_kb],
3844 ebqe_nu[ebNE_kb],
3845 KILL_PRESSURE_TERM,
3846 0,
3847 0., // mql: zero force term at boundary
3848 0.,
3849 0.,
3850 MATERIAL_PARAMETERS_AS_FUNCTION,
3851 ebqe_density_as_function[ebNE_kb],
3852 ebqe_dynamic_viscosity_as_function[ebNE_kb],
3853 USE_SBM,
3854 x_ext,y_ext,z_ext,
3855 use_ball_as_particle,
3856 ball_center.data(),
3857 ball_radius.data(),
3858 ball_velocity.data(),
3859 ball_angular_velocity.data(),
3860 INT_BY_PARTS_PRESSURE);
3861 evaluateCoefficients(eps_rho,
3862 eps_mu,
3863 particle_eps,
3864 sigma,
3865 rho_0,
3866 nu_0,
3867 rho_1,
3868 nu_1,
3869 elementDiameter[eN],
3870 smagorinskyConstant,
3871 turbulenceClosureModel,
3872 g.data(),
3873 useVF,
3874 bc_ebqe_vf_ext[ebNE_kb],
3875 bc_ebqe_phi_ext[ebNE_kb],
3876 &ebqe_normal_phi_ext[ebNE_kb_nSpace],
3877 distance_to_omega_solid,
3878 ebqe_kappa_phi_ext[ebNE_kb],
3879 //VRANS
3880 porosity_ext,
3881 //
3882 bc_p_ext,
3883 grad_p_ext,
3884 grad_u_ext,
3885 grad_v_ext,
3886 grad_w_ext,
3887 bc_u_ext,
3888 bc_v_ext,
3889 bc_w_ext,
3890 ebqe_velocity_star[ebNE_kb_nSpace+0],
3891 ebqe_velocity_star[ebNE_kb_nSpace+1],
3892 ebqe_velocity_star[ebNE_kb_nSpace+2],
3893 bc_eddy_viscosity_ext,
3894 bc_mom_u_acc_ext,
3895 bc_dmom_u_acc_u_ext,
3896 bc_mom_v_acc_ext,
3897 bc_dmom_v_acc_v_ext,
3898 bc_mom_w_acc_ext,
3899 bc_dmom_w_acc_w_ext,
3900 bc_mass_adv_ext,
3901 bc_dmass_adv_u_ext,
3902 bc_dmass_adv_v_ext,
3903 bc_dmass_adv_w_ext,
3904 bc_mom_u_adv_ext,
3905 bc_dmom_u_adv_u_ext,
3906 bc_dmom_u_adv_v_ext,
3907 bc_dmom_u_adv_w_ext,
3908 bc_mom_v_adv_ext,
3909 bc_dmom_v_adv_u_ext,
3910 bc_dmom_v_adv_v_ext,
3911 bc_dmom_v_adv_w_ext,
3912 bc_mom_w_adv_ext,
3913 bc_dmom_w_adv_u_ext,
3914 bc_dmom_w_adv_v_ext,
3915 bc_dmom_w_adv_w_ext,
3916 bc_mom_uu_diff_ten_ext,
3917 bc_mom_vv_diff_ten_ext,
3918 bc_mom_ww_diff_ten_ext,
3919 bc_mom_uv_diff_ten_ext,
3920 bc_mom_uw_diff_ten_ext,
3921 bc_mom_vu_diff_ten_ext,
3922 bc_mom_vw_diff_ten_ext,
3923 bc_mom_wu_diff_ten_ext,
3924 bc_mom_wv_diff_ten_ext,
3925 bc_mom_u_source_ext,
3926 bc_mom_v_source_ext,
3927 bc_mom_w_source_ext,
3928 bc_mom_u_ham_ext,
3929 bc_dmom_u_ham_grad_p_ext,
3930 bc_dmom_u_ham_grad_u_ext,
3931 bc_mom_v_ham_ext,
3932 bc_dmom_v_ham_grad_p_ext,
3933 bc_dmom_v_ham_grad_v_ext,
3934 bc_mom_w_ham_ext,
3935 bc_dmom_w_ham_grad_p_ext,
3936 bc_dmom_w_ham_grad_w_ext,
3937 ebqe_rho[ebNE_kb],
3938 ebqe_nu[ebNE_kb],
3939 KILL_PRESSURE_TERM,
3940 0,
3941 0., // mql: zero force term at boundary
3942 0.,
3943 0.,
3944 MATERIAL_PARAMETERS_AS_FUNCTION,
3945 ebqe_density_as_function[ebNE_kb],
3946 ebqe_dynamic_viscosity_as_function[ebNE_kb],
3947 USE_SBM,
3948 x_ext,y_ext,z_ext,
3949 use_ball_as_particle,
3950 ball_center.data(),
3951 ball_radius.data(),
3952 ball_velocity.data(),
3953 ball_angular_velocity.data(),
3954 INT_BY_PARTS_PRESSURE);
3955
3956 //Turbulence closure model
3957 if (turbulenceClosureModel >= 3)
3958 {
3959 const double turb_var_grad_0_dummy[3] = {0.,0.,0.};
3960 const double c_mu = 0.09;//mwf hack
3961 updateTurbulenceClosure(turbulenceClosureModel,
3962 eps_rho,
3963 eps_mu,
3964 rho_0,
3965 nu_0,
3966 rho_1,
3967 nu_1,
3968 useVF,
3969 ebqe_vf_ext[ebNE_kb],
3970 ebqe_phi_ext[ebNE_kb],
3971 porosity_ext,
3972 c_mu, //mwf hack
3973 ebqe_turb_var_0[ebNE_kb],
3974 ebqe_turb_var_1[ebNE_kb],
3975 turb_var_grad_0_dummy, //not needed
3976 eddy_viscosity_ext,
3977 mom_uu_diff_ten_ext,
3978 mom_vv_diff_ten_ext,
3979 mom_ww_diff_ten_ext,
3980 mom_uv_diff_ten_ext,
3981 mom_uw_diff_ten_ext,
3982 mom_vu_diff_ten_ext,
3983 mom_vw_diff_ten_ext,
3984 mom_wu_diff_ten_ext,
3985 mom_wv_diff_ten_ext,
3986 mom_u_source_ext,
3987 mom_v_source_ext,
3988 mom_w_source_ext);
3989
3990 updateTurbulenceClosure(turbulenceClosureModel,
3991 eps_rho,
3992 eps_mu,
3993 rho_0,
3994 nu_0,
3995 rho_1,
3996 nu_1,
3997 useVF,
3998 bc_ebqe_vf_ext[ebNE_kb],
3999 bc_ebqe_phi_ext[ebNE_kb],
4000 porosity_ext,
4001 c_mu, //mwf hack
4002 ebqe_turb_var_0[ebNE_kb],
4003 ebqe_turb_var_1[ebNE_kb],
4004 turb_var_grad_0_dummy, //not needed
4005 bc_eddy_viscosity_ext,
4006 bc_mom_uu_diff_ten_ext,
4007 bc_mom_vv_diff_ten_ext,
4008 bc_mom_ww_diff_ten_ext,
4009 bc_mom_uv_diff_ten_ext,
4010 bc_mom_uw_diff_ten_ext,
4011 bc_mom_vu_diff_ten_ext,
4012 bc_mom_vw_diff_ten_ext,
4013 bc_mom_wu_diff_ten_ext,
4014 bc_mom_wv_diff_ten_ext,
4015 bc_mom_u_source_ext,
4016 bc_mom_v_source_ext,
4017 bc_mom_w_source_ext);
4018 }
4019
4020
4021 //
4022 //moving domain
4023 //
4024 mom_u_adv_ext[0] -= MOVING_DOMAIN*dmom_u_acc_u_ext*mom_u_acc_ext*xt_ext; // times rho*porosity. mql. CHECK.
4025 mom_u_adv_ext[1] -= MOVING_DOMAIN*dmom_u_acc_u_ext*mom_u_acc_ext*yt_ext;
4026 mom_u_adv_ext[2] -= MOVING_DOMAIN*dmom_u_acc_u_ext*mom_u_acc_ext*zt_ext;
4027 dmom_u_adv_u_ext[0] -= MOVING_DOMAIN*dmom_u_acc_u_ext*xt_ext;
4028 dmom_u_adv_u_ext[1] -= MOVING_DOMAIN*dmom_u_acc_u_ext*yt_ext;
4029 dmom_u_adv_u_ext[2] -= MOVING_DOMAIN*dmom_u_acc_u_ext*zt_ext;
4030
4031 mom_v_adv_ext[0] -= MOVING_DOMAIN*dmom_v_acc_v_ext*mom_v_acc_ext*xt_ext;
4032 mom_v_adv_ext[1] -= MOVING_DOMAIN*dmom_v_acc_v_ext*mom_v_acc_ext*yt_ext;
4033 mom_v_adv_ext[2] -= MOVING_DOMAIN*dmom_v_acc_v_ext*mom_v_acc_ext*zt_ext;
4034 dmom_v_adv_v_ext[0] -= MOVING_DOMAIN*dmom_v_acc_v_ext*xt_ext;
4035 dmom_v_adv_v_ext[1] -= MOVING_DOMAIN*dmom_v_acc_v_ext*yt_ext;
4036 dmom_v_adv_v_ext[2] -= MOVING_DOMAIN*dmom_v_acc_v_ext*zt_ext;
4037
4038 mom_w_adv_ext[0] -= MOVING_DOMAIN*dmom_w_acc_w_ext*mom_w_acc_ext*xt_ext;
4039 mom_w_adv_ext[1] -= MOVING_DOMAIN*dmom_w_acc_w_ext*mom_w_acc_ext*yt_ext;
4040 mom_w_adv_ext[2] -= MOVING_DOMAIN*dmom_w_acc_w_ext*mom_w_acc_ext*zt_ext;
4041 dmom_w_adv_w_ext[0] -= MOVING_DOMAIN*dmom_w_acc_w_ext*xt_ext;
4042 dmom_w_adv_w_ext[1] -= MOVING_DOMAIN*dmom_w_acc_w_ext*yt_ext;
4043 dmom_w_adv_w_ext[2] -= MOVING_DOMAIN*dmom_w_acc_w_ext*zt_ext;
4044
4045 //bc's
4046 // mql. CHECK.
4047 bc_mom_u_adv_ext[0] -= MOVING_DOMAIN*bc_dmom_u_acc_u_ext*bc_mom_u_acc_ext*xt_ext; // times rho*porosity
4048 bc_mom_u_adv_ext[1] -= MOVING_DOMAIN*bc_dmom_u_acc_u_ext*bc_mom_u_acc_ext*yt_ext;
4049 bc_mom_u_adv_ext[2] -= MOVING_DOMAIN*bc_dmom_u_acc_u_ext*bc_mom_u_acc_ext*zt_ext;
4050
4051 bc_mom_v_adv_ext[0] -= MOVING_DOMAIN*bc_dmom_v_acc_v_ext*bc_mom_v_acc_ext*xt_ext;
4052 bc_mom_v_adv_ext[1] -= MOVING_DOMAIN*bc_dmom_v_acc_v_ext*bc_mom_v_acc_ext*yt_ext;
4053 bc_mom_v_adv_ext[2] -= MOVING_DOMAIN*bc_dmom_v_acc_v_ext*bc_mom_v_acc_ext*zt_ext;
4054
4055 bc_mom_w_adv_ext[0] -= MOVING_DOMAIN*bc_dmom_w_acc_w_ext*bc_mom_w_acc_ext*xt_ext;
4056 bc_mom_w_adv_ext[1] -= MOVING_DOMAIN*bc_dmom_w_acc_w_ext*bc_mom_w_acc_ext*yt_ext;
4057 bc_mom_w_adv_ext[2] -= MOVING_DOMAIN*bc_dmom_w_acc_w_ext*bc_mom_w_acc_ext*zt_ext;
4058
4059 //
4060 //calculate the numerical fluxes
4061 //
4062 ck.calculateGScale(G,normal,h_penalty);
4063 penalty = useMetrics*C_b/h_penalty + (1.0-useMetrics)*ebqe_penalty_ext[ebNE_kb];
4064 exteriorNumericalAdvectiveFlux(isDOFBoundary_p[ebNE_kb],
4065 isDOFBoundary_u[ebNE_kb],
4066 isDOFBoundary_v[ebNE_kb],
4067 isDOFBoundary_w[ebNE_kb],
4068 isAdvectiveFluxBoundary_p[ebNE_kb],
4069 isAdvectiveFluxBoundary_u[ebNE_kb],
4070 isAdvectiveFluxBoundary_v[ebNE_kb],
4071 isAdvectiveFluxBoundary_w[ebNE_kb],
4072 dmom_u_ham_grad_p_ext[0],//=1/rho,
4073 bc_dmom_u_ham_grad_p_ext[0],//=1/bc_rho,
4074 normal,
4075 porosity_ext*ebqe_rho[ebNE_kb],//dmom_u_acc_u_ext,
4076 bc_p_ext,
4077 bc_u_ext,
4078 bc_v_ext,
4079 bc_w_ext,
4080 bc_mass_adv_ext,
4081 bc_mom_u_adv_ext,
4082 bc_mom_v_adv_ext,
4083 bc_mom_w_adv_ext,
4084 ebqe_bc_flux_mass_ext[ebNE_kb]+MOVING_DOMAIN*(xt_ext*normal[0]+yt_ext*normal[1]+zt_ext*normal[2]),//BC is relative mass flux
4085 ebqe_bc_flux_mom_u_adv_ext[ebNE_kb],
4086 ebqe_bc_flux_mom_v_adv_ext[ebNE_kb],
4087 ebqe_bc_flux_mom_w_adv_ext[ebNE_kb],
4088 p_ext,
4089 u_ext,
4090 v_ext,
4091 w_ext,
4092 mass_adv_ext,
4093 mom_u_adv_ext,
4094 mom_v_adv_ext,
4095 mom_w_adv_ext,
4096 dmass_adv_u_ext,
4097 dmass_adv_v_ext,
4098 dmass_adv_w_ext,
4099 dmom_u_adv_p_ext,
4100 dmom_u_adv_u_ext,
4101 dmom_u_adv_v_ext,
4102 dmom_u_adv_w_ext,
4103 dmom_v_adv_p_ext,
4104 dmom_v_adv_u_ext,
4105 dmom_v_adv_v_ext,
4106 dmom_v_adv_w_ext,
4107 dmom_w_adv_p_ext,
4108 dmom_w_adv_u_ext,
4109 dmom_w_adv_v_ext,
4110 dmom_w_adv_w_ext,
4111 flux_mass_ext,
4112 flux_mom_u_adv_ext,
4113 flux_mom_v_adv_ext,
4114 flux_mom_w_adv_ext,
4115 &ebqe_velocity_star[ebNE_kb_nSpace],
4116 &ebqe_velocity[ebNE_kb_nSpace]);
4117 // mql: save gradient of solution for other models and to compute errors
4118 for (int I=0;I<nSpace;I++)
4119 {
4120 ebqe_grad_u[ebNE_kb_nSpace+I] = grad_u_ext[I];
4121 ebqe_grad_v[ebNE_kb_nSpace+I] = grad_v_ext[I];
4122 ebqe_grad_w[ebNE_kb_nSpace+I] = grad_w_ext[I];
4123 }
4124 exteriorNumericalDiffusiveFlux(eps_rho,
4125 ebqe_phi_ext[ebNE_kb],
4126 sdInfo_u_u_rowptr.data(),
4127 sdInfo_u_u_colind.data(),
4128 isDOFBoundary_u[ebNE_kb],
4129 isDiffusiveFluxBoundary_u[ebNE_kb],
4130 normal,
4131 bc_mom_uu_diff_ten_ext,
4132 bc_u_ext,
4133 ebqe_bc_flux_u_diff_ext[ebNE_kb],
4134 mom_uu_diff_ten_ext,
4135 grad_u_ext,
4136 u_ext,
4137 penalty,//ebqe_penalty_ext[ebNE_kb],
4138 flux_mom_uu_diff_ext);
4139 exteriorNumericalDiffusiveFlux(eps_rho,
4140 ebqe_phi_ext[ebNE_kb],
4141 sdInfo_u_v_rowptr.data(),
4142 sdInfo_u_v_colind.data(),
4143 isDOFBoundary_v[ebNE_kb],
4144 isDiffusiveFluxBoundary_v[ebNE_kb],
4145 normal,
4146 bc_mom_uv_diff_ten_ext,
4147 bc_v_ext,
4148 0.0,//assume all of the flux gets applied in diagonal component
4149 mom_uv_diff_ten_ext,
4150 grad_v_ext,
4151 v_ext,
4152 penalty,//ebqe_penalty_ext[ebNE_kb],
4153 flux_mom_uv_diff_ext);
4154 exteriorNumericalDiffusiveFlux(eps_rho,
4155 ebqe_phi_ext[ebNE_kb],
4156 sdInfo_u_w_rowptr.data(),
4157 sdInfo_u_w_colind.data(),
4158 isDOFBoundary_w[ebNE_kb],
4159 isDiffusiveFluxBoundary_w[ebNE_kb],
4160 normal,
4161 bc_mom_uw_diff_ten_ext,
4162 bc_w_ext,
4163 0.0,//see above
4164 mom_uw_diff_ten_ext,
4165 grad_w_ext,
4166 w_ext,
4167 penalty,//ebqe_penalty_ext[ebNE_kb],
4168 flux_mom_uw_diff_ext);
4169 exteriorNumericalDiffusiveFlux(eps_rho,
4170 ebqe_phi_ext[ebNE_kb],
4171 sdInfo_v_u_rowptr.data(),
4172 sdInfo_v_u_colind.data(),
4173 isDOFBoundary_u[ebNE_kb],
4174 isDiffusiveFluxBoundary_u[ebNE_kb],
4175 normal,
4176 bc_mom_vu_diff_ten_ext,
4177 bc_u_ext,
4178 0.0,//see above
4179 mom_vu_diff_ten_ext,
4180 grad_u_ext,
4181 u_ext,
4182 penalty,//ebqe_penalty_ext[ebNE_kb],
4183 flux_mom_vu_diff_ext);
4184 exteriorNumericalDiffusiveFlux(eps_rho,
4185 ebqe_phi_ext[ebNE_kb],
4186 sdInfo_v_v_rowptr.data(),
4187 sdInfo_v_v_colind.data(),
4188 isDOFBoundary_v[ebNE_kb],
4189 isDiffusiveFluxBoundary_v[ebNE_kb],
4190 normal,
4191 bc_mom_vv_diff_ten_ext,
4192 bc_v_ext,
4193 ebqe_bc_flux_v_diff_ext[ebNE_kb],
4194 mom_vv_diff_ten_ext,
4195 grad_v_ext,
4196 v_ext,
4197 penalty,//ebqe_penalty_ext[ebNE_kb],
4198 flux_mom_vv_diff_ext);
4199 exteriorNumericalDiffusiveFlux(eps_rho,
4200 ebqe_phi_ext[ebNE_kb],
4201 sdInfo_v_w_rowptr.data(),
4202 sdInfo_v_w_colind.data(),
4203 isDOFBoundary_w[ebNE_kb],
4204 isDiffusiveFluxBoundary_w[ebNE_kb],
4205 normal,
4206 bc_mom_vw_diff_ten_ext,
4207 bc_w_ext,
4208 0.0,//see above
4209 mom_vw_diff_ten_ext,
4210 grad_w_ext,
4211 w_ext,
4212 penalty,//ebqe_penalty_ext[ebNE_kb],
4213 flux_mom_vw_diff_ext);
4214 exteriorNumericalDiffusiveFlux(eps_rho,
4215 ebqe_phi_ext[ebNE_kb],
4216 sdInfo_w_u_rowptr.data(),
4217 sdInfo_w_u_colind.data(),
4218 isDOFBoundary_u[ebNE_kb],
4219 isDiffusiveFluxBoundary_u[ebNE_kb],
4220 normal,
4221 bc_mom_wu_diff_ten_ext,
4222 bc_u_ext,
4223 0.0,//see above
4224 mom_wu_diff_ten_ext,
4225 grad_u_ext,
4226 u_ext,
4227 penalty,//ebqe_penalty_ext[ebNE_kb],
4228 flux_mom_wu_diff_ext);
4229 exteriorNumericalDiffusiveFlux(eps_rho,
4230 ebqe_phi_ext[ebNE_kb],
4231 sdInfo_w_v_rowptr.data(),
4232 sdInfo_w_v_colind.data(),
4233 isDOFBoundary_v[ebNE_kb],
4234 isDiffusiveFluxBoundary_v[ebNE_kb],
4235 normal,
4236 bc_mom_wv_diff_ten_ext,
4237 bc_v_ext,
4238 0.0,//see above
4239 mom_wv_diff_ten_ext,
4240 grad_v_ext,
4241 v_ext,
4242 penalty,//ebqe_penalty_ext[ebNE_kb],
4243 flux_mom_wv_diff_ext);
4244 exteriorNumericalDiffusiveFlux(eps_rho,
4245 ebqe_phi_ext[ebNE_kb],
4246 sdInfo_w_w_rowptr.data(),
4247 sdInfo_w_w_colind.data(),
4248 isDOFBoundary_w[ebNE_kb],
4249 isDiffusiveFluxBoundary_w[ebNE_kb],
4250 normal,
4251 bc_mom_ww_diff_ten_ext,
4252 bc_w_ext,
4253 ebqe_bc_flux_w_diff_ext[ebNE_kb],
4254 mom_ww_diff_ten_ext,
4255 grad_w_ext,
4256 w_ext,
4257 penalty,//ebqe_penalty_ext[ebNE_kb],
4258 flux_mom_ww_diff_ext);
4259 flux[ebN*nQuadraturePoints_elementBoundary+kb] = flux_mass_ext;
4260 /* std::cout<<"external u,v,u_n " */
4261 /* <<ebqe_velocity[ebNE_kb_nSpace+0]<<'\t' */
4262 /* <<ebqe_velocity[ebNE_kb_nSpace+1]<<'\t' */
4263 /* <<flux[ebN*nQuadraturePoints_elementBoundary+kb]<<std::endl; */
4264 //
4265 //integrate the net force and moment on flagged boundaries
4266 //
4267 if (ebN < nElementBoundaries_owned)
4268 {
4269 force_v_x = (flux_mom_u_adv_ext + flux_mom_uu_diff_ext + flux_mom_uv_diff_ext + flux_mom_uw_diff_ext)/dmom_u_ham_grad_p_ext[0];//same as *rho
4270 force_v_y = (flux_mom_v_adv_ext + flux_mom_vu_diff_ext + flux_mom_vv_diff_ext + flux_mom_vw_diff_ext)/dmom_u_ham_grad_p_ext[0];
4271 force_v_z = (flux_mom_w_adv_ext + flux_mom_wu_diff_ext + flux_mom_wv_diff_ext + flux_mom_ww_diff_ext)/dmom_u_ham_grad_p_ext[0];
4272
4273 force_p_x = p_ext*normal[0];
4274 force_p_y = p_ext*normal[1];
4275 force_p_z = p_ext*normal[2];
4276
4277 force_x = force_p_x + force_v_x;
4278 force_y = force_p_y + force_v_y;
4279 force_z = force_p_z + force_v_z;
4280
4281 r_x = x_ext - barycenters[3*boundaryFlags[ebN]+0];
4282 r_y = y_ext - barycenters[3*boundaryFlags[ebN]+1];
4283 r_z = z_ext - barycenters[3*boundaryFlags[ebN]+2];
4284
4285 wettedAreas[boundaryFlags[ebN]] += dS*(1.0-ebqe_vf_ext[ebNE_kb]);
4286
4287 netForces_p[3*boundaryFlags[ebN]+0] += force_p_x*dS;
4288 netForces_p[3*boundaryFlags[ebN]+1] += force_p_y*dS;
4289 netForces_p[3*boundaryFlags[ebN]+2] += force_p_z*dS;
4290
4291 netForces_v[3*boundaryFlags[ebN]+0] += force_v_x*dS;
4292 netForces_v[3*boundaryFlags[ebN]+1] += force_v_y*dS;
4293 netForces_v[3*boundaryFlags[ebN]+2] += force_v_z*dS;
4294
4295 netMoments[3*boundaryFlags[ebN]+0] += (r_y*force_z - r_z*force_y)*dS;
4296 netMoments[3*boundaryFlags[ebN]+1] += (r_z*force_x - r_x*force_z)*dS;
4297 netMoments[3*boundaryFlags[ebN]+2] += (r_x*force_y - r_y*force_x)*dS;
4298 }
4299 //
4300 //update residuals
4301 //
4302 for (int i=0;i<nDOF_test_element;i++)
4303 {
4304 elementResidual_mesh[i] -= ck.ExteriorElementBoundaryFlux(MOVING_DOMAIN*(xt_ext*normal[0]+yt_ext*normal[1]+zt_ext*normal[2]),p_test_dS[i]);
4305 elementResidual_p[i] += ck.ExteriorElementBoundaryFlux(flux_mass_ext,p_test_dS[i]);
4306 elementResidual_p[i] -= DM*ck.ExteriorElementBoundaryFlux(MOVING_DOMAIN*(xt_ext*normal[0]+yt_ext*normal[1]+zt_ext*normal[2]),p_test_dS[i]);
4307 globalConservationError += ck.ExteriorElementBoundaryFlux(flux_mass_ext,p_test_dS[i]);
4308 elementResidual_u[i] +=
4309 (INT_BY_PARTS_PRESSURE==1 ? p_ext*vel_test_dS[i]*normal[0] : 0.) +
4310 ck.ExteriorElementBoundaryFlux(flux_mom_u_adv_ext,vel_test_dS[i])+
4311 ck.ExteriorElementBoundaryFlux(flux_mom_uu_diff_ext,vel_test_dS[i])+
4312 ck.ExteriorElementBoundaryFlux(flux_mom_uv_diff_ext,vel_test_dS[i])+
4313 ck.ExteriorElementBoundaryFlux(flux_mom_uw_diff_ext,vel_test_dS[i])+
4314 ck.ExteriorElementBoundaryDiffusionAdjoint(isDOFBoundary_u[ebNE_kb],
4315 isDiffusiveFluxBoundary_u[ebNE_kb],
4316 eb_adjoint_sigma,
4317 u_ext,
4318 bc_u_ext,
4319 normal,
4320 sdInfo_u_u_rowptr.data(),
4321 sdInfo_u_u_colind.data(),
4322 mom_uu_diff_ten_ext,
4323 &vel_grad_test_dS[i*nSpace])+
4324 ck.ExteriorElementBoundaryDiffusionAdjoint(isDOFBoundary_v[ebNE_kb],
4325 isDiffusiveFluxBoundary_u[ebNE_kb],
4326 eb_adjoint_sigma,
4327 v_ext,
4328 bc_v_ext,
4329 normal,
4330 sdInfo_u_v_rowptr.data(),
4331 sdInfo_u_v_colind.data(),
4332 mom_uv_diff_ten_ext,
4333 &vel_grad_test_dS[i*nSpace])+
4334 ck.ExteriorElementBoundaryDiffusionAdjoint(isDOFBoundary_w[ebNE_kb],
4335 isDiffusiveFluxBoundary_u[ebNE_kb],
4336 eb_adjoint_sigma,
4337 w_ext,
4338 bc_w_ext,
4339 normal,
4340 sdInfo_u_w_rowptr.data(),
4341 sdInfo_u_w_colind.data(),
4342 mom_uw_diff_ten_ext,
4343 &vel_grad_test_dS[i*nSpace]);
4344 elementResidual_v[i] +=
4345 (INT_BY_PARTS_PRESSURE==1 ? p_ext*vel_test_dS[i]*normal[1] : 0.) +
4346 ck.ExteriorElementBoundaryFlux(flux_mom_v_adv_ext,vel_test_dS[i]) +
4347 ck.ExteriorElementBoundaryFlux(flux_mom_vu_diff_ext,vel_test_dS[i])+
4348 ck.ExteriorElementBoundaryFlux(flux_mom_vv_diff_ext,vel_test_dS[i])+
4349 ck.ExteriorElementBoundaryFlux(flux_mom_vw_diff_ext,vel_test_dS[i])+
4350 ck.ExteriorElementBoundaryDiffusionAdjoint(isDOFBoundary_u[ebNE_kb],
4351 isDiffusiveFluxBoundary_v[ebNE_kb],
4352 eb_adjoint_sigma,
4353 u_ext,
4354 bc_u_ext,
4355 normal,
4356 sdInfo_v_u_rowptr.data(),
4357 sdInfo_v_u_colind.data(),
4358 mom_vu_diff_ten_ext,
4359 &vel_grad_test_dS[i*nSpace])+
4360 ck.ExteriorElementBoundaryDiffusionAdjoint(isDOFBoundary_v[ebNE_kb],
4361 isDiffusiveFluxBoundary_v[ebNE_kb],
4362 eb_adjoint_sigma,
4363 v_ext,
4364 bc_v_ext,
4365 normal,
4366 sdInfo_v_v_rowptr.data(),
4367 sdInfo_v_v_colind.data(),
4368 mom_vv_diff_ten_ext,
4369 &vel_grad_test_dS[i*nSpace])+
4370 ck.ExteriorElementBoundaryDiffusionAdjoint(isDOFBoundary_w[ebNE_kb],
4371 isDiffusiveFluxBoundary_v[ebNE_kb],
4372 eb_adjoint_sigma,
4373 w_ext,
4374 bc_w_ext,
4375 normal,
4376 sdInfo_v_w_rowptr.data(),
4377 sdInfo_v_w_colind.data(),
4378 mom_vw_diff_ten_ext,
4379 &vel_grad_test_dS[i*nSpace]);
4380
4381 elementResidual_w[i] +=
4382 (INT_BY_PARTS_PRESSURE==1 ? p_ext*vel_test_dS[i]*normal[2] : 0.) +
4383 ck.ExteriorElementBoundaryFlux(flux_mom_w_adv_ext,vel_test_dS[i]) +
4384 ck.ExteriorElementBoundaryFlux(flux_mom_wu_diff_ext,vel_test_dS[i])+
4385 ck.ExteriorElementBoundaryFlux(flux_mom_wv_diff_ext,vel_test_dS[i])+
4386 ck.ExteriorElementBoundaryFlux(flux_mom_ww_diff_ext,vel_test_dS[i])+
4387 ck.ExteriorElementBoundaryDiffusionAdjoint(isDOFBoundary_u[ebNE_kb],
4388 isDiffusiveFluxBoundary_w[ebNE_kb],
4389 eb_adjoint_sigma,
4390 u_ext,
4391 bc_u_ext,
4392 normal,
4393 sdInfo_w_u_rowptr.data(),
4394 sdInfo_w_u_colind.data(),
4395 mom_wu_diff_ten_ext,
4396 &vel_grad_test_dS[i*nSpace])+
4397 ck.ExteriorElementBoundaryDiffusionAdjoint(isDOFBoundary_v[ebNE_kb],
4398 isDiffusiveFluxBoundary_w[ebNE_kb],
4399 eb_adjoint_sigma,
4400 v_ext,
4401 bc_v_ext,
4402 normal,
4403 sdInfo_w_v_rowptr.data(),
4404 sdInfo_w_v_colind.data(),
4405 mom_wv_diff_ten_ext,
4406 &vel_grad_test_dS[i*nSpace])+
4407 ck.ExteriorElementBoundaryDiffusionAdjoint(isDOFBoundary_w[ebNE_kb],
4408 isDiffusiveFluxBoundary_w[ebNE_kb],
4409 eb_adjoint_sigma,
4410 w_ext,
4411 bc_w_ext,
4412 normal,
4413 sdInfo_w_w_rowptr.data(),
4414 sdInfo_w_w_colind.data(),
4415 mom_ww_diff_ten_ext,
4416 &vel_grad_test_dS[i*nSpace]);
4417 }//i
4418 }//kb
4419 //
4420 //update the element and global residual storage
4421 //
4422 for (int i=0;i<nDOF_test_element;i++)
4423 {
4424 int eN_i = eN*nDOF_test_element+i;
4425
4426 /* elementResidual_p_save[eN_i] += elementResidual_p[i]; */
4427 /* mesh_volume_conservation_weak += elementResidual_mesh[i]; */
4428 /* globalResidual[offset_p+stride_p*p_l2g[eN_i]]+=elementResidual_p[i]; */
4429 globalResidual[offset_u+stride_u*vel_l2g[eN_i]]+=elementResidual_u[i];
4430 globalResidual[offset_v+stride_v*vel_l2g[eN_i]]+=elementResidual_v[i];
4431 globalResidual[offset_w+stride_w*vel_l2g[eN_i]]+=elementResidual_w[i];
4432 }//i
4433 }//ebNE
4434 gf.useExact=useExact;
4435 gf_s.useExact=useExact;
4436 /* std::cout<<"mesh volume conservation = "<<mesh_volume_conservation<<std::endl; */
4437 /* std::cout<<"mesh volume conservation weak = "<<mesh_volume_conservation_weak<<std::endl; */
4438 /* std::cout<<"mesh volume conservation err max= "<<mesh_volume_conservation_err_max<<std::endl; */
4439 /* std::cout<<"mesh volume conservation err max weak = "<<mesh_volume_conservation_err_max_weak<<std::endl; */
4440 }
4441
4442
4443 void calculateJacobian(arguments_dict& args,
4444 bool useExact)
4445 {
4446 xt::pyarray<double>& mesh_trial_ref = args.array<double>("mesh_trial_ref");
4447 xt::pyarray<double>& mesh_grad_trial_ref = args.array<double>("mesh_grad_trial_ref");
4448 xt::pyarray<double>& mesh_dof = args.array<double>("mesh_dof");
4449 xt::pyarray<double>& mesh_velocity_dof = args.array<double>("mesh_velocity_dof");
4450 double MOVING_DOMAIN = args.scalar<double>("MOVING_DOMAIN");
4451 double PSTAB = args.scalar<double>("PSTAB");
4452 xt::pyarray<int>& mesh_l2g = args.array<int>("mesh_l2g");
4453 xt::pyarray<double>& x_ref = args.array<double>("x_ref");
4454 xt::pyarray<double>& dV_ref = args.array<double>("dV_ref");
4455 xt::pyarray<double>& p_trial_ref = args.array<double>("p_trial_ref");
4456 xt::pyarray<double>& p_grad_trial_ref = args.array<double>("p_grad_trial_ref");
4457 xt::pyarray<double>& p_test_ref = args.array<double>("p_test_ref");
4458 xt::pyarray<double>& p_grad_test_ref = args.array<double>("p_grad_test_ref");
4459 xt::pyarray<double>& q_p = args.array<double>("q_p");
4460 xt::pyarray<double>& q_grad_p = args.array<double>("q_grad_p");
4461 xt::pyarray<double>& ebqe_p = args.array<double>("ebqe_p");
4462 xt::pyarray<double>& ebqe_grad_p = args.array<double>("ebqe_grad_p");
4463 xt::pyarray<double>& vel_trial_ref = args.array<double>("vel_trial_ref");
4464 xt::pyarray<double>& vel_grad_trial_ref = args.array<double>("vel_grad_trial_ref");
4465 xt::pyarray<double>& vel_hess_trial_ref = args.array<double>("vel_hess_trial_ref");
4466 xt::pyarray<double>& vel_test_ref = args.array<double>("vel_test_ref");
4467 xt::pyarray<double>& vel_grad_test_ref = args.array<double>("vel_grad_test_ref");
4468 xt::pyarray<double>& mesh_trial_trace_ref = args.array<double>("mesh_trial_trace_ref");
4469 xt::pyarray<double>& mesh_grad_trial_trace_ref = args.array<double>("mesh_grad_trial_trace_ref");
4470 xt::pyarray<double>& dS_ref = args.array<double>("dS_ref");
4471 xt::pyarray<double>& p_trial_trace_ref = args.array<double>("p_trial_trace_ref");
4472 xt::pyarray<double>& p_grad_trial_trace_ref = args.array<double>("p_grad_trial_trace_ref");
4473 xt::pyarray<double>& p_test_trace_ref = args.array<double>("p_test_trace_ref");
4474 xt::pyarray<double>& p_grad_test_trace_ref = args.array<double>("p_grad_test_trace_ref");
4475 xt::pyarray<double>& vel_trial_trace_ref = args.array<double>("vel_trial_trace_ref");
4476 xt::pyarray<double>& vel_grad_trial_trace_ref = args.array<double>("vel_grad_trial_trace_ref");
4477 xt::pyarray<double>& vel_test_trace_ref = args.array<double>("vel_test_trace_ref");
4478 xt::pyarray<double>& vel_grad_test_trace_ref = args.array<double>("vel_grad_test_trace_ref");
4479 xt::pyarray<double>& normal_ref = args.array<double>("normal_ref");
4480 xt::pyarray<double>& boundaryJac_ref = args.array<double>("boundaryJac_ref");
4481 double eb_adjoint_sigma = args.scalar<double>("eb_adjoint_sigma");
4482 xt::pyarray<double>& elementDiameter = args.array<double>("elementDiameter");
4483 xt::pyarray<double>& nodeDiametersArray = args.array<double>("nodeDiametersArray");
4484 double hFactor = args.scalar<double>("hFactor");
4485 int nElements_global = args.scalar<int>("nElements_global");
4486 int nElements_owned = args.scalar<int>("nElements_owned");
4487 int nElementBoundaries_global = args.scalar<int>("nElementBoundaries_global");
4488 int nElementBoundaries_owned = args.scalar<int>("nElementBoundaries_owned");
4489 int nNodes_owned = args.scalar<int>("nNodes_owned");
4490 double useRBLES = args.scalar<double>("useRBLES");
4491 double useMetrics = args.scalar<double>("useMetrics");
4492 double alphaBDF = args.scalar<double>("alphaBDF");
4493 double epsFact_rho = args.scalar<double>("epsFact_rho");
4494 double epsFact_mu = args.scalar<double>("epsFact_mu");
4495 double sigma = args.scalar<double>("sigma");
4496 double rho_0 = args.scalar<double>("rho_0");
4497 double nu_0 = args.scalar<double>("nu_0");
4498 double rho_1 = args.scalar<double>("rho_1");
4499 double nu_1 = args.scalar<double>("nu_1");
4500 double smagorinskyConstant = args.scalar<double>("smagorinskyConstant");
4501 int turbulenceClosureModel = args.scalar<int>("turbulenceClosureModel");
4502 double Ct_sge = args.scalar<double>("Ct_sge");
4503 double Cd_sge = args.scalar<double>("Cd_sge");
4504 double C_dg = args.scalar<double>("C_dg");
4505 double C_b = args.scalar<double>("C_b");
4506 const xt::pyarray<double>& eps_solid = args.array<double>("eps_solid");
4507 const xt::pyarray<double>& ebq_global_phi_solid = args.array<double>("ebq_global_phi_solid");
4508 const xt::pyarray<double>& ebq_global_grad_phi_solid = args.array<double>("ebq_global_grad_phi_solid");
4509 const xt::pyarray<double>& ebq_particle_velocity_solid = args.array<double>("ebq_particle_velocity_solid");
4510 xt::pyarray<double>& phi_solid_nodes = args.array<double>("phi_solid_nodes");
4511 const xt::pyarray<double>& phi_solid = args.array<double>("phi_solid");
4512 const xt::pyarray<double>& q_velocity_solid = args.array<double>("q_velocity_solid");
4513 const xt::pyarray<double>& q_velocityStar_solid = args.array<double>("q_velocityStar_solid");
4514 const xt::pyarray<double>& q_vos = args.array<double>("q_vos");
4515 const xt::pyarray<double>& q_dvos_dt = args.array<double>("q_dvos_dt");
4516 const xt::pyarray<double>& q_grad_vos = args.array<double>("q_grad_vos");
4517 const xt::pyarray<double>& q_dragAlpha = args.array<double>("q_dragAlpha");
4518 const xt::pyarray<double>& q_dragBeta = args.array<double>("q_dragBeta");
4519 const xt::pyarray<double>& q_mass_source = args.array<double>("q_mass_source");
4520 const xt::pyarray<double>& q_turb_var_0 = args.array<double>("q_turb_var_0");
4521 const xt::pyarray<double>& q_turb_var_1 = args.array<double>("q_turb_var_1");
4522 const xt::pyarray<double>& q_turb_var_grad_0 = args.array<double>("q_turb_var_grad_0");
4523 xt::pyarray<int>& p_l2g = args.array<int>("p_l2g");
4524 xt::pyarray<int>& vel_l2g = args.array<int>("vel_l2g");
4525 xt::pyarray<double>& p_dof = args.array<double>("p_dof");
4526 xt::pyarray<double>& u_dof = args.array<double>("u_dof");
4527 xt::pyarray<double>& v_dof = args.array<double>("v_dof");
4528 xt::pyarray<double>& w_dof = args.array<double>("w_dof");
4529 xt::pyarray<double>& g = args.array<double>("g");
4530 const double useVF = args.scalar<double>("useVF");
4531 xt::pyarray<double>& vf = args.array<double>("vf");
4532 xt::pyarray<double>& phi = args.array<double>("phi");
4533 xt::pyarray<double>& phi_dof = args.array<double>("phi_dof");
4534 xt::pyarray<double>& normal_phi = args.array<double>("normal_phi");
4535 xt::pyarray<double>& kappa_phi = args.array<double>("kappa_phi");
4536 xt::pyarray<double>& q_mom_u_acc_beta_bdf = args.array<double>("q_mom_u_acc_beta_bdf");
4537 xt::pyarray<double>& q_mom_v_acc_beta_bdf = args.array<double>("q_mom_v_acc_beta_bdf");
4538 xt::pyarray<double>& q_mom_w_acc_beta_bdf = args.array<double>("q_mom_w_acc_beta_bdf");
4539 xt::pyarray<double>& q_dV = args.array<double>("q_dV");
4540 xt::pyarray<double>& q_dV_last = args.array<double>("q_dV_last");
4541 xt::pyarray<double>& q_velocity_sge = args.array<double>("q_velocity_sge");
4542 xt::pyarray<double>& ebqe_velocity_star = args.array<double>("ebqe_velocity_star");
4543 xt::pyarray<double>& q_cfl = args.array<double>("q_cfl");
4544 xt::pyarray<double>& q_numDiff_u_last = args.array<double>("q_numDiff_u_last");
4545 xt::pyarray<double>& q_numDiff_v_last = args.array<double>("q_numDiff_v_last");
4546 xt::pyarray<double>& q_numDiff_w_last = args.array<double>("q_numDiff_w_last");
4547 xt::pyarray<int>& sdInfo_u_u_rowptr = args.array<int>("sdInfo_u_u_rowptr");
4548 xt::pyarray<int>& sdInfo_u_u_colind = args.array<int>("sdInfo_u_u_colind");
4549 xt::pyarray<int>& sdInfo_u_v_rowptr = args.array<int>("sdInfo_u_v_rowptr");
4550 xt::pyarray<int>& sdInfo_u_v_colind = args.array<int>("sdInfo_u_v_colind");
4551 xt::pyarray<int>& sdInfo_u_w_rowptr = args.array<int>("sdInfo_u_w_rowptr");
4552 xt::pyarray<int>& sdInfo_u_w_colind = args.array<int>("sdInfo_u_w_colind");
4553 xt::pyarray<int>& sdInfo_v_v_rowptr = args.array<int>("sdInfo_v_v_rowptr");
4554 xt::pyarray<int>& sdInfo_v_v_colind = args.array<int>("sdInfo_v_v_colind");
4555 xt::pyarray<int>& sdInfo_v_u_rowptr = args.array<int>("sdInfo_v_u_rowptr");
4556 xt::pyarray<int>& sdInfo_v_u_colind = args.array<int>("sdInfo_v_u_colind");
4557 xt::pyarray<int>& sdInfo_v_w_rowptr = args.array<int>("sdInfo_v_w_rowptr");
4558 xt::pyarray<int>& sdInfo_v_w_colind = args.array<int>("sdInfo_v_w_colind");
4559 xt::pyarray<int>& sdInfo_w_w_rowptr = args.array<int>("sdInfo_w_w_rowptr");
4560 xt::pyarray<int>& sdInfo_w_w_colind = args.array<int>("sdInfo_w_w_colind");
4561 xt::pyarray<int>& sdInfo_w_u_rowptr = args.array<int>("sdInfo_w_u_rowptr");
4562 xt::pyarray<int>& sdInfo_w_u_colind = args.array<int>("sdInfo_w_u_colind");
4563 xt::pyarray<int>& sdInfo_w_v_rowptr = args.array<int>("sdInfo_w_v_rowptr");
4564 xt::pyarray<int>& sdInfo_w_v_colind = args.array<int>("sdInfo_w_v_colind");
4565 xt::pyarray<int>& csrRowIndeces_p_p = args.array<int>("csrRowIndeces_p_p");
4566 xt::pyarray<int>& csrColumnOffsets_p_p = args.array<int>("csrColumnOffsets_p_p");
4567 xt::pyarray<int>& csrRowIndeces_p_u = args.array<int>("csrRowIndeces_p_u");
4568 xt::pyarray<int>& csrColumnOffsets_p_u = args.array<int>("csrColumnOffsets_p_u");
4569 xt::pyarray<int>& csrRowIndeces_p_v = args.array<int>("csrRowIndeces_p_v");
4570 xt::pyarray<int>& csrColumnOffsets_p_v = args.array<int>("csrColumnOffsets_p_v");
4571 xt::pyarray<int>& csrRowIndeces_p_w = args.array<int>("csrRowIndeces_p_w");
4572 xt::pyarray<int>& csrColumnOffsets_p_w = args.array<int>("csrColumnOffsets_p_w");
4573 xt::pyarray<int>& csrRowIndeces_u_p = args.array<int>("csrRowIndeces_u_p");
4574 xt::pyarray<int>& csrColumnOffsets_u_p = args.array<int>("csrColumnOffsets_u_p");
4575 xt::pyarray<int>& csrRowIndeces_u_u = args.array<int>("csrRowIndeces_u_u");
4576 xt::pyarray<int>& csrColumnOffsets_u_u = args.array<int>("csrColumnOffsets_u_u");
4577 xt::pyarray<int>& csrRowIndeces_u_v = args.array<int>("csrRowIndeces_u_v");
4578 xt::pyarray<int>& csrColumnOffsets_u_v = args.array<int>("csrColumnOffsets_u_v");
4579 xt::pyarray<int>& csrRowIndeces_u_w = args.array<int>("csrRowIndeces_u_w");
4580 xt::pyarray<int>& csrColumnOffsets_u_w = args.array<int>("csrColumnOffsets_u_w");
4581 xt::pyarray<int>& csrRowIndeces_v_p = args.array<int>("csrRowIndeces_v_p");
4582 xt::pyarray<int>& csrColumnOffsets_v_p = args.array<int>("csrColumnOffsets_v_p");
4583 xt::pyarray<int>& csrRowIndeces_v_u = args.array<int>("csrRowIndeces_v_u");
4584 xt::pyarray<int>& csrColumnOffsets_v_u = args.array<int>("csrColumnOffsets_v_u");
4585 xt::pyarray<int>& csrRowIndeces_v_v = args.array<int>("csrRowIndeces_v_v");
4586 xt::pyarray<int>& csrColumnOffsets_v_v = args.array<int>("csrColumnOffsets_v_v");
4587 xt::pyarray<int>& csrRowIndeces_v_w = args.array<int>("csrRowIndeces_v_w");
4588 xt::pyarray<int>& csrColumnOffsets_v_w = args.array<int>("csrColumnOffsets_v_w");
4589 xt::pyarray<int>& csrRowIndeces_w_p = args.array<int>("csrRowIndeces_w_p");
4590 xt::pyarray<int>& csrColumnOffsets_w_p = args.array<int>("csrColumnOffsets_w_p");
4591 xt::pyarray<int>& csrRowIndeces_w_u = args.array<int>("csrRowIndeces_w_u");
4592 xt::pyarray<int>& csrColumnOffsets_w_u = args.array<int>("csrColumnOffsets_w_u");
4593 xt::pyarray<int>& csrRowIndeces_w_v = args.array<int>("csrRowIndeces_w_v");
4594 xt::pyarray<int>& csrColumnOffsets_w_v = args.array<int>("csrColumnOffsets_w_v");
4595 xt::pyarray<int>& csrRowIndeces_w_w = args.array<int>("csrRowIndeces_w_w");
4596 xt::pyarray<int>& csrColumnOffsets_w_w = args.array<int>("csrColumnOffsets_w_w");
4597 xt::pyarray<double>& globalJacobian = args.array<double>("globalJacobian");
4598 int nExteriorElementBoundaries_global = args.scalar<int>("nExteriorElementBoundaries_global");
4599 xt::pyarray<int>& exteriorElementBoundariesArray = args.array<int>("exteriorElementBoundariesArray");
4600 xt::pyarray<int>& elementBoundariesArray = args.array<int>("elementBoundariesArray");
4601 xt::pyarray<int>& elementBoundaryElementsArray = args.array<int>("elementBoundaryElementsArray");
4602 xt::pyarray<int>& elementBoundaryLocalElementBoundariesArray = args.array<int>("elementBoundaryLocalElementBoundariesArray");
4603 xt::pyarray<double>& ebqe_vf_ext = args.array<double>("ebqe_vf_ext");
4604 xt::pyarray<double>& bc_ebqe_vf_ext = args.array<double>("bc_ebqe_vf_ext");
4605 xt::pyarray<double>& ebqe_phi_ext = args.array<double>("ebqe_phi_ext");
4606 xt::pyarray<double>& bc_ebqe_phi_ext = args.array<double>("bc_ebqe_phi_ext");
4607 xt::pyarray<double>& ebqe_normal_phi_ext = args.array<double>("ebqe_normal_phi_ext");
4608 xt::pyarray<double>& ebqe_kappa_phi_ext = args.array<double>("ebqe_kappa_phi_ext");
4609 const xt::pyarray<double>& ebqe_vos_ext = args.array<double>("ebqe_vos_ext");
4610 const xt::pyarray<double>& ebqe_turb_var_0 = args.array<double>("ebqe_turb_var_0");
4611 const xt::pyarray<double>& ebqe_turb_var_1 = args.array<double>("ebqe_turb_var_1");
4612 xt::pyarray<int>& isDOFBoundary_p = args.array<int>("isDOFBoundary_p");
4613 xt::pyarray<int>& isDOFBoundary_u = args.array<int>("isDOFBoundary_u");
4614 xt::pyarray<int>& isDOFBoundary_v = args.array<int>("isDOFBoundary_v");
4615 xt::pyarray<int>& isDOFBoundary_w = args.array<int>("isDOFBoundary_w");
4616 xt::pyarray<int>& isAdvectiveFluxBoundary_p = args.array<int>("isAdvectiveFluxBoundary_p");
4617 xt::pyarray<int>& isAdvectiveFluxBoundary_u = args.array<int>("isAdvectiveFluxBoundary_u");
4618 xt::pyarray<int>& isAdvectiveFluxBoundary_v = args.array<int>("isAdvectiveFluxBoundary_v");
4619 xt::pyarray<int>& isAdvectiveFluxBoundary_w = args.array<int>("isAdvectiveFluxBoundary_w");
4620 xt::pyarray<int>& isDiffusiveFluxBoundary_u = args.array<int>("isDiffusiveFluxBoundary_u");
4621 xt::pyarray<int>& isDiffusiveFluxBoundary_v = args.array<int>("isDiffusiveFluxBoundary_v");
4622 xt::pyarray<int>& isDiffusiveFluxBoundary_w = args.array<int>("isDiffusiveFluxBoundary_w");
4623 xt::pyarray<double>& ebqe_bc_p_ext = args.array<double>("ebqe_bc_p_ext");
4624 xt::pyarray<double>& ebqe_bc_flux_mass_ext = args.array<double>("ebqe_bc_flux_mass_ext");
4625 xt::pyarray<double>& ebqe_bc_flux_mom_u_adv_ext = args.array<double>("ebqe_bc_flux_mom_u_adv_ext");
4626 xt::pyarray<double>& ebqe_bc_flux_mom_v_adv_ext = args.array<double>("ebqe_bc_flux_mom_v_adv_ext");
4627 xt::pyarray<double>& ebqe_bc_flux_mom_w_adv_ext = args.array<double>("ebqe_bc_flux_mom_w_adv_ext");
4628 xt::pyarray<double>& ebqe_bc_u_ext = args.array<double>("ebqe_bc_u_ext");
4629 xt::pyarray<double>& ebqe_bc_flux_u_diff_ext = args.array<double>("ebqe_bc_flux_u_diff_ext");
4630 xt::pyarray<double>& ebqe_penalty_ext = args.array<double>("ebqe_penalty_ext");
4631 xt::pyarray<double>& ebqe_bc_v_ext = args.array<double>("ebqe_bc_v_ext");
4632 xt::pyarray<double>& ebqe_bc_flux_v_diff_ext = args.array<double>("ebqe_bc_flux_v_diff_ext");
4633 xt::pyarray<double>& ebqe_bc_w_ext = args.array<double>("ebqe_bc_w_ext");
4634 xt::pyarray<double>& ebqe_bc_flux_w_diff_ext = args.array<double>("ebqe_bc_flux_w_diff_ext");
4635 xt::pyarray<int>& csrColumnOffsets_eb_p_p = args.array<int>("csrColumnOffsets_eb_p_p");
4636 xt::pyarray<int>& csrColumnOffsets_eb_p_u = args.array<int>("csrColumnOffsets_eb_p_u");
4637 xt::pyarray<int>& csrColumnOffsets_eb_p_v = args.array<int>("csrColumnOffsets_eb_p_v");
4638 xt::pyarray<int>& csrColumnOffsets_eb_p_w = args.array<int>("csrColumnOffsets_eb_p_w");
4639 xt::pyarray<int>& csrColumnOffsets_eb_u_p = args.array<int>("csrColumnOffsets_eb_u_p");
4640 xt::pyarray<int>& csrColumnOffsets_eb_u_u = args.array<int>("csrColumnOffsets_eb_u_u");
4641 xt::pyarray<int>& csrColumnOffsets_eb_u_v = args.array<int>("csrColumnOffsets_eb_u_v");
4642 xt::pyarray<int>& csrColumnOffsets_eb_u_w = args.array<int>("csrColumnOffsets_eb_u_w");
4643 xt::pyarray<int>& csrColumnOffsets_eb_v_p = args.array<int>("csrColumnOffsets_eb_v_p");
4644 xt::pyarray<int>& csrColumnOffsets_eb_v_u = args.array<int>("csrColumnOffsets_eb_v_u");
4645 xt::pyarray<int>& csrColumnOffsets_eb_v_v = args.array<int>("csrColumnOffsets_eb_v_v");
4646 xt::pyarray<int>& csrColumnOffsets_eb_v_w = args.array<int>("csrColumnOffsets_eb_v_w");
4647 xt::pyarray<int>& csrColumnOffsets_eb_w_p = args.array<int>("csrColumnOffsets_eb_w_p");
4648 xt::pyarray<int>& csrColumnOffsets_eb_w_u = args.array<int>("csrColumnOffsets_eb_w_u");
4649 xt::pyarray<int>& csrColumnOffsets_eb_w_v = args.array<int>("csrColumnOffsets_eb_w_v");
4650 xt::pyarray<int>& csrColumnOffsets_eb_w_w = args.array<int>("csrColumnOffsets_eb_w_w");
4651 xt::pyarray<int>& elementFlags = args.array<int>("elementFlags");
4652 int nParticles = args.scalar<int>("nParticles");
4653 double particle_epsFact = args.scalar<double>("particle_epsFact");
4654 double particle_alpha = args.scalar<double>("particle_alpha");
4655 double particle_beta = args.scalar<double>("particle_beta");
4656 double particle_penalty_constant = args.scalar<double>("particle_penalty_constant");
4657 xt::pyarray<double>& particle_signed_distances = args.array<double>("particle_signed_distances");
4658 xt::pyarray<double>& particle_signed_distance_normals = args.array<double>("particle_signed_distance_normals");
4659 xt::pyarray<double>& particle_velocities = args.array<double>("particle_velocities");
4660 xt::pyarray<double>& particle_centroids = args.array<double>("particle_centroids");
4661 double particle_nitsche = args.scalar<double>("particle_nitsche");
4662 int use_ball_as_particle = args.scalar<int>("use_ball_as_particle");
4663 xt::pyarray<double>& ball_center = args.array<double>("ball_center");
4664 xt::pyarray<double>& ball_radius = args.array<double>("ball_radius");
4665 xt::pyarray<double>& ball_velocity = args.array<double>("ball_velocity");
4666 xt::pyarray<double>& ball_angular_velocity = args.array<double>("ball_angular_velocity");
4667 int USE_SUPG = args.scalar<int>("USE_SUPG");
4668 int KILL_PRESSURE_TERM = args.scalar<int>("KILL_PRESSURE_TERM");
4669 double dt = args.scalar<double>("dt");
4670 int MATERIAL_PARAMETERS_AS_FUNCTION = args.scalar<int>("MATERIAL_PARAMETERS_AS_FUNCTION");
4671 xt::pyarray<double>& density_as_function = args.array<double>("density_as_function");
4672 xt::pyarray<double>& dynamic_viscosity_as_function = args.array<double>("dynamic_viscosity_as_function");
4673 xt::pyarray<double>& ebqe_density_as_function = args.array<double>("ebqe_density_as_function");
4674 xt::pyarray<double>& ebqe_dynamic_viscosity_as_function = args.array<double>("ebqe_dynamic_viscosity_as_function");
4675 int USE_SBM = args.scalar<int>("USE_SBM");
4676 int ARTIFICIAL_VISCOSITY = args.scalar<int>("ARTIFICIAL_VISCOSITY");
4677 xt::pyarray<double>& uStar_dMatrix = args.array<double>("uStar_dMatrix");
4678 xt::pyarray<double>& vStar_dMatrix = args.array<double>("vStar_dMatrix");
4679 xt::pyarray<double>& wStar_dMatrix = args.array<double>("wStar_dMatrix");
4680 int numDOFs_1D = args.scalar<int>("numDOFs_1D");
4681 int offset_u = args.scalar<int>("offset_u");
4682 int offset_v = args.scalar<int>("offset_v");
4683 int offset_w = args.scalar<int>("offset_w");
4684 int stride_u = args.scalar<int>("stride_u");
4685 int stride_v = args.scalar<int>("stride_v");
4686 int stride_w = args.scalar<int>("stride_w");
4687 xt::pyarray<int>& rowptr_1D = args.array<int>("rowptr_1D");
4688 xt::pyarray<int>& colind_1D = args.array<int>("colind_1D");
4689 xt::pyarray<int>& rowptr = args.array<int>("rowptr");
4690 xt::pyarray<int>& colind = args.array<int>("colind");
4691 int INT_BY_PARTS_PRESSURE = args.scalar<int>("INT_BY_PARTS_PRESSURE");
4692 //
4693 //loop over elements to compute volume integrals and load them into the element Jacobians and global Jacobian
4694 //
4695 std::valarray<double> particle_surfaceArea(nParticles), particle_netForces(nParticles * 3), particle_netMoments(nParticles * 3);
4696 const int nQuadraturePoints_global(nElements_global*nQuadraturePoints_element);
4697 for(int eN=0;eN<nElements_global;eN++)
4698 {
4699 double eps_rho,eps_mu;
4700 double element_active=1.0;//value 1 is because it is ibm by default
4701
4702 double elementJacobian_p_p[nDOF_test_element][nDOF_trial_element],
4703 elementJacobian_p_u[nDOF_test_element][nDOF_trial_element],
4704 elementJacobian_p_v[nDOF_test_element][nDOF_trial_element],
4705 elementJacobian_p_w[nDOF_test_element][nDOF_trial_element],
4706 elementJacobian_u_p[nDOF_test_element][nDOF_trial_element],
4707 elementJacobian_u_u[nDOF_test_element][nDOF_trial_element],
4708 elementJacobian_u_v[nDOF_test_element][nDOF_trial_element],
4709 elementJacobian_u_w[nDOF_test_element][nDOF_trial_element],
4710 elementJacobian_v_p[nDOF_test_element][nDOF_trial_element],
4711 elementJacobian_v_u[nDOF_test_element][nDOF_trial_element],
4712 elementJacobian_v_v[nDOF_test_element][nDOF_trial_element],
4713 elementJacobian_v_w[nDOF_test_element][nDOF_trial_element],
4714 elementJacobian_w_p[nDOF_test_element][nDOF_trial_element],
4715 elementJacobian_w_u[nDOF_test_element][nDOF_trial_element],
4716 elementJacobian_w_v[nDOF_test_element][nDOF_trial_element],
4717 elementJacobian_w_w[nDOF_test_element][nDOF_trial_element];
4718 for (int i=0;i<nDOF_test_element;i++)
4719 for (int j=0;j<nDOF_trial_element;j++)
4720 {
4721 elementJacobian_p_p[i][j]=0.0;
4722 elementJacobian_p_u[i][j]=0.0;
4723 elementJacobian_p_v[i][j]=0.0;
4724 elementJacobian_p_w[i][j]=0.0;
4725 elementJacobian_u_p[i][j]=0.0;
4726 elementJacobian_u_u[i][j]=0.0;
4727 elementJacobian_u_v[i][j]=0.0;
4728 elementJacobian_u_w[i][j]=0.0;
4729 elementJacobian_v_p[i][j]=0.0;
4730 elementJacobian_v_u[i][j]=0.0;
4731 elementJacobian_v_v[i][j]=0.0;
4732 elementJacobian_v_w[i][j]=0.0;
4733 elementJacobian_w_p[i][j]=0.0;
4734 elementJacobian_w_u[i][j]=0.0;
4735 elementJacobian_w_v[i][j]=0.0;
4736 elementJacobian_w_w[i][j]=0.0;
4737 }
4738 if(USE_SBM>0)
4739 {
4740 //
4741 //detect cut cells
4742 //
4743 double _distance[nDOF_mesh_trial_element]={0.0};
4744 int pos_counter=0;
4745 for (int I=0;I<nDOF_mesh_trial_element;I++)
4746 {
4747 if(use_ball_as_particle==1)
4748 {
4749 get_distance_to_ball(nParticles, ball_center.data(), ball_radius.data(),
4750 mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+I]+0],
4751 mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+I]+1],
4752 mesh_dof[3*mesh_l2g[eN*nDOF_mesh_trial_element+I]+2],
4753 _distance[I]);
4754 }
4755 else
4756 {
4757 _distance[I] = phi_solid_nodes[mesh_l2g[eN*nDOF_mesh_trial_element+I]];
4758 }
4759 if ( _distance[I] >= 0)
4760 pos_counter++;
4761 }
4762 if (pos_counter == 3)//surrogate face
4763 {
4764 element_active=0.0;
4765 int opp_node=-1;
4766 for (int I=0;I<nDOF_mesh_trial_element;I++)
4767 {
4768 if (_distance[I] < 0)
4769 opp_node = I;
4770 }
4771 assert(opp_node >=0);
4772 assert(opp_node <nDOF_mesh_trial_element);
4773 }
4774 else if (pos_counter == 4)// element is in fluid totally
4775 {
4776 element_active=1.0;
4777 }
4778 else
4779 {
4780 element_active=0.0;
4781 }
4782 }
4783 double element_phi[nDOF_mesh_trial_element], element_phi_s[nDOF_mesh_trial_element];
4784 for (int j=0;j<nDOF_mesh_trial_element;j++)
4785 {
4786 int eN_j = eN*nDOF_mesh_trial_element+j;
4787 element_phi[j] = phi_dof[p_l2g[eN_j]];
4788 element_phi_s[j] = phi_solid_nodes[p_l2g[eN_j]];
4789 }
4790 double element_nodes[nDOF_mesh_trial_element*3];
4791 for (int i=0;i<nDOF_mesh_trial_element;i++)
4792 {
4793 int eN_i=eN*nDOF_mesh_trial_element+i;
4794 for(int I=0;I<3;I++)
4795 element_nodes[i*3 + I] = mesh_dof[mesh_l2g[eN_i]*3 + I];
4796 }//i
4797 gf_s.calculate(element_phi_s, element_nodes, x_ref.data(), false);
4798 gf.calculate(element_phi, element_nodes, x_ref.data(), false);
4799 for (int k=0;k<nQuadraturePoints_element;k++)
4800 {
4801 gf.set_quad(k);
4802 gf_s.set_quad(k);
4803 int eN_k = eN*nQuadraturePoints_element+k, //index to a scalar at a quadrature point
4804 eN_k_nSpace = eN_k*nSpace,
4805 eN_nDOF_trial_element = eN*nDOF_trial_element; //index to a vector at a quadrature point
4806
4807 //declare local storage
4808 double p=0.0,u=0.0,v=0.0,w=0.0,
4809 grad_p[nSpace],grad_u[nSpace],grad_v[nSpace],grad_w[nSpace],
4810 hess_u[nSpace2],hess_v[nSpace2],hess_w[nSpace2],
4811 mom_u_acc=0.0,
4812 dmom_u_acc_u=0.0,
4813 mom_v_acc=0.0,
4814 dmom_v_acc_v=0.0,
4815 mom_w_acc=0.0,
4816 dmom_w_acc_w=0.0,
4817 mass_adv[nSpace],
4818 dmass_adv_u[nSpace],
4819 dmass_adv_v[nSpace],
4820 dmass_adv_w[nSpace],
4821 mom_u_adv[nSpace],
4822 dmom_u_adv_u[nSpace],
4823 dmom_u_adv_v[nSpace],
4824 dmom_u_adv_w[nSpace],
4825 mom_v_adv[nSpace],
4826 dmom_v_adv_u[nSpace],
4827 dmom_v_adv_v[nSpace],
4828 dmom_v_adv_w[nSpace],
4829 mom_w_adv[nSpace],
4830 dmom_w_adv_u[nSpace],
4831 dmom_w_adv_v[nSpace],
4832 dmom_w_adv_w[nSpace],
4833 mom_uu_diff_ten[nSpace],
4834 mom_vv_diff_ten[nSpace],
4835 mom_ww_diff_ten[nSpace],
4836 mom_uv_diff_ten[1],
4837 mom_uw_diff_ten[1],
4838 mom_vu_diff_ten[1],
4839 mom_vw_diff_ten[1],
4840 mom_wu_diff_ten[1],
4841 mom_wv_diff_ten[1],
4842 mom_u_source=0.0,
4843 mom_v_source=0.0,
4844 mom_w_source=0.0,
4845 mom_u_ham=0.0,
4846 dmom_u_ham_grad_p[nSpace],
4847 dmom_u_ham_grad_u[nSpace],
4848 mom_v_ham=0.0,
4849 dmom_v_ham_grad_p[nSpace],
4850 dmom_v_ham_grad_v[nSpace],
4851 mom_w_ham=0.0,
4852 dmom_w_ham_grad_p[nSpace],
4853 dmom_w_ham_grad_w[nSpace],
4854 mom_u_acc_t=0.0,
4855 dmom_u_acc_u_t=0.0,
4856 mom_v_acc_t=0.0,
4857 dmom_v_acc_v_t=0.0,
4858 mom_w_acc_t=0.0,
4859 dmom_w_acc_w_t=0.0,
4860 pdeResidual_p=0.0,
4861 pdeResidual_u=0.0,
4862 pdeResidual_v=0.0,
4863 pdeResidual_w=0.0,
4864 dpdeResidual_p_u[nDOF_trial_element],dpdeResidual_p_v[nDOF_trial_element],dpdeResidual_p_w[nDOF_trial_element],
4865 dpdeResidual_u_p[nDOF_trial_element],dpdeResidual_u_u[nDOF_trial_element],
4866 dpdeResidual_v_p[nDOF_trial_element],dpdeResidual_v_v[nDOF_trial_element],
4867 dpdeResidual_w_p[nDOF_trial_element],dpdeResidual_w_w[nDOF_trial_element],
4868 Lstar_u_p[nDOF_test_element],
4869 Lstar_v_p[nDOF_test_element],
4870 Lstar_w_p[nDOF_test_element],
4871 Lstar_u_u[nDOF_test_element],
4872 Lstar_v_v[nDOF_test_element],
4873 Lstar_w_w[nDOF_test_element],
4874 Lstar_p_u[nDOF_test_element],
4875 Lstar_p_v[nDOF_test_element],
4876 Lstar_p_w[nDOF_test_element],
4877 subgridError_p=0.0,
4878 subgridError_u=0.0,
4879 subgridError_v=0.0,
4880 subgridError_w=0.0,
4881 dsubgridError_p_u[nDOF_trial_element],
4882 dsubgridError_p_v[nDOF_trial_element],
4883 dsubgridError_p_w[nDOF_trial_element],
4884 dsubgridError_u_p[nDOF_trial_element],
4885 dsubgridError_u_u[nDOF_trial_element],
4886 dsubgridError_v_p[nDOF_trial_element],
4887 dsubgridError_v_v[nDOF_trial_element],
4888 dsubgridError_w_p[nDOF_trial_element],
4889 dsubgridError_w_w[nDOF_trial_element],
4890 tau_p=0.0,tau_p0=0.0,tau_p1=0.0,
4891 tau_v=0.0,tau_v0=0.0,tau_v1=0.0,
4892 jac[nSpace*nSpace],
4893 jacDet,
4894 jacInv[nSpace*nSpace],
4895 p_grad_trial[nDOF_trial_element*nSpace],vel_grad_trial[nDOF_trial_element*nSpace],
4896 vel_hess_trial[nDOF_trial_element*nSpace2],
4897 dV,
4898 p_test_dV[nDOF_test_element],vel_test_dV[nDOF_test_element],
4899 p_grad_test_dV[nDOF_test_element*nSpace],vel_grad_test_dV[nDOF_test_element*nSpace],
4900 x,y,z,xt,yt,zt,
4901 //VRANS
4902 porosity,
4903 //meanGrainSize,
4904 dmom_u_source[nSpace],
4905 dmom_v_source[nSpace],
4906 dmom_w_source[nSpace],
4907 mass_source,
4908 //
4909 G[nSpace*nSpace],G_dd_G,tr_G,h_phi, dmom_adv_star[nSpace], dmom_adv_sge[nSpace];
4910 //get jacobian, etc for mapping reference element
4911 ck.calculateMapping_element(eN,
4912 k,
4913 mesh_dof.data(),
4914 mesh_l2g.data(),
4915 mesh_trial_ref.data(),
4916 mesh_grad_trial_ref.data(),
4917 jac,
4918 jacDet,
4919 jacInv,
4920 x,y,z);
4921 ck.calculateH_element(eN,
4922 k,
4923 nodeDiametersArray.data(),
4924 mesh_l2g.data(),
4925 mesh_trial_ref.data(),
4926 h_phi);
4927 ck.calculateMappingVelocity_element(eN,
4928 k,
4929 mesh_velocity_dof.data(),
4930 mesh_l2g.data(),
4931 mesh_trial_ref.data(),
4932 xt,yt,zt);
4933 //xt=0.0;yt=0.0;zt=0.0;
4934 //std::cout<<"xt "<<xt<<'\t'<<yt<<'\t'<<zt<<std::endl;
4935 //get the physical integration weight
4936 dV = fabs(jacDet)*dV_ref[k];
4937 ck.calculateG(jacInv,G,G_dd_G,tr_G);
4938 //ck.calculateGScale(G,&normal_phi[eN_k_nSpace],h_phi);
4939
4940 eps_rho = epsFact_rho*(useMetrics*h_phi+(1.0-useMetrics)*elementDiameter[eN]);
4941 eps_mu = epsFact_mu *(useMetrics*h_phi+(1.0-useMetrics)*elementDiameter[eN]);
4942 const double particle_eps = particle_epsFact*(useMetrics*h_phi+(1.0-useMetrics)*elementDiameter[eN]);
4943
4944 //get the trial function gradients
4945 /* ck.gradTrialFromRef(&p_grad_trial_ref[k*nDOF_trial_element*nSpace],jacInv,p_grad_trial); */
4946 ck.gradTrialFromRef(&vel_grad_trial_ref[k*nDOF_trial_element*nSpace],jacInv,vel_grad_trial);
4947 ck.hessTrialFromRef(&vel_hess_trial_ref[k*nDOF_trial_element*nSpace2],jacInv,vel_hess_trial);
4948 //get the solution
4949 /* ck.valFromDOF(p_dof,&p_l2g[eN_nDOF_trial_element],&p_trial_ref[k*nDOF_trial_element],p); */
4950 p = q_p[eN_k];
4951 ck.valFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_ref[k*nDOF_trial_element],u);
4952 ck.valFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_ref[k*nDOF_trial_element],v);
4953 ck.valFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_ref[k*nDOF_trial_element],w);
4954 //get the solution gradients
4955 /* ck.gradFromDOF(p_dof,&p_l2g[eN_nDOF_trial_element],p_grad_trial,grad_p); */
4956 for (int I=0;I<nSpace;I++)
4957 grad_p[I] = q_grad_p[eN_k_nSpace+I];
4958 ck.gradFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial,grad_u);
4959 ck.gradFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial,grad_v);
4960 ck.gradFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial,grad_w);
4961 ck.hessFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_hess_trial,hess_u);
4962 ck.hessFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_hess_trial,hess_v);
4963 ck.hessFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_hess_trial,hess_w);
4964 //precalculate test function products with integration weights
4965 for (int j=0;j<nDOF_trial_element;j++)
4966 {
4967 /* p_test_dV[j] = p_test_ref[k*nDOF_trial_element+j]*dV; */
4968 vel_test_dV[j] = vel_test_ref[k*nDOF_trial_element+j]*dV;
4969 for (int I=0;I<nSpace;I++)
4970 {
4971 /* p_grad_test_dV[j*nSpace+I] = p_grad_trial[j*nSpace+I]*dV;//cek warning won't work for Petrov-Galerkin */
4972 vel_grad_test_dV[j*nSpace+I] = vel_grad_trial[j*nSpace+I]*dV;//cek warning won't work for Petrov-Galerkin}
4973 }
4974 }
4975 //cek hack
4976 double div_mesh_velocity=0.0;
4977 int NDOF_MESH_TRIAL_ELEMENT=4;
4978 for (int j=0;j<NDOF_MESH_TRIAL_ELEMENT;j++)
4979 {
4980 int eN_j=eN*NDOF_MESH_TRIAL_ELEMENT+j;
4981 div_mesh_velocity +=
4982 mesh_velocity_dof[mesh_l2g[eN_j]*3+0]*vel_grad_trial[j*3+0] +
4983 mesh_velocity_dof[mesh_l2g[eN_j]*3+1]*vel_grad_trial[j*3+1] +
4984 mesh_velocity_dof[mesh_l2g[eN_j]*3+2]*vel_grad_trial[j*3+2];
4985 }
4986 div_mesh_velocity = DM3*div_mesh_velocity + (1.0-DM3)*alphaBDF*(dV-q_dV_last[eN_k])/dV;
4987 //
4988 //VRANS
4989 porosity = 1.0 - q_vos[eN_k];
4990 //
4991 //
4992 //calculate pde coefficients and derivatives at quadrature points
4993 //
4994 double distance_to_omega_solid = phi_solid[eN_k];//computed in getResidual
4995 double eddy_viscosity(0.),rhoSave,nuSave;//not really interested in saving eddy_viscosity in jacobian
4996 evaluateCoefficients(eps_rho,
4997 eps_mu,
4998 particle_eps,
4999 sigma,
5000 rho_0,
5001 nu_0,
5002 rho_1,
5003 nu_1,
5004 elementDiameter[eN],
5005 smagorinskyConstant,
5006 turbulenceClosureModel,
5007 g.data(),
5008 useVF,
5009 vf[eN_k],
5010 phi[eN_k],
5011 &normal_phi[eN_k_nSpace],
5012 distance_to_omega_solid,
5013 kappa_phi[eN_k],
5014 //VRANS
5015 porosity,
5016 //
5017 p,
5018 grad_p,
5019 grad_u,
5020 grad_v,
5021 grad_w,
5022 u,
5023 v,
5024 w,
5025 q_velocity_sge[eN_k_nSpace+0],
5026 q_velocity_sge[eN_k_nSpace+1],
5027 q_velocity_sge[eN_k_nSpace+2],
5028 eddy_viscosity,
5029 mom_u_acc,
5030 dmom_u_acc_u,
5031 mom_v_acc,
5032 dmom_v_acc_v,
5033 mom_w_acc,
5034 dmom_w_acc_w,
5035 mass_adv,
5036 dmass_adv_u,
5037 dmass_adv_v,
5038 dmass_adv_w,
5039 mom_u_adv,
5040 dmom_u_adv_u,
5041 dmom_u_adv_v,
5042 dmom_u_adv_w,
5043 mom_v_adv,
5044 dmom_v_adv_u,
5045 dmom_v_adv_v,
5046 dmom_v_adv_w,
5047 mom_w_adv,
5048 dmom_w_adv_u,
5049 dmom_w_adv_v,
5050 dmom_w_adv_w,
5051 mom_uu_diff_ten,
5052 mom_vv_diff_ten,
5053 mom_ww_diff_ten,
5054 mom_uv_diff_ten,
5055 mom_uw_diff_ten,
5056 mom_vu_diff_ten,
5057 mom_vw_diff_ten,
5058 mom_wu_diff_ten,
5059 mom_wv_diff_ten,
5060 mom_u_source,
5061 mom_v_source,
5062 mom_w_source,
5063 mom_u_ham,
5064 dmom_u_ham_grad_p,
5065 dmom_u_ham_grad_u,
5066 mom_v_ham,
5067 dmom_v_ham_grad_p,
5068 dmom_v_ham_grad_v,
5069 mom_w_ham,
5070 dmom_w_ham_grad_p,
5071 dmom_w_ham_grad_w,
5072 rhoSave,
5073 nuSave,
5074 KILL_PRESSURE_TERM,
5075 0,
5076 0., // mql: the force term doesn't play a role in the Jacobian
5077 0.,
5078 0.,
5079 MATERIAL_PARAMETERS_AS_FUNCTION,
5080 density_as_function[eN_k],
5081 dynamic_viscosity_as_function[eN_k],
5082 USE_SBM,
5083 x,y,z,
5084 use_ball_as_particle,
5085 ball_center.data(),
5086 ball_radius.data(),
5087 ball_velocity.data(),
5088 ball_angular_velocity.data(),
5089 INT_BY_PARTS_PRESSURE);
5090 //VRANS
5091 mass_source = q_mass_source[eN_k];
5092 for (int I=0;I<nSpace;I++)
5093 {
5094 dmom_u_source[I] = 0.0;
5095 dmom_v_source[I] = 0.0;
5096 dmom_w_source[I] = 0.0;
5097 }
5098 updateDarcyForchheimerTerms_Ergun(/* linearDragFactor, */
5099 /* nonlinearDragFactor, */
5100 /* porosity, */
5101 /* meanGrainSize, */
5102 q_dragAlpha[eN_k],
5103 q_dragBeta[eN_k],
5104 eps_rho,
5105 eps_mu,
5106 rho_0,
5107 nu_0,
5108 rho_1,
5109 nu_1,
5110 eddy_viscosity,
5111 useVF,
5112 vf[eN_k],
5113 phi[eN_k],
5114 u,
5115 v,
5116 w,
5117 q_velocity_sge[eN_k_nSpace+0],
5118 q_velocity_sge[eN_k_nSpace+1],
5119 q_velocity_sge[eN_k_nSpace+2],
5120 eps_solid[elementFlags[eN]],
5121 porosity,
5122 q_velocity_solid[eN_k_nSpace+0],
5123 q_velocity_solid[eN_k_nSpace+1],
5124 q_velocity_solid[eN_k_nSpace+2],
5125 q_velocityStar_solid[eN_k_nSpace+0],
5126 q_velocityStar_solid[eN_k_nSpace+1],
5127 q_velocityStar_solid[eN_k_nSpace+2],
5128 mom_u_source,
5129 mom_v_source,
5130 mom_w_source,
5131 dmom_u_source,
5132 dmom_v_source,
5133 dmom_w_source,
5134 q_grad_vos[eN_k_nSpace+0],
5135 q_grad_vos[eN_k_nSpace+1],
5136 q_grad_vos[eN_k_nSpace+2]);
5137 double C_particles=0.0;
5138 if(nParticles > 0 && USE_SBM==0)
5139 updateSolidParticleTerms(eN < nElements_owned,
5140 particle_nitsche,
5141 dV,
5142 nParticles,
5143 nQuadraturePoints_global,
5144 &particle_signed_distances[eN_k],
5145 &particle_signed_distance_normals[eN_k_nSpace],
5146 &particle_velocities[eN_k_nSpace],
5147 particle_centroids.data(),
5148 use_ball_as_particle,
5149 ball_center.data(),
5150 ball_radius.data(),
5151 ball_velocity.data(),
5152 ball_angular_velocity.data(),
5153 porosity,
5154 particle_penalty_constant/h_phi,
5155 particle_alpha/h_phi,
5156 particle_beta/h_phi,
5157 eps_rho,
5158 eps_mu,
5159 rho_0,
5160 nu_0,
5161 rho_1,
5162 nu_1,
5163 useVF,
5164 vf[eN_k],
5165 phi[eN_k],
5166 x,
5167 y,
5168 z,
5169 p,
5170 u,
5171 v,
5172 w,
5173 q_velocity_sge[eN_k_nSpace+0],
5174 q_velocity_sge[eN_k_nSpace+1],
5175 q_velocity_sge[eN_k_nSpace+2],
5176 particle_eps,
5177 grad_u,
5178 grad_v,
5179 grad_w,
5180 mom_u_source,
5181 mom_v_source,
5182 mom_w_source,
5183 dmom_u_source,
5184 dmom_v_source,
5185 dmom_w_source,
5186 mom_u_adv,
5187 mom_v_adv,
5188 mom_w_adv,
5189 dmom_u_adv_u,
5190 dmom_v_adv_v,
5191 dmom_w_adv_w,
5192 mom_u_ham,
5193 dmom_u_ham_grad_u,
5194 mom_v_ham,
5195 dmom_v_ham_grad_v,
5196 mom_w_ham,
5197 dmom_w_ham_grad_w,
5198 &particle_netForces[0],
5199 &particle_netMoments[0],
5200 &particle_surfaceArea[0]);
5201 //Turbulence closure model
5202 if (turbulenceClosureModel >= 3)
5203 {
5204 const double c_mu = 0.09;//mwf hack
5205 updateTurbulenceClosure(turbulenceClosureModel,
5206 eps_rho,
5207 eps_mu,
5208 rho_0,
5209 nu_0,
5210 rho_1,
5211 nu_1,
5212 useVF,
5213 vf[eN_k],
5214 phi[eN_k],
5215 porosity,
5216 c_mu, //mwf hack
5217 q_turb_var_0[eN_k],
5218 q_turb_var_1[eN_k],
5219 &q_turb_var_grad_0[eN_k_nSpace],
5220 eddy_viscosity,
5221 mom_uu_diff_ten,
5222 mom_vv_diff_ten,
5223 mom_ww_diff_ten,
5224 mom_uv_diff_ten,
5225 mom_uw_diff_ten,
5226 mom_vu_diff_ten,
5227 mom_vw_diff_ten,
5228 mom_wu_diff_ten,
5229 mom_wv_diff_ten,
5230 mom_u_source,
5231 mom_v_source,
5232 mom_w_source);
5233
5234 }
5235 //
5236 //
5237 //moving mesh
5238 //
5239 mom_u_adv[0] -= MOVING_DOMAIN*dmom_u_acc_u*mom_u_acc*xt; // multiply by rho*porosity. mql. CHECK.
5240 mom_u_adv[1] -= MOVING_DOMAIN*dmom_u_acc_u*mom_u_acc*yt;
5241 mom_u_adv[2] -= MOVING_DOMAIN*dmom_u_acc_u*mom_u_acc*zt;
5242 dmom_u_adv_u[0] -= MOVING_DOMAIN*dmom_u_acc_u*xt;
5243 dmom_u_adv_u[1] -= MOVING_DOMAIN*dmom_u_acc_u*yt;
5244 dmom_u_adv_u[2] -= MOVING_DOMAIN*dmom_u_acc_u*zt;
5245
5246 mom_v_adv[0] -= MOVING_DOMAIN*dmom_v_acc_v*mom_v_acc*xt;
5247 mom_v_adv[1] -= MOVING_DOMAIN*dmom_v_acc_v*mom_v_acc*yt;
5248 mom_v_adv[2] -= MOVING_DOMAIN*dmom_v_acc_v*mom_v_acc*zt;
5249 dmom_v_adv_v[0] -= MOVING_DOMAIN*dmom_v_acc_v*xt;
5250 dmom_v_adv_v[1] -= MOVING_DOMAIN*dmom_v_acc_v*yt;
5251 dmom_v_adv_v[2] -= MOVING_DOMAIN*dmom_v_acc_v*zt;
5252
5253 mom_w_adv[0] -= MOVING_DOMAIN*dmom_w_acc_w*mom_w_acc*xt;
5254 mom_w_adv[1] -= MOVING_DOMAIN*dmom_w_acc_w*mom_w_acc*yt;
5255 mom_w_adv[2] -= MOVING_DOMAIN*dmom_w_acc_w*mom_w_acc*zt;
5256 dmom_w_adv_w[0] -= MOVING_DOMAIN*dmom_w_acc_w*xt;
5257 dmom_w_adv_w[1] -= MOVING_DOMAIN*dmom_w_acc_w*yt;
5258 dmom_w_adv_w[2] -= MOVING_DOMAIN*dmom_w_acc_w*zt;
5259 //
5260 //calculate time derivatives
5261 //
5262 ck.bdf(alphaBDF,
5263 q_mom_u_acc_beta_bdf[eN_k]*q_dV_last[eN_k]/dV,
5264 mom_u_acc,
5265 dmom_u_acc_u,
5266 mom_u_acc_t,
5267 dmom_u_acc_u_t);
5268 ck.bdf(alphaBDF,
5269 q_mom_v_acc_beta_bdf[eN_k]*q_dV_last[eN_k]/dV,
5270 mom_v_acc,
5271 dmom_v_acc_v,
5272 mom_v_acc_t,
5273 dmom_v_acc_v_t);
5274 ck.bdf(alphaBDF,
5275 q_mom_w_acc_beta_bdf[eN_k]*q_dV_last[eN_k]/dV,
5276 mom_w_acc,
5277 dmom_w_acc_w,
5278 mom_w_acc_t,
5279 dmom_w_acc_w_t);
5280
5281 mom_u_acc_t *= dmom_u_acc_u; //multiply by porosity*rho. mql. CHECK.
5282 mom_v_acc_t *= dmom_v_acc_v;
5283 mom_w_acc_t *= dmom_w_acc_w;
5284
5285 //
5286 //calculate subgrid error contribution to the Jacobian (strong residual, adjoint, jacobian of strong residual)
5287 //
5288 dmom_adv_sge[0] = dmom_u_acc_u*(q_velocity_sge[eN_k_nSpace+0] - MOVING_DOMAIN*xt);
5289 dmom_adv_sge[1] = dmom_u_acc_u*(q_velocity_sge[eN_k_nSpace+1] - MOVING_DOMAIN*yt);
5290 dmom_adv_sge[2] = dmom_u_acc_u*(q_velocity_sge[eN_k_nSpace+2] - MOVING_DOMAIN*zt);
5291 //
5292 //calculate strong residual
5293 //
5294 pdeResidual_p =
5295 ck.Mass_strong(-q_dvos_dt[eN_k]) + // mql. CHECK.
5296 ck.Advection_strong(dmass_adv_u,grad_u) +
5297 ck.Advection_strong(dmass_adv_v,grad_v) +
5298 ck.Advection_strong(dmass_adv_w,grad_w) +
5299 DM2*MOVING_DOMAIN*ck.Reaction_strong(alphaBDF*(dV-q_dV_last[eN_k])/dV - div_mesh_velocity) +
5300 //VRANS
5301 ck.Reaction_strong(mass_source);
5302 //
5303
5304 pdeResidual_u =
5305 ck.Mass_strong(mom_u_acc_t) +
5306 ck.Advection_strong(dmom_adv_sge,grad_u) +
5307 ck.Hamiltonian_strong(dmom_u_ham_grad_p,grad_p) +
5308 ck.Reaction_strong(mom_u_source) -
5309 ck.Reaction_strong(u*div_mesh_velocity);
5310
5311 pdeResidual_v =
5312 ck.Mass_strong(mom_v_acc_t) +
5313 ck.Advection_strong(dmom_adv_sge,grad_v) +
5314 ck.Hamiltonian_strong(dmom_v_ham_grad_p,grad_p) +
5315 ck.Reaction_strong(mom_v_source) -
5316 ck.Reaction_strong(v*div_mesh_velocity);
5317
5318 pdeResidual_w = ck.Mass_strong(mom_w_acc_t) +
5319 ck.Advection_strong(dmom_adv_sge,grad_w) +
5320 ck.Hamiltonian_strong(dmom_w_ham_grad_p,grad_p) +
5321 ck.Reaction_strong(mom_w_source) -
5322 ck.Reaction_strong(w*div_mesh_velocity);
5323
5324 //calculate the Jacobian of strong residual
5325 for (int j=0;j<nDOF_trial_element;j++)
5326 {
5327 int j_nSpace = j*nSpace;
5328 dpdeResidual_p_u[j]=ck.AdvectionJacobian_strong(dmass_adv_u,&vel_grad_trial[j_nSpace]);
5329 dpdeResidual_p_v[j]=ck.AdvectionJacobian_strong(dmass_adv_v,&vel_grad_trial[j_nSpace]);
5330 dpdeResidual_p_w[j]=ck.AdvectionJacobian_strong(dmass_adv_w,&vel_grad_trial[j_nSpace]);
5331
5332 dpdeResidual_u_p[j]=ck.HamiltonianJacobian_strong(dmom_u_ham_grad_p,&p_grad_trial[j_nSpace]);
5333 dpdeResidual_u_u[j]=ck.MassJacobian_strong(dmom_u_acc_u_t,vel_trial_ref[k*nDOF_trial_element+j]) +
5334 ck.AdvectionJacobian_strong(dmom_adv_sge,&vel_grad_trial[j_nSpace]) -
5335 ck.ReactionJacobian_strong(div_mesh_velocity,vel_trial_ref[k*nDOF_trial_element+j]);
5336
5337 dpdeResidual_v_p[j]=ck.HamiltonianJacobian_strong(dmom_v_ham_grad_p,&p_grad_trial[j_nSpace]);
5338 dpdeResidual_v_v[j]=ck.MassJacobian_strong(dmom_v_acc_v_t,vel_trial_ref[k*nDOF_trial_element+j]) +
5339 ck.AdvectionJacobian_strong(dmom_adv_sge,&vel_grad_trial[j_nSpace]) -
5340 ck.ReactionJacobian_strong(div_mesh_velocity,vel_trial_ref[k*nDOF_trial_element+j]);
5341
5342 dpdeResidual_w_p[j]=ck.HamiltonianJacobian_strong(dmom_w_ham_grad_p,&p_grad_trial[j_nSpace]);
5343 dpdeResidual_w_w[j]=ck.MassJacobian_strong(dmom_w_acc_w_t,vel_trial_ref[k*nDOF_trial_element+j]) +
5344 ck.AdvectionJacobian_strong(dmom_adv_sge,&vel_grad_trial[j_nSpace]) -
5345 ck.ReactionJacobian_strong(div_mesh_velocity,vel_trial_ref[k*nDOF_trial_element+j]);
5346
5347 //VRANS account for drag terms, diagonal only here ... decide if need off diagonal terms too
5348 dpdeResidual_u_u[j]+= ck.ReactionJacobian_strong(dmom_u_source[0],vel_trial_ref[k*nDOF_trial_element+j]);
5349 dpdeResidual_v_v[j]+= ck.ReactionJacobian_strong(dmom_v_source[1],vel_trial_ref[k*nDOF_trial_element+j]);
5350 dpdeResidual_w_w[j]+= ck.ReactionJacobian_strong(dmom_w_source[2],vel_trial_ref[k*nDOF_trial_element+j]);
5351 //
5352 }
5353 //calculate tau and tau*Res
5354 //cek debug
5355 double tmpR=dmom_u_acc_u_t + dmom_u_source[0];
5356 calculateSubgridError_tau(hFactor,
5357 elementDiameter[eN],
5358 tmpR,//dmom_u_acc_u_t,
5359 dmom_u_acc_u,
5360 dmom_adv_sge,
5361 mom_uu_diff_ten[1],
5362 dmom_u_ham_grad_p[0],
5363 tau_v0,
5364 tau_p0,
5365 q_cfl[eN_k]);
5366
5367 calculateSubgridError_tau(Ct_sge,Cd_sge,
5368 G,G_dd_G,tr_G,
5369 tmpR,//dmom_u_acc_u_t,
5370 dmom_adv_sge,
5371 mom_uu_diff_ten[1],
5372 dmom_u_ham_grad_p[0],
5373 tau_v1,
5374 tau_p1,
5375 q_cfl[eN_k]);
5376
5377
5378 tau_v = useMetrics*tau_v1+(1.0-useMetrics)*tau_v0;
5379 tau_p = KILL_PRESSURE_TERM == 1 ? 0. : PSTAB*(useMetrics*tau_p1+(1.0-useMetrics)*tau_p0);
5380 calculateSubgridError_tauRes(tau_p,
5381 tau_v,
5382 pdeResidual_p,
5383 pdeResidual_u,
5384 pdeResidual_v,
5385 pdeResidual_w,
5386 subgridError_p,
5387 subgridError_u,
5388 subgridError_v,
5389 subgridError_w);
5390
5391 calculateSubgridErrorDerivatives_tauRes(tau_p,
5392 tau_v,
5393 dpdeResidual_p_u,
5394 dpdeResidual_p_v,
5395 dpdeResidual_p_w,
5396 dpdeResidual_u_p,
5397 dpdeResidual_u_u,
5398 dpdeResidual_v_p,
5399 dpdeResidual_v_v,
5400 dpdeResidual_w_p,
5401 dpdeResidual_w_w,
5402 dsubgridError_p_u,
5403 dsubgridError_p_v,
5404 dsubgridError_p_w,
5405 dsubgridError_u_p,
5406 dsubgridError_u_u,
5407 dsubgridError_v_p,
5408 dsubgridError_v_v,
5409 dsubgridError_w_p,
5410 dsubgridError_w_w);
5411 // velocity used in adjoint (VMS or RBLES, with or without lagging the grid scale velocity)
5412 dmom_adv_star[0] = dmom_u_acc_u*(q_velocity_sge[eN_k_nSpace+0] - MOVING_DOMAIN*xt + useRBLES*subgridError_u);
5413 dmom_adv_star[1] = dmom_u_acc_u*(q_velocity_sge[eN_k_nSpace+1] - MOVING_DOMAIN*yt + useRBLES*subgridError_v);
5414 dmom_adv_star[2] = dmom_u_acc_u*(q_velocity_sge[eN_k_nSpace+2] - MOVING_DOMAIN*zt + useRBLES*subgridError_w);
5415
5416 //calculate the adjoint times the test functions
5417 for (int i=0;i<nDOF_test_element;i++)
5418 {
5419 int i_nSpace = i*nSpace;
5420 Lstar_u_p[i]=ck.Advection_adjoint(dmass_adv_u,&p_grad_test_dV[i_nSpace]);
5421 Lstar_v_p[i]=ck.Advection_adjoint(dmass_adv_v,&p_grad_test_dV[i_nSpace]);
5422 Lstar_w_p[i]=ck.Advection_adjoint(dmass_adv_w,&p_grad_test_dV[i_nSpace]);
5423 Lstar_u_u[i]=ck.Advection_adjoint(dmom_adv_star,&vel_grad_test_dV[i_nSpace]);
5424 Lstar_v_v[i]=ck.Advection_adjoint(dmom_adv_star,&vel_grad_test_dV[i_nSpace]);
5425 Lstar_w_w[i]=ck.Advection_adjoint(dmom_adv_star,&vel_grad_test_dV[i_nSpace]);
5426 Lstar_p_u[i]=ck.Hamiltonian_adjoint(dmom_u_ham_grad_p,&vel_grad_test_dV[i_nSpace]);
5427 Lstar_p_v[i]=ck.Hamiltonian_adjoint(dmom_v_ham_grad_p,&vel_grad_test_dV[i_nSpace]);
5428 Lstar_p_w[i]=ck.Hamiltonian_adjoint(dmom_w_ham_grad_p,&vel_grad_test_dV[i_nSpace]);
5429 //VRANS account for drag terms, diagonal only here ... decide if need off diagonal terms too
5430 Lstar_u_u[i]+=ck.Reaction_adjoint(dmom_u_source[0],vel_test_dV[i]);
5431 Lstar_v_v[i]+=ck.Reaction_adjoint(dmom_v_source[1],vel_test_dV[i]);
5432 Lstar_w_w[i]+=ck.Reaction_adjoint(dmom_w_source[2],vel_test_dV[i]);
5433 }
5434
5435 // Assumes non-lagged subgrid velocity
5436 dmom_u_adv_u[0] += dmom_u_acc_u*(useRBLES*subgridError_u);
5437 dmom_u_adv_u[1] += dmom_u_acc_u*(useRBLES*subgridError_v);
5438 dmom_u_adv_u[2] += dmom_u_acc_u*(useRBLES*subgridError_w);
5439
5440 dmom_v_adv_v[0] += dmom_u_acc_u*(useRBLES*subgridError_u);
5441 dmom_v_adv_v[1] += dmom_u_acc_u*(useRBLES*subgridError_v);
5442 dmom_v_adv_v[2] += dmom_u_acc_u*(useRBLES*subgridError_w);
5443
5444 dmom_w_adv_w[0] += dmom_u_acc_u*(useRBLES*subgridError_u);
5445 dmom_w_adv_w[1] += dmom_u_acc_u*(useRBLES*subgridError_v);
5446 dmom_w_adv_w[2] += dmom_u_acc_u*(useRBLES*subgridError_w);
5447
5448 // SURFACE TENSION //
5449 double unit_normal[nSpace];
5450 double norm_grad_phi = 0.;
5451 for (int I=0;I<nSpace;I++)
5452 norm_grad_phi += normal_phi[eN_k_nSpace+I]*normal_phi[eN_k_nSpace+I];
5453 norm_grad_phi = std::sqrt(norm_grad_phi) + 1E-10;
5454 for (int I=0;I<nSpace;I++)
5455 unit_normal[I] = normal_phi[eN_k_nSpace+I]/norm_grad_phi;
5456 double delta = gf.D(eps_mu,phi[eN_k]); //use eps_rho instead?
5457 double vel_tgrad_test_i[nSpace], vel_tgrad_test_j[nSpace];
5458 // END OF SURFACE TENSION //
5459
5460 //cek todo add RBLES terms consistent to residual modifications or ignore the partials w.r.t the additional RBLES terms
5461 for(int i=0;i<nDOF_test_element;i++)
5462 {
5463 int i_nSpace = i*nSpace;
5464 calculateTangentialGradient(unit_normal,
5465 &vel_grad_trial[i_nSpace],
5466 vel_tgrad_test_i);
5467 for(int j=0;j<nDOF_trial_element;j++)
5468 {
5469 int j_nSpace = j*nSpace;
5470 calculateTangentialGradient(unit_normal,
5471 &vel_grad_trial[j_nSpace],
5472 vel_tgrad_test_j);
5473
5474 /* elementJacobian_p_p[i][j] += ck.SubgridErrorJacobian(dsubgridError_u_p[j],Lstar_u_p[i]) + */
5475 /* ck.SubgridErrorJacobian(dsubgridError_v_p[j],Lstar_v_p[i]);// + */
5476 /* /\* ck.SubgridErrorJacobian(dsubgridError_w_p[j],Lstar_w_p[i]); *\/ */
5477
5478 /* elementJacobian_p_u[i][j] += ck.AdvectionJacobian_weak(dmass_adv_u,vel_trial_ref[k*nDOF_trial_element+j],&p_grad_test_dV[i_nSpace]) + */
5479 /* ck.SubgridErrorJacobian(dsubgridError_u_u[j],Lstar_u_p[i]); */
5480 /* elementJacobian_p_v[i][j] += ck.AdvectionJacobian_weak(dmass_adv_v,vel_trial_ref[k*nDOF_trial_element+j],&p_grad_test_dV[i_nSpace]) + */
5481 /* ck.SubgridErrorJacobian(dsubgridError_v_v[j],Lstar_v_p[i]); */
5482 /* elementJacobian_p_w[i][j] += ck.AdvectionJacobian_weak(dmass_adv_w,vel_trial_ref[k*nDOF_trial_element+j],&p_grad_test_dV[i_nSpace]) + */
5483 /* ck.SubgridErrorJacobian(dsubgridError_w_w[j],Lstar_w_p[i]); */
5484
5485 /* elementJacobian_u_p[i][j] += ck.HamiltonianJacobian_weak(dmom_u_ham_grad_p,&p_grad_trial[j_nSpace],vel_test_dV[i]) + */
5486 /* ck.SubgridErrorJacobian(dsubgridError_u_p[j],Lstar_u_u[i]); */
5487 elementJacobian_u_u[i][j] +=
5488 ck.MassJacobian_weak(dmom_u_acc_u_t,vel_trial_ref[k*nDOF_trial_element+j],vel_test_dV[i]) +
5489 ck.HamiltonianJacobian_weak(dmom_u_ham_grad_u,&vel_grad_trial[j_nSpace],vel_test_dV[i]) +
5490 ck.AdvectionJacobian_weak(dmom_u_adv_u,vel_trial_ref[k*nDOF_trial_element+j],&vel_grad_test_dV[i_nSpace]) +
5491 ck.SimpleDiffusionJacobian_weak(sdInfo_u_u_rowptr.data(),sdInfo_u_u_colind.data(),mom_uu_diff_ten,&vel_grad_trial[j_nSpace],&vel_grad_test_dV[i_nSpace]) +
5492 //VRANS
5493 ck.ReactionJacobian_weak(dmom_u_source[0],vel_trial_ref[k*nDOF_trial_element+j],vel_test_dV[i]) +
5494 //
5495 //ck.SubgridErrorJacobian(dsubgridError_p_u[j],Lstar_p_u[i]) +
5496 USE_SUPG*ck.SubgridErrorJacobian(dsubgridError_u_u[j],Lstar_u_u[i]) +
5497 ck.NumericalDiffusionJacobian(q_numDiff_u_last[eN_k],&vel_grad_trial[j_nSpace],&vel_grad_test_dV[i_nSpace]) +
5498 // surface tension
5499 ck.NumericalDiffusion(dt*delta*sigma*dV,
5500 vel_tgrad_test_i,
5501 vel_tgrad_test_j);
5502
5503 elementJacobian_u_v[i][j] +=
5504 ck.AdvectionJacobian_weak(dmom_u_adv_v,vel_trial_ref[k*nDOF_trial_element+j],&vel_grad_test_dV[i_nSpace]) +
5505 ck.SimpleDiffusionJacobian_weak(sdInfo_u_v_rowptr.data(),sdInfo_u_v_colind.data(),mom_uv_diff_ten,&vel_grad_trial[j_nSpace],&vel_grad_test_dV[i_nSpace]) +
5506 //VRANS
5507 ck.ReactionJacobian_weak(dmom_u_source[1],vel_trial_ref[k*nDOF_trial_element+j],vel_test_dV[i])
5508 //+ck.SubgridErrorJacobian(dsubgridError_p_v[j],Lstar_p_u[i])
5509 ;
5510 elementJacobian_u_w[i][j] +=
5511 ck.AdvectionJacobian_weak(dmom_u_adv_w,vel_trial_ref[k*nDOF_trial_element+j],&vel_grad_test_dV[i_nSpace]) +
5512 ck.SimpleDiffusionJacobian_weak(sdInfo_u_w_rowptr.data(),sdInfo_u_w_colind.data(),mom_uw_diff_ten,&vel_grad_trial[j_nSpace],&vel_grad_test_dV[i_nSpace]) +
5513 //VRANS
5514 ck.ReactionJacobian_weak(dmom_u_source[2],vel_trial_ref[k*nDOF_trial_element+j],vel_test_dV[i])
5515 //+ck.SubgridErrorJacobian(dsubgridError_p_w[j],Lstar_p_u[i])
5516 ;
5517
5518 /* elementJacobian_v_p[i][j] +=
5519 ck.HamiltonianJacobian_weak(dmom_v_ham_grad_p,&p_grad_trial[j_nSpace],vel_test_dV[i]) + */
5520 /* ck.SubgridErrorJacobian(dsubgridError_v_p[j],Lstar_v_v[i]); */
5521 elementJacobian_v_u[i][j] +=
5522 ck.AdvectionJacobian_weak(dmom_v_adv_u,vel_trial_ref[k*nDOF_trial_element+j],&vel_grad_test_dV[i_nSpace]) +
5523 ck.SimpleDiffusionJacobian_weak(sdInfo_v_u_rowptr.data(),sdInfo_v_u_colind.data(),mom_vu_diff_ten,&vel_grad_trial[j_nSpace],&vel_grad_test_dV[i_nSpace]) +
5524 //VRANS
5525 ck.ReactionJacobian_weak(dmom_v_source[0],vel_trial_ref[k*nDOF_trial_element+j],vel_test_dV[i])
5526 //+ck.SubgridErrorJacobian(dsubgridError_p_u[j],Lstar_p_v[i])
5527 ;
5528 elementJacobian_v_v[i][j] +=
5529 ck.MassJacobian_weak(dmom_v_acc_v_t,vel_trial_ref[k*nDOF_trial_element+j],vel_test_dV[i]) +
5530 ck.HamiltonianJacobian_weak(dmom_v_ham_grad_v,&vel_grad_trial[j_nSpace],vel_test_dV[i]) +
5531 ck.AdvectionJacobian_weak(dmom_v_adv_v,vel_trial_ref[k*nDOF_trial_element+j],&vel_grad_test_dV[i_nSpace]) +
5532 ck.SimpleDiffusionJacobian_weak(sdInfo_v_v_rowptr.data(),sdInfo_v_v_colind.data(),mom_vv_diff_ten,&vel_grad_trial[j_nSpace],&vel_grad_test_dV[i_nSpace]) +
5533 //VRANS
5534 ck.ReactionJacobian_weak(dmom_v_source[1],vel_trial_ref[k*nDOF_trial_element+j],vel_test_dV[i]) +
5535 //
5536 //ck.SubgridErrorJacobian(dsubgridError_p_v[j],Lstar_p_v[i]) +
5537 USE_SUPG*ck.SubgridErrorJacobian(dsubgridError_v_v[j],Lstar_v_v[i]) +
5538 ck.NumericalDiffusionJacobian(q_numDiff_v_last[eN_k],&vel_grad_trial[j_nSpace],&vel_grad_test_dV[i_nSpace]) +
5539 // surface tension
5540 ck.NumericalDiffusion(dt*delta*sigma*dV,
5541 vel_tgrad_test_i,
5542 vel_tgrad_test_j);
5543
5544 elementJacobian_v_w[i][j] +=
5545 ck.AdvectionJacobian_weak(dmom_v_adv_w,vel_trial_ref[k*nDOF_trial_element+j],&vel_grad_test_dV[i_nSpace]) +
5546 ck.SimpleDiffusionJacobian_weak(sdInfo_v_w_rowptr.data(),sdInfo_v_w_colind.data(),mom_vw_diff_ten,&vel_grad_trial[j_nSpace],&vel_grad_test_dV[i_nSpace]) +
5547 //VRANS
5548 ck.ReactionJacobian_weak(dmom_v_source[2],vel_trial_ref[k*nDOF_trial_element+j],vel_test_dV[i])
5549 //+ck.SubgridErrorJacobian(dsubgridError_p_w[j],Lstar_p_v[i])
5550 ;
5551
5552 /* elementJacobian_w_p[i][j] += ck.HamiltonianJacobian_weak(dmom_w_ham_grad_p,&p_grad_trial[j_nSpace],vel_test_dV[i]) + */
5553 /* ck.SubgridErrorJacobian(dsubgridError_w_p[j],Lstar_w_w[i]); */
5554 elementJacobian_w_u[i][j] +=
5555 ck.AdvectionJacobian_weak(dmom_w_adv_u,vel_trial_ref[k*nDOF_trial_element+j],&vel_grad_test_dV[i_nSpace]) +
5556 ck.SimpleDiffusionJacobian_weak(sdInfo_w_u_rowptr.data(),sdInfo_w_u_colind.data(),mom_wu_diff_ten,&vel_grad_trial[j_nSpace],&vel_grad_test_dV[i_nSpace]) +
5557 //VRANS
5558 ck.ReactionJacobian_weak(dmom_w_source[0],vel_trial_ref[k*nDOF_trial_element+j],vel_test_dV[i])
5559 //+ck.SubgridErrorJacobian(dsubgridError_p_u[j],Lstar_p_w[i])
5560 ;
5561 elementJacobian_w_v[i][j] +=
5562 ck.AdvectionJacobian_weak(dmom_w_adv_v,vel_trial_ref[k*nDOF_trial_element+j],&vel_grad_test_dV[i_nSpace]) +
5563 ck.SimpleDiffusionJacobian_weak(sdInfo_w_v_rowptr.data(),sdInfo_w_v_colind.data(),mom_wv_diff_ten,&vel_grad_trial[j_nSpace],&vel_grad_test_dV[i_nSpace]) +
5564 //VRANS
5565 ck.ReactionJacobian_weak(dmom_w_source[1],vel_trial_ref[k*nDOF_trial_element+j],vel_test_dV[i])
5566 //+ck.SubgridErrorJacobian(dsubgridError_p_v[j],Lstar_p_w[i])
5567 ;
5568 elementJacobian_w_w[i][j] +=
5569 ck.MassJacobian_weak(dmom_w_acc_w_t,vel_trial_ref[k*nDOF_trial_element+j],vel_test_dV[i]) +
5570 ck.HamiltonianJacobian_weak(dmom_w_ham_grad_w,&vel_grad_trial[j_nSpace],vel_test_dV[i]) +
5571 ck.AdvectionJacobian_weak(dmom_w_adv_w,vel_trial_ref[k*nDOF_trial_element+j],&vel_grad_test_dV[i_nSpace]) +
5572 ck.SimpleDiffusionJacobian_weak(sdInfo_w_w_rowptr.data(),sdInfo_w_w_colind.data(),mom_ww_diff_ten,&vel_grad_trial[j_nSpace],&vel_grad_test_dV[i_nSpace]) +
5573 //VRANS
5574 ck.ReactionJacobian_weak(dmom_w_source[2],vel_trial_ref[k*nDOF_trial_element+j],vel_test_dV[i]) +
5575 //
5576 //ck.SubgridErrorJacobian(dsubgridError_p_w[j],Lstar_p_w[i]) +
5577 USE_SUPG*ck.SubgridErrorJacobian(dsubgridError_w_w[j],Lstar_w_w[i]) +
5578 ck.NumericalDiffusionJacobian(q_numDiff_w_last[eN_k],&vel_grad_trial[j_nSpace],&vel_grad_test_dV[i_nSpace]) +
5579 // surface tension
5580 ck.NumericalDiffusion(dt*delta*sigma*dV,
5581 vel_tgrad_test_i,
5582 vel_tgrad_test_j);
5583 }//j
5584 }//i
5585 }//k
5586 //
5587 //load into element Jacobian into global Jacobian
5588 //
5589 for (int i=0;i<nDOF_test_element;i++)
5590 {
5591 int eN_i = eN*nDOF_test_element+i;
5592 for (int j=0;j<nDOF_trial_element;j++)
5593 {
5594 int eN_i_j = eN_i*nDOF_trial_element+j;
5595 /* globalJacobian[csrRowIndeces_p_p[eN_i] + csrColumnOffsets_p_p[eN_i_j]] += elementJacobian_p_p[i][j]; */
5596 /* globalJacobian[csrRowIndeces_p_u[eN_i] + csrColumnOffsets_p_u[eN_i_j]] += elementJacobian_p_u[i][j]; */
5597 /* globalJacobian[csrRowIndeces_p_v[eN_i] + csrColumnOffsets_p_v[eN_i_j]] += elementJacobian_p_v[i][j]; */
5598 /* globalJacobian[csrRowIndeces_p_w[eN_i] + csrColumnOffsets_p_w[eN_i_j]] += elementJacobian_p_w[i][j]; */
5599
5600 /* globalJacobian[csrRowIndeces_u_p[eN_i] + csrColumnOffsets_u_p[eN_i_j]] += elementJacobian_u_p[i][j]; */
5601 globalJacobian[csrRowIndeces_u_u[eN_i] + csrColumnOffsets_u_u[eN_i_j]] += element_active*elementJacobian_u_u[i][j];
5602 globalJacobian[csrRowIndeces_u_v[eN_i] + csrColumnOffsets_u_v[eN_i_j]] += element_active*elementJacobian_u_v[i][j];
5603 globalJacobian[csrRowIndeces_u_w[eN_i] + csrColumnOffsets_u_w[eN_i_j]] += element_active*elementJacobian_u_w[i][j];
5604
5605 /* globalJacobian[csrRowIndeces_v_p[eN_i] + csrColumnOffsets_v_p[eN_i_j]] += elementJacobian_v_p[i][j]; */
5606 globalJacobian[csrRowIndeces_v_u[eN_i] + csrColumnOffsets_v_u[eN_i_j]] += element_active*elementJacobian_v_u[i][j];
5607 globalJacobian[csrRowIndeces_v_v[eN_i] + csrColumnOffsets_v_v[eN_i_j]] += element_active*elementJacobian_v_v[i][j];
5608 globalJacobian[csrRowIndeces_v_w[eN_i] + csrColumnOffsets_v_w[eN_i_j]] += element_active*elementJacobian_v_w[i][j];
5609
5610 /* globalJacobian[csrRowIndeces_w_p[eN_i] + csrColumnOffsets_w_p[eN_i_j]] += elementJacobian_w_p[i][j]; */
5611 globalJacobian[csrRowIndeces_w_u[eN_i] + csrColumnOffsets_w_u[eN_i_j]] += element_active*elementJacobian_w_u[i][j];
5612 globalJacobian[csrRowIndeces_w_v[eN_i] + csrColumnOffsets_w_v[eN_i_j]] += element_active*elementJacobian_w_v[i][j];
5613 globalJacobian[csrRowIndeces_w_w[eN_i] + csrColumnOffsets_w_w[eN_i_j]] += element_active*elementJacobian_w_w[i][j];
5614 }//j
5615 }//i
5616 }//elements
5617
5618 // loop in DOFs for discrete upwinding
5619 if (ARTIFICIAL_VISCOSITY==3 || ARTIFICIAL_VISCOSITY==4)
5620 {
5621 int ij=0;
5622 for (int i=0; i<numDOFs_1D; i++)
5623 {
5624 // global index for each component
5625 int u_gi = offset_u+stride_u*i;
5626 int v_gi = offset_v+stride_v*i;
5627 int w_gi = offset_w+stride_w*i;
5628
5629 // pointer to first entry in the ith row for each component
5630 int u_ith_row_ptr = rowptr[u_gi];
5631 int v_ith_row_ptr = rowptr[v_gi];
5632 int w_ith_row_ptr = rowptr[w_gi];
5633
5634 // number of DOFs in the ith row (of the small matrix dMatrix)
5635 int numDOFs_ith_row = rowptr_1D[i+1]-rowptr_1D[i];
5636 for (int counter = 0; counter < numDOFs_ith_row; counter++)
5637 {
5638 // ij pointer for each component
5639 int uu_ij = u_ith_row_ptr + (offset_u + counter*stride_u);
5640 int vv_ij = v_ith_row_ptr + (offset_v + counter*stride_v);
5641 int ww_ij = w_ith_row_ptr + (offset_w + counter*stride_w);
5642
5643 // read ij component of dissipative matrix
5644 double uStar_dij = uStar_dMatrix[ij];
5645 double vStar_dij = vStar_dMatrix[ij];
5646 double wStar_dij = wStar_dMatrix[ij];
5647
5648 // update global Jacobian
5649 globalJacobian[uu_ij] -= uStar_dij;
5650 globalJacobian[vv_ij] -= vStar_dij;
5651 globalJacobian[ww_ij] -= wStar_dij;
5652
5653 // update ij
5654 ij++;
5655 }
5656 }
5657 }
5658
5659 //
5660 //loop over surrogate boundary
5661 //
5662 if(USE_SBM>0)
5663 {
5664 for (int ebN_s=0;ebN_s < surrogate_boundaries.size();ebN_s++)
5665 {
5666 int ebN = surrogate_boundaries[ebN_s],
5667 eN = elementBoundaryElementsArray[ebN*2+surrogate_boundary_elements[ebN_s]],
5668 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+surrogate_boundary_elements[ebN_s]],
5669 eN_nDOF_trial_element = eN*nDOF_trial_element;
5670 double eps_rho,eps_mu;
5671 for (int kb=0;kb<nQuadraturePoints_elementBoundary;kb++)
5672 {
5673 int ebN_kb = ebN*nQuadraturePoints_elementBoundary+kb,
5674 ebN_kb_nSpace = ebN_kb*nSpace,
5675 ebN_local_kb = ebN_local*nQuadraturePoints_elementBoundary+kb,
5676 ebN_local_kb_nSpace = ebN_local_kb*nSpace;
5677
5678 double u_ext=0.0,
5679 v_ext=0.0,
5680 w_ext=0.0,
5681 bc_u_ext=0.0,
5682 bc_v_ext=0.0,
5683 bc_w_ext=0.0,
5684 grad_u_ext[nSpace],
5685 grad_v_ext[nSpace],
5686 grad_w_ext[nSpace],
5687 jac_ext[nSpace*nSpace],
5688 jacDet_ext,
5689 jacInv_ext[nSpace*nSpace],
5690 boundaryJac[nSpace*(nSpace-1)],
5691 metricTensor[(nSpace-1)*(nSpace-1)],
5692 metricTensorDetSqrt,
5693 vel_grad_trial_trace[nDOF_trial_element*nSpace],
5694 dS,
5695 vel_test_dS[nDOF_test_element],
5696 normal[3],
5697 x_ext,y_ext,z_ext,xt_ext,yt_ext,zt_ext,integralScaling,
5698 vel_grad_test_dS[nDOF_trial_element*nSpace],
5699 G[nSpace*nSpace],G_dd_G,tr_G,h_phi,h_penalty,penalty;
5700 ck.calculateMapping_elementBoundary(eN,
5701 ebN_local,
5702 kb,
5703 ebN_local_kb,
5704 mesh_dof.data(),
5705 mesh_l2g.data(),
5706 mesh_trial_trace_ref.data(),
5707 mesh_grad_trial_trace_ref.data(),
5708 boundaryJac_ref.data(),
5709 jac_ext,
5710 jacDet_ext,
5711 jacInv_ext,
5712 boundaryJac,
5713 metricTensor,
5714 metricTensorDetSqrt,
5715 normal_ref.data(),
5716 normal,
5717 x_ext,y_ext,z_ext);
5718 ck.calculateMappingVelocity_elementBoundary(eN,
5719 ebN_local,
5720 kb,
5721 ebN_local_kb,
5722 mesh_velocity_dof.data(),
5723 mesh_l2g.data(),
5724 mesh_trial_trace_ref.data(),
5725 xt_ext,yt_ext,zt_ext,
5726 normal,
5727 boundaryJac,
5728 metricTensor,
5729 integralScaling);
5730 dS = metricTensorDetSqrt*dS_ref[kb];
5731 ck.calculateG(jacInv_ext,G,G_dd_G,tr_G);
5732 //compute shape and solution information
5733 //shape
5734 ck.gradTrialFromRef(&vel_grad_trial_trace_ref[ebN_local_kb_nSpace*nDOF_trial_element],jacInv_ext,vel_grad_trial_trace);
5735 //solution and gradients
5736 ck.valFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_trace_ref[ebN_local_kb*nDOF_test_element],u_ext);
5737 ck.valFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_trace_ref[ebN_local_kb*nDOF_test_element],v_ext);
5738 ck.valFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_trace_ref[ebN_local_kb*nDOF_test_element],w_ext);
5739
5740 ck.gradFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial_trace,grad_u_ext);
5741 ck.gradFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial_trace,grad_v_ext);
5742 ck.gradFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial_trace,grad_w_ext);
5743 //precalculate test function products with integration weights
5744 for (int j=0;j<nDOF_trial_element;j++)
5745 {
5746 vel_test_dS[j] = vel_test_trace_ref[ebN_local_kb*nDOF_test_element+j]*dS;
5747 for (int I=0;I<nSpace;I++)
5748 vel_grad_test_dS[j*nSpace+I] = vel_grad_trial_trace[j*nSpace+I]*dS;
5749 }
5750 //
5751 //load the boundary values
5752 //
5753 ck.calculateGScale(G,normal,h_penalty);
5754 penalty = h_penalty;
5755 //
5756 //update the global Jacobian from the flux Jacobian
5757 //
5758 double dist;
5759 double distance[3], P_normal[3], P_tangent[3]={0.0}; // distance vector, normal and tangent of the physical boundary
5760 if(use_ball_as_particle==1)
5761 {
5762 get_distance_to_ball(nParticles,ball_center.data(),ball_radius.data(),
5763 x_ext,y_ext,z_ext,
5764 dist);
5765 get_normal_to_ith_ball(nParticles,ball_center.data(),ball_radius.data(),
5766 surrogate_boundary_particle[ebN_s],
5767 x_ext,y_ext,z_ext,
5768 P_normal[0],P_normal[1],P_normal[2]);
5769 get_velocity_to_ith_ball(nParticles,ball_center.data(),ball_radius.data(),
5770 ball_velocity.data(),ball_angular_velocity.data(),
5771 surrogate_boundary_particle[ebN_s],
5772 x_ext-dist*P_normal[0],//corresponding point on the boundary of the particle
5773 y_ext-dist*P_normal[1],
5774 z_ext-dist*P_normal[2],
5775 bc_u_ext,bc_v_ext,bc_w_ext);
5776
5777 }
5778 else
5779 {
5780 dist = ebq_global_phi_solid[ebN_kb];
5781 P_normal[0] = ebq_global_grad_phi_solid[ebN_kb*nSpace+0];
5782 P_normal[1] = ebq_global_grad_phi_solid[ebN_kb*nSpace+1];
5783 P_normal[2] = ebq_global_grad_phi_solid[ebN_kb*nSpace+2];
5784 bc_u_ext = ebq_particle_velocity_solid [ebN_kb*nSpace+0];
5785 bc_v_ext = ebq_particle_velocity_solid [ebN_kb*nSpace+1];
5786 bc_w_ext = ebq_particle_velocity_solid [ebN_kb*nSpace+2];
5787 }
5788 distance[0] = -P_normal[0]*dist;//distance=vector from \tilde{x} to x. It holds also when dist<0.0
5789 distance[1] = -P_normal[1]*dist;
5790 distance[2] = -P_normal[2]*dist;
5791// P_tangent[0] = -P_normal[1];
5792// P_tangent[1] = P_normal[0];
5793// double tx = P_tangent[0] ; double ty = P_tangent[1];
5794 if(get_dot_product(P_normal,normal)>0)
5795 {
5796 // std::cout<<"YYPDB: some normal direction has wrong sign\n";
5797 for(int i=0;i<3;++i)
5798 {
5799 normal[i] *= -1.0;
5800 }
5801 }
5802 assert(h_penalty>0.0);
5803 if (h_penalty < std::abs(dist))
5804 h_penalty = std::abs(dist);
5805 //hack: this won't work for two-phase flow, need mixture viscosity
5806 double visco = nu_0*rho_0;
5807 double C_adim = C_sbm*visco/h_penalty;
5808 double beta_adim = beta_sbm*h_penalty*visco;
5809
5810 double res[3];
5811 const double zero_vec[3]={0.,0.,0.};
5812 for (int i=0;i<nDOF_test_element;i++)
5813 {
5814 int eN_i = eN*nDOF_test_element+i;
5815 double phi_i = vel_test_dS[i];
5816 double* grad_phi_i = &vel_grad_test_dS[i*nSpace+0];
5817 const double grad_phi_i_dot_d = get_dot_product(grad_phi_i,distance);
5818 for (int j=0;j<nDOF_trial_element;j++)
5819 {
5820 int ebN_i_j = ebN*4*nDOF_test_X_trial_element
5821 + surrogate_boundary_elements[ebN_s]*2*nDOF_test_X_trial_element
5822 + surrogate_boundary_elements[ebN_s]*nDOF_test_X_trial_element
5823 + i*nDOF_trial_element
5824 + j;
5825
5826 double phi_j = vel_test_dS[j]/dS;//since phi_i has dS
5827 const double grad_phi_j[3]={vel_grad_test_dS[j*nSpace+0]/dS,
5828 vel_grad_test_dS[j*nSpace+1]/dS,
5829 vel_grad_test_dS[j*nSpace+2]/dS};
5830 const double grad_phi_j_dot_d = get_dot_product(grad_phi_j,distance);
5831
5832 // Classical Nitsche
5833 // (1)
5834 globalJacobian[csrRowIndeces_u_u[eN_i] + csrColumnOffsets_eb_u_u[ebN_i_j]] +=
5835 phi_i*phi_j*C_adim;
5836 globalJacobian[csrRowIndeces_v_v[eN_i] + csrColumnOffsets_eb_v_v[ebN_i_j]] +=
5837 phi_i*phi_j*C_adim;
5838 globalJacobian[csrRowIndeces_w_w[eN_i] + csrColumnOffsets_eb_w_w[ebN_i_j]] +=
5839 phi_i*phi_j*C_adim;
5840 // (2)
5841 get_symmetric_gradient_dot_vec(grad_phi_j,zero_vec,zero_vec,normal,res);
5842 globalJacobian[csrRowIndeces_u_u[eN_i] + csrColumnOffsets_eb_u_u[ebN_i_j]] -=
5843 visco * phi_i * res[0];
5844 globalJacobian[csrRowIndeces_u_v[eN_i] + csrColumnOffsets_eb_u_v[ebN_i_j]] -=
5845 visco * phi_i * res[1];
5846 globalJacobian[csrRowIndeces_u_w[eN_i] + csrColumnOffsets_eb_u_w[ebN_i_j]] -=
5847 visco * phi_i * res[2];
5848
5849 get_symmetric_gradient_dot_vec(zero_vec,grad_phi_j,zero_vec,normal,res);
5850 globalJacobian[csrRowIndeces_v_u[eN_i] + csrColumnOffsets_eb_v_u[ebN_i_j]] -=
5851 visco * phi_i * res[0] ;
5852 globalJacobian[csrRowIndeces_v_v[eN_i] + csrColumnOffsets_eb_v_v[ebN_i_j]] -=
5853 visco * phi_i * res[1];
5854 globalJacobian[csrRowIndeces_v_w[eN_i] + csrColumnOffsets_eb_v_w[ebN_i_j]] -=
5855 visco * phi_i * res[2];
5856
5857 get_symmetric_gradient_dot_vec(zero_vec,zero_vec,grad_phi_j,normal,res);
5858 globalJacobian[csrRowIndeces_w_u[eN_i] + csrColumnOffsets_eb_w_u[ebN_i_j]] -=
5859 visco * phi_i * res[0] ;
5860 globalJacobian[csrRowIndeces_w_v[eN_i] + csrColumnOffsets_eb_w_v[ebN_i_j]] -=
5861 visco * phi_i * res[1];
5862 globalJacobian[csrRowIndeces_w_w[eN_i] + csrColumnOffsets_eb_w_w[ebN_i_j]] -=
5863 visco * phi_i * res[2];
5864
5865 // (3)
5866 get_symmetric_gradient_dot_vec(grad_phi_i,zero_vec,zero_vec,normal,res);
5867 globalJacobian[csrRowIndeces_u_u[eN_i] + csrColumnOffsets_eb_u_u[ebN_i_j]] -=
5868 visco * phi_j * res[0];
5869 globalJacobian[csrRowIndeces_u_v[eN_i] + csrColumnOffsets_eb_u_v[ebN_i_j]] -=
5870 visco * phi_j * res[1];
5871 globalJacobian[csrRowIndeces_u_w[eN_i] + csrColumnOffsets_eb_u_w[ebN_i_j]] -=
5872 visco * phi_j * res[2];
5873
5874 get_symmetric_gradient_dot_vec(zero_vec,grad_phi_i,zero_vec,normal,res);
5875 globalJacobian[csrRowIndeces_v_u[eN_i] + csrColumnOffsets_eb_v_u[ebN_i_j]] -=
5876 visco * phi_j * res[0] ;
5877 globalJacobian[csrRowIndeces_v_v[eN_i] + csrColumnOffsets_eb_v_v[ebN_i_j]] -=
5878 visco * phi_j * res[1];
5879 globalJacobian[csrRowIndeces_v_w[eN_i] + csrColumnOffsets_eb_v_w[ebN_i_j]] -=
5880 visco * phi_j * res[2];
5881
5882 get_symmetric_gradient_dot_vec(zero_vec,zero_vec,grad_phi_i,normal,res);
5883 globalJacobian[csrRowIndeces_w_u[eN_i] + csrColumnOffsets_eb_w_u[ebN_i_j]] -=
5884 visco * phi_j * res[0] ;
5885 globalJacobian[csrRowIndeces_w_v[eN_i] + csrColumnOffsets_eb_w_v[ebN_i_j]] -=
5886 visco * phi_j * res[1];
5887 globalJacobian[csrRowIndeces_w_w[eN_i] + csrColumnOffsets_eb_w_w[ebN_i_j]] -=
5888 visco * phi_j * res[2];
5889
5890 // (4)
5891 globalJacobian[csrRowIndeces_u_u[eN_i] + csrColumnOffsets_eb_u_u[ebN_i_j]] +=
5892 C_adim*grad_phi_i_dot_d*phi_j;
5893 globalJacobian[csrRowIndeces_v_v[eN_i] + csrColumnOffsets_eb_v_v[ebN_i_j]] +=
5894 C_adim*grad_phi_i_dot_d*phi_j;
5895 globalJacobian[csrRowIndeces_w_w[eN_i] + csrColumnOffsets_eb_w_w[ebN_i_j]] +=
5896 C_adim*grad_phi_i_dot_d*phi_j;
5897 // (5)
5898 globalJacobian[csrRowIndeces_u_u[eN_i] + csrColumnOffsets_eb_u_u[ebN_i_j]] +=
5899 C_adim*grad_phi_i_dot_d*grad_phi_j_dot_d;
5900 globalJacobian[csrRowIndeces_v_v[eN_i] + csrColumnOffsets_eb_v_v[ebN_i_j]] +=
5901 C_adim*grad_phi_i_dot_d*grad_phi_j_dot_d;
5902 globalJacobian[csrRowIndeces_w_w[eN_i] + csrColumnOffsets_eb_w_w[ebN_i_j]] +=
5903 C_adim*grad_phi_i_dot_d*grad_phi_j_dot_d;
5904 // (6)
5905 globalJacobian[csrRowIndeces_u_u[eN_i] + csrColumnOffsets_eb_u_u[ebN_i_j]] +=
5906 C_adim*grad_phi_j_dot_d*phi_i;
5907 globalJacobian[csrRowIndeces_v_v[eN_i] + csrColumnOffsets_eb_v_v[ebN_i_j]] +=
5908 C_adim*grad_phi_j_dot_d*phi_i;
5909 globalJacobian[csrRowIndeces_w_w[eN_i] + csrColumnOffsets_eb_w_w[ebN_i_j]] +=
5910 C_adim*grad_phi_j_dot_d*phi_i;
5911 // (7)
5912 get_symmetric_gradient_dot_vec(grad_phi_i,zero_vec,zero_vec,normal,res);
5913 globalJacobian[csrRowIndeces_u_u[eN_i] + csrColumnOffsets_eb_u_u[ebN_i_j]] -=
5914 visco * grad_phi_j_dot_d * res[0];
5915 globalJacobian[csrRowIndeces_u_v[eN_i] + csrColumnOffsets_eb_u_v[ebN_i_j]] -=
5916 visco * grad_phi_j_dot_d * res[1];
5917 globalJacobian[csrRowIndeces_u_w[eN_i] + csrColumnOffsets_eb_u_w[ebN_i_j]] -=
5918 visco * grad_phi_j_dot_d * res[2];
5919
5920 get_symmetric_gradient_dot_vec(zero_vec,grad_phi_i,zero_vec,normal,res);
5921 globalJacobian[csrRowIndeces_v_u[eN_i] + csrColumnOffsets_eb_v_u[ebN_i_j]] -=
5922 visco * grad_phi_j_dot_d * res[0] ;
5923 globalJacobian[csrRowIndeces_v_v[eN_i] + csrColumnOffsets_eb_v_v[ebN_i_j]] -=
5924 visco * grad_phi_j_dot_d * res[1];
5925 globalJacobian[csrRowIndeces_v_w[eN_i] + csrColumnOffsets_eb_v_w[ebN_i_j]] -=
5926 visco * grad_phi_j_dot_d * res[2];
5927
5928 get_symmetric_gradient_dot_vec(zero_vec,zero_vec,grad_phi_i,normal,res);
5929 globalJacobian[csrRowIndeces_w_u[eN_i] + csrColumnOffsets_eb_w_u[ebN_i_j]] -=
5930 visco * grad_phi_j_dot_d * res[0] ;
5931 globalJacobian[csrRowIndeces_w_v[eN_i] + csrColumnOffsets_eb_w_v[ebN_i_j]] -=
5932 visco * grad_phi_j_dot_d * res[1];
5933 globalJacobian[csrRowIndeces_w_w[eN_i] + csrColumnOffsets_eb_w_w[ebN_i_j]] -=
5934 visco * grad_phi_j_dot_d * res[2];
5935
5936 // the penalization on the tangential derivative
5937 // B < Gw t , (Gu - GuD) t >
5938// // diag
5939// globalJacobian[csrRowIndeces_u_u[eN_i] + csrColumnOffsets_eb_u_u[ebN_i_j]] +=
5940// beta_adim*(tx*Gxphi_i+ ty*Gyphi_i)*(tx*Gxphi_j+ ty*Gyphi_j);
5941// globalJacobian[csrRowIndeces_v_v[eN_i] + csrColumnOffsets_eb_v_v[ebN_i_j]] +=
5942// beta_adim*(tx*Gxphi_i+ ty*Gyphi_i)*(tx*Gxphi_j+ ty*Gyphi_j);
5943 // // extra diag
5944 // globalJacobian[csrRowIndeces_u_v[eN_i] + csrColumnOffsets_eb_u_v[ebN_i_j]] +=
5945 // beta_adim*tx*(Gxphi_i*ty*Gxphi_j + Gyphi_i*ty*Gyphi_j);
5946 // globalJacobian[csrRowIndeces_v_u[eN_i] + csrColumnOffsets_eb_v_u[ebN_i_j]] +=
5947 // beta_adim*ty*(Gxphi_i*tx*Gxphi_j + Gyphi_i*tx*Gyphi_j);
5948
5949 }//j
5950 }//i
5951
5952 }//kb
5953 }//ebN_s
5954 }//if USE_SBM
5955 //
5956 //loop over exterior element boundaries to compute the surface integrals and load them into the global Jacobian
5957 //
5958 //exact generalized function integration not implemented for boundaries yet
5959 gf.useExact=false;
5960 gf_s.useExact=false;
5961 for (int ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
5962 {
5963 int ebN = exteriorElementBoundariesArray[ebNE],
5964 eN = elementBoundaryElementsArray[ebN*2+0],
5965 eN_nDOF_trial_element = eN*nDOF_trial_element,
5966 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0];
5967 double eps_rho,eps_mu;
5968 for (int kb=0;kb<nQuadraturePoints_elementBoundary;kb++)
5969 {
5970 int ebNE_kb = ebNE*nQuadraturePoints_elementBoundary+kb,
5971 ebNE_kb_nSpace = ebNE_kb*nSpace,
5972 ebN_local_kb = ebN_local*nQuadraturePoints_elementBoundary+kb,
5973 ebN_local_kb_nSpace = ebN_local_kb*nSpace;
5974
5975 double p_ext=0.0,
5976 u_ext=0.0,
5977 v_ext=0.0,
5978 w_ext=0.0,
5979 grad_p_ext[nSpace],
5980 grad_u_ext[nSpace],
5981 grad_v_ext[nSpace],
5982 grad_w_ext[nSpace],
5983 mom_u_acc_ext=0.0,
5984 dmom_u_acc_u_ext=0.0,
5985 mom_v_acc_ext=0.0,
5986 dmom_v_acc_v_ext=0.0,
5987 mom_w_acc_ext=0.0,
5988 dmom_w_acc_w_ext=0.0,
5989 mass_adv_ext[nSpace],
5990 dmass_adv_u_ext[nSpace],
5991 dmass_adv_v_ext[nSpace],
5992 dmass_adv_w_ext[nSpace],
5993 mom_u_adv_ext[nSpace],
5994 dmom_u_adv_u_ext[nSpace],
5995 dmom_u_adv_v_ext[nSpace],
5996 dmom_u_adv_w_ext[nSpace],
5997 mom_v_adv_ext[nSpace],
5998 dmom_v_adv_u_ext[nSpace],
5999 dmom_v_adv_v_ext[nSpace],
6000 dmom_v_adv_w_ext[nSpace],
6001 mom_w_adv_ext[nSpace],
6002 dmom_w_adv_u_ext[nSpace],
6003 dmom_w_adv_v_ext[nSpace],
6004 dmom_w_adv_w_ext[nSpace],
6005 mom_uu_diff_ten_ext[nSpace],
6006 mom_vv_diff_ten_ext[nSpace],
6007 mom_ww_diff_ten_ext[nSpace],
6008 mom_uv_diff_ten_ext[1],
6009 mom_uw_diff_ten_ext[1],
6010 mom_vu_diff_ten_ext[1],
6011 mom_vw_diff_ten_ext[1],
6012 mom_wu_diff_ten_ext[1],
6013 mom_wv_diff_ten_ext[1],
6014 mom_u_source_ext=0.0,
6015 mom_v_source_ext=0.0,
6016 mom_w_source_ext=0.0,
6017 mom_u_ham_ext=0.0,
6018 dmom_u_ham_grad_p_ext[nSpace],
6019 dmom_u_ham_grad_u_ext[nSpace],
6020 mom_v_ham_ext=0.0,
6021 dmom_v_ham_grad_p_ext[nSpace],
6022 dmom_v_ham_grad_v_ext[nSpace],
6023 mom_w_ham_ext=0.0,
6024 dmom_w_ham_grad_p_ext[nSpace],
6025 dmom_w_ham_grad_w_ext[nSpace],
6026 dmom_u_adv_p_ext[nSpace],
6027 dmom_v_adv_p_ext[nSpace],
6028 dmom_w_adv_p_ext[nSpace],
6029 dflux_mass_u_ext=0.0,
6030 dflux_mass_v_ext=0.0,
6031 dflux_mass_w_ext=0.0,
6032 dflux_mom_u_adv_p_ext=0.0,
6033 dflux_mom_u_adv_u_ext=0.0,
6034 dflux_mom_u_adv_v_ext=0.0,
6035 dflux_mom_u_adv_w_ext=0.0,
6036 dflux_mom_v_adv_p_ext=0.0,
6037 dflux_mom_v_adv_u_ext=0.0,
6038 dflux_mom_v_adv_v_ext=0.0,
6039 dflux_mom_v_adv_w_ext=0.0,
6040 dflux_mom_w_adv_p_ext=0.0,
6041 dflux_mom_w_adv_u_ext=0.0,
6042 dflux_mom_w_adv_v_ext=0.0,
6043 dflux_mom_w_adv_w_ext=0.0,
6044 bc_p_ext=0.0,
6045 bc_u_ext=0.0,
6046 bc_v_ext=0.0,
6047 bc_w_ext=0.0,
6048 bc_mom_u_acc_ext=0.0,
6049 bc_dmom_u_acc_u_ext=0.0,
6050 bc_mom_v_acc_ext=0.0,
6051 bc_dmom_v_acc_v_ext=0.0,
6052 bc_mom_w_acc_ext=0.0,
6053 bc_dmom_w_acc_w_ext=0.0,
6054 bc_mass_adv_ext[nSpace],
6055 bc_dmass_adv_u_ext[nSpace],
6056 bc_dmass_adv_v_ext[nSpace],
6057 bc_dmass_adv_w_ext[nSpace],
6058 bc_mom_u_adv_ext[nSpace],
6059 bc_dmom_u_adv_u_ext[nSpace],
6060 bc_dmom_u_adv_v_ext[nSpace],
6061 bc_dmom_u_adv_w_ext[nSpace],
6062 bc_mom_v_adv_ext[nSpace],
6063 bc_dmom_v_adv_u_ext[nSpace],
6064 bc_dmom_v_adv_v_ext[nSpace],
6065 bc_dmom_v_adv_w_ext[nSpace],
6066 bc_mom_w_adv_ext[nSpace],
6067 bc_dmom_w_adv_u_ext[nSpace],
6068 bc_dmom_w_adv_v_ext[nSpace],
6069 bc_dmom_w_adv_w_ext[nSpace],
6070 bc_mom_uu_diff_ten_ext[nSpace],
6071 bc_mom_vv_diff_ten_ext[nSpace],
6072 bc_mom_ww_diff_ten_ext[nSpace],
6073 bc_mom_uv_diff_ten_ext[1],
6074 bc_mom_uw_diff_ten_ext[1],
6075 bc_mom_vu_diff_ten_ext[1],
6076 bc_mom_vw_diff_ten_ext[1],
6077 bc_mom_wu_diff_ten_ext[1],
6078 bc_mom_wv_diff_ten_ext[1],
6079 bc_mom_u_source_ext=0.0,
6080 bc_mom_v_source_ext=0.0,
6081 bc_mom_w_source_ext=0.0,
6082 bc_mom_u_ham_ext=0.0,
6083 bc_dmom_u_ham_grad_p_ext[nSpace],
6084 bc_dmom_u_ham_grad_u_ext[nSpace],
6085 bc_mom_v_ham_ext=0.0,
6086 bc_dmom_v_ham_grad_p_ext[nSpace],
6087 bc_dmom_v_ham_grad_v_ext[nSpace],
6088 bc_mom_w_ham_ext=0.0,
6089 bc_dmom_w_ham_grad_p_ext[nSpace],
6090 bc_dmom_w_ham_grad_w_ext[nSpace],
6091 fluxJacobian_p_p[nDOF_trial_element],
6092 fluxJacobian_p_u[nDOF_trial_element],
6093 fluxJacobian_p_v[nDOF_trial_element],
6094 fluxJacobian_p_w[nDOF_trial_element],
6095 fluxJacobian_u_p[nDOF_trial_element],
6096 fluxJacobian_u_u[nDOF_trial_element],
6097 fluxJacobian_u_v[nDOF_trial_element],
6098 fluxJacobian_u_w[nDOF_trial_element],
6099 fluxJacobian_v_p[nDOF_trial_element],
6100 fluxJacobian_v_u[nDOF_trial_element],
6101 fluxJacobian_v_v[nDOF_trial_element],
6102 fluxJacobian_v_w[nDOF_trial_element],
6103 fluxJacobian_w_p[nDOF_trial_element],
6104 fluxJacobian_w_u[nDOF_trial_element],
6105 fluxJacobian_w_v[nDOF_trial_element],
6106 fluxJacobian_w_w[nDOF_trial_element],
6107 jac_ext[nSpace*nSpace],
6108 jacDet_ext,
6109 jacInv_ext[nSpace*nSpace],
6110 boundaryJac[nSpace*(nSpace-1)],
6111 metricTensor[(nSpace-1)*(nSpace-1)],
6112 metricTensorDetSqrt,
6113 p_grad_trial_trace[nDOF_trial_element*nSpace],
6114 vel_grad_trial_trace[nDOF_trial_element*nSpace],
6115 dS,
6116 p_test_dS[nDOF_test_element],
6117 vel_test_dS[nDOF_test_element],
6118 normal[3],
6119 x_ext,y_ext,z_ext,xt_ext,yt_ext,zt_ext,integralScaling,
6120 vel_grad_test_dS[nDOF_trial_element*nSpace],
6121 //VRANS
6122 porosity_ext,
6123 //
6124 G[nSpace*nSpace],G_dd_G,tr_G,h_phi,h_penalty,penalty;
6125 ck.calculateMapping_elementBoundary(eN,
6126 ebN_local,
6127 kb,
6128 ebN_local_kb,
6129 mesh_dof.data(),
6130 mesh_l2g.data(),
6131 mesh_trial_trace_ref.data(),
6132 mesh_grad_trial_trace_ref.data(),
6133 boundaryJac_ref.data(),
6134 jac_ext,
6135 jacDet_ext,
6136 jacInv_ext,
6137 boundaryJac,
6138 metricTensor,
6139 metricTensorDetSqrt,
6140 normal_ref.data(),
6141 normal,
6142 x_ext,y_ext,z_ext);
6143 ck.calculateMappingVelocity_elementBoundary(eN,
6144 ebN_local,
6145 kb,
6146 ebN_local_kb,
6147 mesh_velocity_dof.data(),
6148 mesh_l2g.data(),
6149 mesh_trial_trace_ref.data(),
6150 xt_ext,yt_ext,zt_ext,
6151 normal,
6152 boundaryJac,
6153 metricTensor,
6154 integralScaling);
6155 //dS = ((1.0-MOVING_DOMAIN)*metricTensorDetSqrt + MOVING_DOMAIN*integralScaling)*dS_ref[kb];
6156 dS = metricTensorDetSqrt*dS_ref[kb];
6157 ck.calculateG(jacInv_ext,G,G_dd_G,tr_G);
6158 ck.calculateGScale(G,&ebqe_normal_phi_ext[ebNE_kb_nSpace],h_phi);
6159
6160 eps_rho = epsFact_rho*(useMetrics*h_phi+(1.0-useMetrics)*elementDiameter[eN]);
6161 eps_mu = epsFact_mu *(useMetrics*h_phi+(1.0-useMetrics)*elementDiameter[eN]);
6162 const double particle_eps = particle_epsFact * (useMetrics * h_phi + (1.0 - useMetrics) * elementDiameter[eN]);
6163
6164 //compute shape and solution information
6165 //shape
6166 /* ck.gradTrialFromRef(&p_grad_trial_trace_ref[ebN_local_kb_nSpace*nDOF_trial_element],jacInv_ext,p_grad_trial_trace); */
6167 ck.gradTrialFromRef(&vel_grad_trial_trace_ref[ebN_local_kb_nSpace*nDOF_trial_element],jacInv_ext,vel_grad_trial_trace);
6168 //solution and gradients
6169 /* ck.valFromDOF(p_dof,&p_l2g[eN_nDOF_trial_element],&p_trial_trace_ref[ebN_local_kb*nDOF_test_element],p_ext); */
6170 p_ext = ebqe_p[ebNE_kb];
6171 ck.valFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_trace_ref[ebN_local_kb*nDOF_test_element],u_ext);
6172 ck.valFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_trace_ref[ebN_local_kb*nDOF_test_element],v_ext);
6173 ck.valFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],&vel_trial_trace_ref[ebN_local_kb*nDOF_test_element],w_ext);
6174 /* ck.gradFromDOF(p_dof,&p_l2g[eN_nDOF_trial_element],p_grad_trial_trace,grad_p_ext); */
6175 for (int I=0;I<nSpace;I++)
6176 grad_p_ext[I] = ebqe_grad_p[ebNE_kb_nSpace+I];
6177 ck.gradFromDOF(u_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial_trace,grad_u_ext);
6178 ck.gradFromDOF(v_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial_trace,grad_v_ext);
6179 ck.gradFromDOF(w_dof.data(),&vel_l2g[eN_nDOF_trial_element],vel_grad_trial_trace,grad_w_ext);
6180 //precalculate test function products with integration weights
6181 for (int j=0;j<nDOF_trial_element;j++)
6182 {
6183 /* p_test_dS[j] = p_test_trace_ref[ebN_local_kb*nDOF_test_element+j]*dS; */
6184 vel_test_dS[j] = vel_test_trace_ref[ebN_local_kb*nDOF_test_element+j]*dS;
6185 for (int I=0;I<nSpace;I++)
6186 vel_grad_test_dS[j*nSpace+I] = vel_grad_trial_trace[j*nSpace+I]*dS;//cek hack, using trial
6187 }
6188 //
6189 //load the boundary values
6190 //
6191 bc_p_ext = isDOFBoundary_p[ebNE_kb]*ebqe_bc_p_ext[ebNE_kb]+(1-isDOFBoundary_p[ebNE_kb])*p_ext;
6192 //bc values at moving boundaries are specified relative to boundary motion so we need to add it here
6193 bc_u_ext = isDOFBoundary_u[ebNE_kb]*(ebqe_bc_u_ext[ebNE_kb] + MOVING_DOMAIN*xt_ext) + (1-isDOFBoundary_u[ebNE_kb])*u_ext;
6194 bc_v_ext = isDOFBoundary_v[ebNE_kb]*(ebqe_bc_v_ext[ebNE_kb] + MOVING_DOMAIN*yt_ext) + (1-isDOFBoundary_v[ebNE_kb])*v_ext;
6195 bc_w_ext = isDOFBoundary_w[ebNE_kb]*(ebqe_bc_w_ext[ebNE_kb] + MOVING_DOMAIN*zt_ext) + (1-isDOFBoundary_w[ebNE_kb])*w_ext;
6196 //VRANS
6197 porosity_ext = 1.0 - ebqe_vos_ext[ebNE_kb];
6198 //
6199 //calculate the internal and external trace of the pde coefficients
6200 //
6201 double distance_to_omega_solid = 1e10;
6202 if (use_ball_as_particle == 1)
6203 {
6204 get_distance_to_ball(nParticles, ball_center.data(), ball_radius.data(), x_ext, y_ext, z_ext, distance_to_omega_solid);
6205 }
6206 else
6207 {
6208 for (int i = 0; i < nParticles; i++)
6209 {
6210 double distance_to_i_th_solid = ebq_global_phi_solid[i * nElementBoundaries_global * nQuadraturePoints_elementBoundary + ebNE_kb];
6211 distance_to_omega_solid = (distance_to_i_th_solid < distance_to_omega_solid)?distance_to_i_th_solid:distance_to_omega_solid;
6212 }
6213 }
6214 double eddy_viscosity_ext(0.),bc_eddy_viscosity_ext(0.),rhoSave, nuSave;//not interested in saving boundary eddy viscosity for now
6215 evaluateCoefficients(eps_rho,
6216 eps_mu,
6217 particle_eps,
6218 sigma,
6219 rho_0,
6220 nu_0,
6221 rho_1,
6222 nu_1,
6223 elementDiameter[eN],
6224 smagorinskyConstant,
6225 turbulenceClosureModel,
6226 g.data(),
6227 useVF,
6228 ebqe_vf_ext[ebNE_kb],
6229 ebqe_phi_ext[ebNE_kb],
6230 &ebqe_normal_phi_ext[ebNE_kb_nSpace],
6231 distance_to_omega_solid,
6232 ebqe_kappa_phi_ext[ebNE_kb],
6233 //VRANS
6234 porosity_ext,
6235 //
6236 p_ext,
6237 grad_p_ext,
6238 grad_u_ext,
6239 grad_v_ext,
6240 grad_w_ext,
6241 u_ext,
6242 v_ext,
6243 w_ext,
6244 ebqe_velocity_star[ebNE_kb_nSpace+0],
6245 ebqe_velocity_star[ebNE_kb_nSpace+1],
6246 ebqe_velocity_star[ebNE_kb_nSpace+2],
6247 eddy_viscosity_ext,
6248 mom_u_acc_ext,
6249 dmom_u_acc_u_ext,
6250 mom_v_acc_ext,
6251 dmom_v_acc_v_ext,
6252 mom_w_acc_ext,
6253 dmom_w_acc_w_ext,
6254 mass_adv_ext,
6255 dmass_adv_u_ext,
6256 dmass_adv_v_ext,
6257 dmass_adv_w_ext,
6258 mom_u_adv_ext,
6259 dmom_u_adv_u_ext,
6260 dmom_u_adv_v_ext,
6261 dmom_u_adv_w_ext,
6262 mom_v_adv_ext,
6263 dmom_v_adv_u_ext,
6264 dmom_v_adv_v_ext,
6265 dmom_v_adv_w_ext,
6266 mom_w_adv_ext,
6267 dmom_w_adv_u_ext,
6268 dmom_w_adv_v_ext,
6269 dmom_w_adv_w_ext,
6270 mom_uu_diff_ten_ext,
6271 mom_vv_diff_ten_ext,
6272 mom_ww_diff_ten_ext,
6273 mom_uv_diff_ten_ext,
6274 mom_uw_diff_ten_ext,
6275 mom_vu_diff_ten_ext,
6276 mom_vw_diff_ten_ext,
6277 mom_wu_diff_ten_ext,
6278 mom_wv_diff_ten_ext,
6279 mom_u_source_ext,
6280 mom_v_source_ext,
6281 mom_w_source_ext,
6282 mom_u_ham_ext,
6283 dmom_u_ham_grad_p_ext,
6284 dmom_u_ham_grad_u_ext,
6285 mom_v_ham_ext,
6286 dmom_v_ham_grad_p_ext,
6287 dmom_v_ham_grad_v_ext,
6288 mom_w_ham_ext,
6289 dmom_w_ham_grad_p_ext,
6290 dmom_w_ham_grad_w_ext,
6291 rhoSave,
6292 nuSave,
6293 KILL_PRESSURE_TERM,
6294 0,
6295 0., // mql: zero force term at boundary
6296 0.,
6297 0.,
6298 MATERIAL_PARAMETERS_AS_FUNCTION,
6299 ebqe_density_as_function[ebNE_kb],
6300 ebqe_dynamic_viscosity_as_function[ebNE_kb],
6301 USE_SBM,
6302 x_ext,y_ext,z_ext,
6303 use_ball_as_particle,
6304 ball_center.data(),
6305 ball_radius.data(),
6306 ball_velocity.data(),
6307 ball_angular_velocity.data(),
6308 INT_BY_PARTS_PRESSURE);
6309 evaluateCoefficients(eps_rho,
6310 eps_mu,
6311 particle_eps,
6312 sigma,
6313 rho_0,
6314 nu_0,
6315 rho_1,
6316 nu_1,
6317 elementDiameter[eN],
6318 smagorinskyConstant,
6319 turbulenceClosureModel,
6320 g.data(),
6321 useVF,
6322 bc_ebqe_vf_ext[ebNE_kb],
6323 bc_ebqe_phi_ext[ebNE_kb],
6324 &ebqe_normal_phi_ext[ebNE_kb_nSpace],
6325 distance_to_omega_solid,
6326 ebqe_kappa_phi_ext[ebNE_kb],
6327 //VRANS
6328 porosity_ext,
6329 //
6330 bc_p_ext,
6331 grad_p_ext,
6332 grad_u_ext,
6333 grad_v_ext,
6334 grad_w_ext,
6335 bc_u_ext,
6336 bc_v_ext,
6337 bc_w_ext,
6338 ebqe_velocity_star[ebNE_kb_nSpace+0],
6339 ebqe_velocity_star[ebNE_kb_nSpace+1],
6340 ebqe_velocity_star[ebNE_kb_nSpace+2],
6341 bc_eddy_viscosity_ext,
6342 bc_mom_u_acc_ext,
6343 bc_dmom_u_acc_u_ext,
6344 bc_mom_v_acc_ext,
6345 bc_dmom_v_acc_v_ext,
6346 bc_mom_w_acc_ext,
6347 bc_dmom_w_acc_w_ext,
6348 bc_mass_adv_ext,
6349 bc_dmass_adv_u_ext,
6350 bc_dmass_adv_v_ext,
6351 bc_dmass_adv_w_ext,
6352 bc_mom_u_adv_ext,
6353 bc_dmom_u_adv_u_ext,
6354 bc_dmom_u_adv_v_ext,
6355 bc_dmom_u_adv_w_ext,
6356 bc_mom_v_adv_ext,
6357 bc_dmom_v_adv_u_ext,
6358 bc_dmom_v_adv_v_ext,
6359 bc_dmom_v_adv_w_ext,
6360 bc_mom_w_adv_ext,
6361 bc_dmom_w_adv_u_ext,
6362 bc_dmom_w_adv_v_ext,
6363 bc_dmom_w_adv_w_ext,
6364 bc_mom_uu_diff_ten_ext,
6365 bc_mom_vv_diff_ten_ext,
6366 bc_mom_ww_diff_ten_ext,
6367 bc_mom_uv_diff_ten_ext,
6368 bc_mom_uw_diff_ten_ext,
6369 bc_mom_vu_diff_ten_ext,
6370 bc_mom_vw_diff_ten_ext,
6371 bc_mom_wu_diff_ten_ext,
6372 bc_mom_wv_diff_ten_ext,
6373 bc_mom_u_source_ext,
6374 bc_mom_v_source_ext,
6375 bc_mom_w_source_ext,
6376 bc_mom_u_ham_ext,
6377 bc_dmom_u_ham_grad_p_ext,
6378 bc_dmom_u_ham_grad_u_ext,
6379 bc_mom_v_ham_ext,
6380 bc_dmom_v_ham_grad_p_ext,
6381 bc_dmom_v_ham_grad_v_ext,
6382 bc_mom_w_ham_ext,
6383 bc_dmom_w_ham_grad_p_ext,
6384 bc_dmom_w_ham_grad_w_ext,
6385 rhoSave,
6386 nuSave,
6387 KILL_PRESSURE_TERM,
6388 0,
6389 0., // mql: zero force term at boundary
6390 0.,
6391 0.,
6392 MATERIAL_PARAMETERS_AS_FUNCTION,
6393 ebqe_density_as_function[ebNE_kb],
6394 ebqe_dynamic_viscosity_as_function[ebNE_kb],
6395 USE_SBM,
6396 x_ext,y_ext,z_ext,
6397 use_ball_as_particle,
6398 ball_center.data(),
6399 ball_radius.data(),
6400 ball_velocity.data(),
6401 ball_angular_velocity.data(),
6402 INT_BY_PARTS_PRESSURE);
6403 //Turbulence closure model
6404 if (turbulenceClosureModel >= 3)
6405 {
6406 const double turb_var_grad_0_dummy[3] = {0.,0.,0.};
6407 const double c_mu = 0.09;//mwf hack
6408 updateTurbulenceClosure(turbulenceClosureModel,
6409 eps_rho,
6410 eps_mu,
6411 rho_0,
6412 nu_0,
6413 rho_1,
6414 nu_1,
6415 useVF,
6416 ebqe_vf_ext[ebNE_kb],
6417 ebqe_phi_ext[ebNE_kb],
6418 porosity_ext,
6419 c_mu, //mwf hack
6420 ebqe_turb_var_0[ebNE_kb],
6421 ebqe_turb_var_1[ebNE_kb],
6422 turb_var_grad_0_dummy, //not needed
6423 eddy_viscosity_ext,
6424 mom_uu_diff_ten_ext,
6425 mom_vv_diff_ten_ext,
6426 mom_ww_diff_ten_ext,
6427 mom_uv_diff_ten_ext,
6428 mom_uw_diff_ten_ext,
6429 mom_vu_diff_ten_ext,
6430 mom_vw_diff_ten_ext,
6431 mom_wu_diff_ten_ext,
6432 mom_wv_diff_ten_ext,
6433 mom_u_source_ext,
6434 mom_v_source_ext,
6435 mom_w_source_ext);
6436
6437 updateTurbulenceClosure(turbulenceClosureModel,
6438 eps_rho,
6439 eps_mu,
6440 rho_0,
6441 nu_0,
6442 rho_1,
6443 nu_1,
6444 useVF,
6445 ebqe_vf_ext[ebNE_kb],
6446 ebqe_phi_ext[ebNE_kb],
6447 porosity_ext,
6448 c_mu, //mwf hack
6449 ebqe_turb_var_0[ebNE_kb],
6450 ebqe_turb_var_1[ebNE_kb],
6451 turb_var_grad_0_dummy, //not needed
6452 bc_eddy_viscosity_ext,
6453 bc_mom_uu_diff_ten_ext,
6454 bc_mom_vv_diff_ten_ext,
6455 bc_mom_ww_diff_ten_ext,
6456 bc_mom_uv_diff_ten_ext,
6457 bc_mom_uw_diff_ten_ext,
6458 bc_mom_vu_diff_ten_ext,
6459 bc_mom_vw_diff_ten_ext,
6460 bc_mom_wu_diff_ten_ext,
6461 bc_mom_wv_diff_ten_ext,
6462 bc_mom_u_source_ext,
6463 bc_mom_v_source_ext,
6464 bc_mom_w_source_ext);
6465 }
6466 //
6467 //moving domain
6468 //
6469 mom_u_adv_ext[0] -= MOVING_DOMAIN*dmom_u_acc_u_ext*mom_u_acc_ext*xt_ext; //times rho*porosity. mql. CHECK.
6470 mom_u_adv_ext[1] -= MOVING_DOMAIN*dmom_u_acc_u_ext*mom_u_acc_ext*yt_ext;
6471 mom_u_adv_ext[2] -= MOVING_DOMAIN*dmom_u_acc_u_ext*mom_u_acc_ext*zt_ext;
6472 dmom_u_adv_u_ext[0] -= MOVING_DOMAIN*dmom_u_acc_u_ext*xt_ext;
6473 dmom_u_adv_u_ext[1] -= MOVING_DOMAIN*dmom_u_acc_u_ext*yt_ext;
6474 dmom_u_adv_u_ext[2] -= MOVING_DOMAIN*dmom_u_acc_u_ext*zt_ext;
6475
6476 mom_v_adv_ext[0] -= MOVING_DOMAIN*dmom_v_acc_v_ext*mom_v_acc_ext*xt_ext;
6477 mom_v_adv_ext[1] -= MOVING_DOMAIN*dmom_v_acc_v_ext*mom_v_acc_ext*yt_ext;
6478 mom_v_adv_ext[2] -= MOVING_DOMAIN*dmom_v_acc_v_ext*mom_v_acc_ext*zt_ext;
6479 dmom_v_adv_v_ext[0] -= MOVING_DOMAIN*dmom_v_acc_v_ext*xt_ext;
6480 dmom_v_adv_v_ext[1] -= MOVING_DOMAIN*dmom_v_acc_v_ext*yt_ext;
6481 dmom_v_adv_v_ext[2] -= MOVING_DOMAIN*dmom_v_acc_v_ext*zt_ext;
6482
6483 mom_w_adv_ext[0] -= MOVING_DOMAIN*dmom_w_acc_w_ext*mom_w_acc_ext*xt_ext;
6484 mom_w_adv_ext[1] -= MOVING_DOMAIN*dmom_w_acc_w_ext*mom_w_acc_ext*yt_ext;
6485 mom_w_adv_ext[2] -= MOVING_DOMAIN*dmom_w_acc_w_ext*mom_w_acc_ext*zt_ext;
6486 dmom_w_adv_w_ext[0] -= MOVING_DOMAIN*dmom_w_acc_w_ext*xt_ext;
6487 dmom_w_adv_w_ext[1] -= MOVING_DOMAIN*dmom_w_acc_w_ext*yt_ext;
6488 dmom_w_adv_w_ext[2] -= MOVING_DOMAIN*dmom_w_acc_w_ext*zt_ext;
6489
6490 //moving domain bc's
6491 // mql. CHECK.
6492 bc_mom_u_adv_ext[0] -= MOVING_DOMAIN*bc_dmom_u_acc_u_ext*bc_mom_u_acc_ext*xt_ext; //times rho*porosity
6493 bc_mom_u_adv_ext[1] -= MOVING_DOMAIN*bc_dmom_u_acc_u_ext*bc_mom_u_acc_ext*yt_ext;
6494 bc_mom_u_adv_ext[2] -= MOVING_DOMAIN*bc_dmom_u_acc_u_ext*bc_mom_u_acc_ext*zt_ext;
6495
6496 bc_mom_v_adv_ext[0] -= MOVING_DOMAIN*bc_dmom_v_acc_v_ext*bc_mom_v_acc_ext*xt_ext;
6497 bc_mom_v_adv_ext[1] -= MOVING_DOMAIN*bc_dmom_v_acc_v_ext*bc_mom_v_acc_ext*yt_ext;
6498 bc_mom_v_adv_ext[2] -= MOVING_DOMAIN*bc_dmom_v_acc_v_ext*bc_mom_v_acc_ext*zt_ext;
6499
6500 bc_mom_w_adv_ext[0] -= MOVING_DOMAIN*bc_dmom_w_acc_w_ext*bc_mom_w_acc_ext*xt_ext;
6501 bc_mom_w_adv_ext[1] -= MOVING_DOMAIN*bc_dmom_w_acc_w_ext*bc_mom_w_acc_ext*yt_ext;
6502 bc_mom_w_adv_ext[2] -= MOVING_DOMAIN*bc_dmom_w_acc_w_ext*bc_mom_w_acc_ext*zt_ext;
6503 //
6504 //calculate the numerical fluxes
6505 //
6506 exteriorNumericalAdvectiveFluxDerivatives(isDOFBoundary_p[ebNE_kb],
6507 isDOFBoundary_u[ebNE_kb],
6508 isDOFBoundary_v[ebNE_kb],
6509 isDOFBoundary_w[ebNE_kb],
6510 isAdvectiveFluxBoundary_p[ebNE_kb],
6511 isAdvectiveFluxBoundary_u[ebNE_kb],
6512 isAdvectiveFluxBoundary_v[ebNE_kb],
6513 isAdvectiveFluxBoundary_w[ebNE_kb],
6514 dmom_u_ham_grad_p_ext[0],//=1/rho
6515 normal,
6516 porosity_ext*rhoSave,//dmom_u_acc_u_ext,
6517 bc_p_ext,
6518 bc_u_ext,
6519 bc_v_ext,
6520 bc_w_ext,
6521 bc_mass_adv_ext,
6522 bc_mom_u_adv_ext,
6523 bc_mom_v_adv_ext,
6524 bc_mom_w_adv_ext,
6525 ebqe_bc_flux_mass_ext[ebNE_kb]+MOVING_DOMAIN*(xt_ext*normal[0]+yt_ext*normal[1]+zt_ext*normal[2]),//bc is relative mass flux
6526 ebqe_bc_flux_mom_u_adv_ext[ebNE_kb],
6527 ebqe_bc_flux_mom_v_adv_ext[ebNE_kb],
6528 ebqe_bc_flux_mom_w_adv_ext[ebNE_kb],
6529 p_ext,
6530 u_ext,
6531 v_ext,
6532 w_ext,
6533 mass_adv_ext,
6534 mom_u_adv_ext,
6535 mom_v_adv_ext,
6536 mom_w_adv_ext,
6537 dmass_adv_u_ext,
6538 dmass_adv_v_ext,
6539 dmass_adv_w_ext,
6540 dmom_u_adv_p_ext,
6541 dmom_u_adv_u_ext,
6542 dmom_u_adv_v_ext,
6543 dmom_u_adv_w_ext,
6544 dmom_v_adv_p_ext,
6545 dmom_v_adv_u_ext,
6546 dmom_v_adv_v_ext,
6547 dmom_v_adv_w_ext,
6548 dmom_w_adv_p_ext,
6549 dmom_w_adv_u_ext,
6550 dmom_w_adv_v_ext,
6551 dmom_w_adv_w_ext,
6552 dflux_mass_u_ext,
6553 dflux_mass_v_ext,
6554 dflux_mass_w_ext,
6555 dflux_mom_u_adv_p_ext,
6556 dflux_mom_u_adv_u_ext,
6557 dflux_mom_u_adv_v_ext,
6558 dflux_mom_u_adv_w_ext,
6559 dflux_mom_v_adv_p_ext,
6560 dflux_mom_v_adv_u_ext,
6561 dflux_mom_v_adv_v_ext,
6562 dflux_mom_v_adv_w_ext,
6563 dflux_mom_w_adv_p_ext,
6564 dflux_mom_w_adv_u_ext,
6565 dflux_mom_w_adv_v_ext,
6566 dflux_mom_w_adv_w_ext,
6567 &ebqe_velocity_star[ebNE_kb_nSpace]);
6568 //
6569 //calculate the flux jacobian
6570 //
6571 ck.calculateGScale(G,normal,h_penalty);
6572 penalty = useMetrics*C_b/h_penalty + (1.0-useMetrics)*ebqe_penalty_ext[ebNE_kb];
6573 for (int j=0;j<nDOF_trial_element;j++)
6574 {
6575 int j_nSpace = j*nSpace,ebN_local_kb_j=ebN_local_kb*nDOF_trial_element+j;
6576 /* fluxJacobian_p_p[j]=0.0; */
6577 /* fluxJacobian_p_u[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mass_u_ext,vel_trial_trace_ref[ebN_local_kb_j]); */
6578 /* fluxJacobian_p_v[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mass_v_ext,vel_trial_trace_ref[ebN_local_kb_j]); */
6579 /* fluxJacobian_p_w[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mass_w_ext,vel_trial_trace_ref[ebN_local_kb_j]); */
6580
6581 /* fluxJacobian_u_p[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mom_u_adv_p_ext,p_trial_trace_ref[ebN_local_kb_j]); */
6582 fluxJacobian_u_u[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mom_u_adv_u_ext,vel_trial_trace_ref[ebN_local_kb_j]) +
6583 ExteriorNumericalDiffusiveFluxJacobian(eps_rho,
6584 ebqe_phi_ext[ebNE_kb],
6585 sdInfo_u_u_rowptr.data(),
6586 sdInfo_u_u_colind.data(),
6587 isDOFBoundary_u[ebNE_kb],
6588 isDiffusiveFluxBoundary_u[ebNE_kb],
6589 normal,
6590 mom_uu_diff_ten_ext,
6591 vel_trial_trace_ref[ebN_local_kb_j],
6592 &vel_grad_trial_trace[j_nSpace],
6593 penalty);//ebqe_penalty_ext[ebNE_kb]);
6594 fluxJacobian_u_v[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mom_u_adv_v_ext,vel_trial_trace_ref[ebN_local_kb_j]) +
6595 ExteriorNumericalDiffusiveFluxJacobian(eps_rho,
6596 ebqe_phi_ext[ebNE_kb],
6597 sdInfo_u_v_rowptr.data(),
6598 sdInfo_u_v_colind.data(),
6599 isDOFBoundary_v[ebNE_kb],
6600 isDiffusiveFluxBoundary_v[ebNE_kb],
6601 normal,
6602 mom_uv_diff_ten_ext,
6603 vel_trial_trace_ref[ebN_local_kb_j],
6604 &vel_grad_trial_trace[j_nSpace],
6605 penalty);//ebqe_penalty_ext[ebNE_kb]);
6606 fluxJacobian_u_w[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mom_u_adv_w_ext,vel_trial_trace_ref[ebN_local_kb_j]) +
6607 ExteriorNumericalDiffusiveFluxJacobian(eps_rho,
6608 ebqe_phi_ext[ebNE_kb],
6609 sdInfo_u_w_rowptr.data(),
6610 sdInfo_u_w_colind.data(),
6611 isDOFBoundary_w[ebNE_kb],
6612 isDiffusiveFluxBoundary_u[ebNE_kb],
6613 normal,
6614 mom_uw_diff_ten_ext,
6615 vel_trial_trace_ref[ebN_local_kb_j],
6616 &vel_grad_trial_trace[j_nSpace],
6617 penalty);//ebqe_penalty_ext[ebNE_kb]);
6618
6619 /* fluxJacobian_v_p[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mom_v_adv_p_ext,p_trial_trace_ref[ebN_local_kb_j]); */
6620 fluxJacobian_v_u[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mom_v_adv_u_ext,vel_trial_trace_ref[ebN_local_kb_j]) +
6621 ExteriorNumericalDiffusiveFluxJacobian(eps_rho,
6622 ebqe_phi_ext[ebNE_kb],
6623 sdInfo_v_u_rowptr.data(),
6624 sdInfo_v_u_colind.data(),
6625 isDOFBoundary_u[ebNE_kb],
6626 isDiffusiveFluxBoundary_u[ebNE_kb],
6627 normal,
6628 mom_vu_diff_ten_ext,
6629 vel_trial_trace_ref[ebN_local_kb_j],
6630 &vel_grad_trial_trace[j_nSpace],
6631 penalty);//ebqe_penalty_ext[ebNE_kb]);
6632 fluxJacobian_v_v[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mom_v_adv_v_ext,vel_trial_trace_ref[ebN_local_kb_j]) +
6633 ExteriorNumericalDiffusiveFluxJacobian(eps_rho,
6634 ebqe_phi_ext[ebNE_kb],
6635 sdInfo_v_v_rowptr.data(),
6636 sdInfo_v_v_colind.data(),
6637 isDOFBoundary_v[ebNE_kb],
6638 isDiffusiveFluxBoundary_v[ebNE_kb],
6639 normal,
6640 mom_vv_diff_ten_ext,
6641 vel_trial_trace_ref[ebN_local_kb_j],
6642 &vel_grad_trial_trace[j_nSpace],
6643 penalty);//ebqe_penalty_ext[ebNE_kb]);
6644 fluxJacobian_v_w[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mom_v_adv_w_ext,vel_trial_trace_ref[ebN_local_kb_j]) +
6645 ExteriorNumericalDiffusiveFluxJacobian(eps_rho,
6646 ebqe_phi_ext[ebNE_kb],
6647 sdInfo_v_w_rowptr.data(),
6648 sdInfo_v_w_colind.data(),
6649 isDOFBoundary_w[ebNE_kb],
6650 isDiffusiveFluxBoundary_v[ebNE_kb],
6651 normal,
6652 mom_vw_diff_ten_ext,
6653 vel_trial_trace_ref[ebN_local_kb_j],
6654 &vel_grad_trial_trace[j_nSpace],
6655 penalty);//ebqe_penalty_ext[ebNE_kb]);
6656
6657 /* fluxJacobian_w_p[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mom_w_adv_p_ext,p_trial_trace_ref[ebN_local_kb_j]); */
6658 fluxJacobian_w_u[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mom_w_adv_u_ext,vel_trial_trace_ref[ebN_local_kb_j]) +
6659 ExteriorNumericalDiffusiveFluxJacobian(eps_rho,
6660 ebqe_phi_ext[ebNE_kb],
6661 sdInfo_w_u_rowptr.data(),
6662 sdInfo_w_u_colind.data(),
6663 isDOFBoundary_u[ebNE_kb],
6664 isDiffusiveFluxBoundary_w[ebNE_kb],
6665 normal,
6666 mom_wu_diff_ten_ext,
6667 vel_trial_trace_ref[ebN_local_kb_j],
6668 &vel_grad_trial_trace[j_nSpace],
6669 penalty);//ebqe_penalty_ext[ebNE_kb]);
6670 fluxJacobian_w_v[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mom_w_adv_v_ext,vel_trial_trace_ref[ebN_local_kb_j]) +
6671 ExteriorNumericalDiffusiveFluxJacobian(eps_rho,
6672 ebqe_phi_ext[ebNE_kb],
6673 sdInfo_w_v_rowptr.data(),
6674 sdInfo_w_v_colind.data(),
6675 isDOFBoundary_v[ebNE_kb],
6676 isDiffusiveFluxBoundary_w[ebNE_kb],
6677 normal,
6678 mom_wv_diff_ten_ext,
6679 vel_trial_trace_ref[ebN_local_kb_j],
6680 &vel_grad_trial_trace[j_nSpace],
6681 penalty);//ebqe_penalty_ext[ebNE_kb]);
6682 fluxJacobian_w_w[j]=ck.ExteriorNumericalAdvectiveFluxJacobian(dflux_mom_w_adv_w_ext,vel_trial_trace_ref[ebN_local_kb_j]) +
6683 ExteriorNumericalDiffusiveFluxJacobian(eps_rho,
6684 ebqe_phi_ext[ebNE_kb],
6685 sdInfo_w_w_rowptr.data(),
6686 sdInfo_w_w_colind.data(),
6687 isDOFBoundary_w[ebNE_kb],
6688 isDiffusiveFluxBoundary_w[ebNE_kb],
6689 normal,
6690 mom_ww_diff_ten_ext,
6691 vel_trial_trace_ref[ebN_local_kb_j],
6692 &vel_grad_trial_trace[j_nSpace],
6693 penalty);//ebqe_penalty_ext[ebNE_kb]);
6694 }//j
6695 //
6696 //update the global Jacobian from the flux Jacobian
6697 //
6698 for (int i=0;i<nDOF_test_element;i++)
6699 {
6700 int eN_i = eN*nDOF_test_element+i;
6701 for (int j=0;j<nDOF_trial_element;j++)
6702 {
6703 int ebN_i_j = ebN*4*nDOF_test_X_trial_element + i*nDOF_trial_element + j,ebN_local_kb_j=ebN_local_kb*nDOF_trial_element+j;
6704
6705 /* globalJacobian[csrRowIndeces_p_p[eN_i] + csrColumnOffsets_eb_p_p[ebN_i_j]] += fluxJacobian_p_p[j]*p_test_dS[i]; */
6706 /* globalJacobian[csrRowIndeces_p_u[eN_i] + csrColumnOffsets_eb_p_u[ebN_i_j]] += fluxJacobian_p_u[j]*p_test_dS[i]; */
6707 /* globalJacobian[csrRowIndeces_p_v[eN_i] + csrColumnOffsets_eb_p_v[ebN_i_j]] += fluxJacobian_p_v[j]*p_test_dS[i]; */
6708 /* globalJacobian[csrRowIndeces_p_w[eN_i] + csrColumnOffsets_eb_p_w[ebN_i_j]] += fluxJacobian_p_w[j]*p_test_dS[i]; */
6709
6710 /* globalJacobian[csrRowIndeces_u_p[eN_i] + csrColumnOffsets_eb_u_p[ebN_i_j]] += fluxJacobian_u_p[j]*vel_test_dS[i]; */
6711 globalJacobian[csrRowIndeces_u_u[eN_i] + csrColumnOffsets_eb_u_u[ebN_i_j]] += fluxJacobian_u_u[j]*vel_test_dS[i]+
6712 ck.ExteriorElementBoundaryDiffusionAdjointJacobian(isDOFBoundary_u[ebNE_kb],
6713 isDiffusiveFluxBoundary_u[ebNE_kb],
6714 eb_adjoint_sigma,
6715 vel_trial_trace_ref[ebN_local_kb_j],
6716 normal,
6717 sdInfo_u_u_rowptr.data(),
6718 sdInfo_u_u_colind.data(),
6719 mom_uu_diff_ten_ext,
6720 &vel_grad_test_dS[i*nSpace]);
6721 globalJacobian[csrRowIndeces_u_v[eN_i] + csrColumnOffsets_eb_u_v[ebN_i_j]] += fluxJacobian_u_v[j]*vel_test_dS[i]+
6722 ck.ExteriorElementBoundaryDiffusionAdjointJacobian(isDOFBoundary_v[ebNE_kb],
6723 isDiffusiveFluxBoundary_u[ebNE_kb],
6724 eb_adjoint_sigma,
6725 vel_trial_trace_ref[ebN_local_kb_j],
6726 normal,
6727 sdInfo_u_v_rowptr.data(),
6728 sdInfo_u_v_colind.data(),
6729 mom_uv_diff_ten_ext,
6730 &vel_grad_test_dS[i*nSpace]);
6731 globalJacobian[csrRowIndeces_u_w[eN_i] + csrColumnOffsets_eb_u_w[ebN_i_j]] += fluxJacobian_u_w[j]*vel_test_dS[i]+
6732 ck.ExteriorElementBoundaryDiffusionAdjointJacobian(isDOFBoundary_w[ebNE_kb],
6733 isDiffusiveFluxBoundary_u[ebNE_kb],
6734 eb_adjoint_sigma,
6735 vel_trial_trace_ref[ebN_local_kb_j],
6736 normal,
6737 sdInfo_u_w_rowptr.data(),
6738 sdInfo_u_w_colind.data(),
6739 mom_uw_diff_ten_ext,
6740 &vel_grad_test_dS[i*nSpace]);
6741
6742 /* globalJacobian[csrRowIndeces_v_p[eN_i] + csrColumnOffsets_eb_v_p[ebN_i_j]] += fluxJacobian_v_p[j]*vel_test_dS[i]; */
6743 globalJacobian[csrRowIndeces_v_u[eN_i] + csrColumnOffsets_eb_v_u[ebN_i_j]] += fluxJacobian_v_u[j]*vel_test_dS[i]+
6744 ck.ExteriorElementBoundaryDiffusionAdjointJacobian(isDOFBoundary_u[ebNE_kb],
6745 isDiffusiveFluxBoundary_v[ebNE_kb],
6746 eb_adjoint_sigma,
6747 vel_trial_trace_ref[ebN_local_kb_j],
6748 normal,
6749 sdInfo_v_u_rowptr.data(),
6750 sdInfo_v_u_colind.data(),
6751 mom_vu_diff_ten_ext,
6752 &vel_grad_test_dS[i*nSpace]);
6753 globalJacobian[csrRowIndeces_v_v[eN_i] + csrColumnOffsets_eb_v_v[ebN_i_j]] += fluxJacobian_v_v[j]*vel_test_dS[i]+
6754 ck.ExteriorElementBoundaryDiffusionAdjointJacobian(isDOFBoundary_v[ebNE_kb],
6755 isDiffusiveFluxBoundary_v[ebNE_kb],
6756 eb_adjoint_sigma,
6757 vel_trial_trace_ref[ebN_local_kb_j],
6758 normal,
6759 sdInfo_v_v_rowptr.data(),
6760 sdInfo_v_v_colind.data(),
6761 mom_vv_diff_ten_ext,
6762 &vel_grad_test_dS[i*nSpace]);
6763 globalJacobian[csrRowIndeces_v_w[eN_i] + csrColumnOffsets_eb_v_w[ebN_i_j]] += fluxJacobian_v_w[j]*vel_test_dS[i]+
6764 ck.ExteriorElementBoundaryDiffusionAdjointJacobian(isDOFBoundary_w[ebNE_kb],
6765 isDiffusiveFluxBoundary_v[ebNE_kb],
6766 eb_adjoint_sigma,
6767 vel_trial_trace_ref[ebN_local_kb_j],
6768 normal,
6769 sdInfo_v_w_rowptr.data(),
6770 sdInfo_v_w_colind.data(),
6771 mom_vw_diff_ten_ext,
6772 &vel_grad_test_dS[i*nSpace]);
6773
6774 /* globalJacobian[csrRowIndeces_w_p[eN_i] + csrColumnOffsets_eb_w_p[ebN_i_j]] += fluxJacobian_w_p[j]*vel_test_dS[i]; */
6775 globalJacobian[csrRowIndeces_w_u[eN_i] + csrColumnOffsets_eb_w_u[ebN_i_j]] += fluxJacobian_w_u[j]*vel_test_dS[i]+
6776 ck.ExteriorElementBoundaryDiffusionAdjointJacobian(isDOFBoundary_u[ebNE_kb],
6777 isDiffusiveFluxBoundary_w[ebNE_kb],
6778 eb_adjoint_sigma,
6779 vel_trial_trace_ref[ebN_local_kb_j],
6780 normal,
6781 sdInfo_w_u_rowptr.data(),
6782 sdInfo_w_u_colind.data(),
6783 mom_wu_diff_ten_ext,
6784 &vel_grad_test_dS[i*nSpace]);
6785 globalJacobian[csrRowIndeces_w_v[eN_i] + csrColumnOffsets_eb_w_v[ebN_i_j]] += fluxJacobian_w_v[j]*vel_test_dS[i]+
6786 ck.ExteriorElementBoundaryDiffusionAdjointJacobian(isDOFBoundary_v[ebNE_kb],
6787 isDiffusiveFluxBoundary_w[ebNE_kb],
6788 eb_adjoint_sigma,
6789 vel_trial_trace_ref[ebN_local_kb_j],
6790 normal,
6791 sdInfo_w_v_rowptr.data(),
6792 sdInfo_w_v_colind.data(),
6793 mom_wv_diff_ten_ext,
6794 &vel_grad_test_dS[i*nSpace]);
6795 globalJacobian[csrRowIndeces_w_w[eN_i] + csrColumnOffsets_eb_w_w[ebN_i_j]] += fluxJacobian_w_w[j]*vel_test_dS[i]+
6796 ck.ExteriorElementBoundaryDiffusionAdjointJacobian(isDOFBoundary_w[ebNE_kb],
6797 isDiffusiveFluxBoundary_w[ebNE_kb],
6798 eb_adjoint_sigma,
6799 vel_trial_trace_ref[ebN_local_kb_j],
6800 normal,
6801 sdInfo_w_w_rowptr.data(),
6802 sdInfo_w_w_colind.data(),
6803 mom_ww_diff_ten_ext,
6804 &vel_grad_test_dS[i*nSpace]);
6805 }//j
6806 }//i
6807 }//kb
6808 }//ebNE
6809 gf.useExact=useExact;
6810 gf_s.useExact=useExact;
6811 }//computeJacobian
6812
6813 void calculateVelocityAverage(arguments_dict& args)
6814 {
6815 int nExteriorElementBoundaries_global = args.scalar<int>("nExteriorElementBoundaries_global");
6816 xt::pyarray<int>& exteriorElementBoundariesArray = args.array<int>("exteriorElementBoundariesArray");
6817 int nInteriorElementBoundaries_global = args.scalar<int>("nInteriorElementBoundaries_global");
6818 xt::pyarray<int>& interiorElementBoundariesArray = args.array<int>("interiorElementBoundariesArray");
6819 xt::pyarray<int>& elementBoundaryElementsArray = args.array<int>("elementBoundaryElementsArray");
6820 xt::pyarray<int>& elementBoundaryLocalElementBoundariesArray = args.array<int>("elementBoundaryLocalElementBoundariesArray");
6821 xt::pyarray<double>& mesh_dof = args.array<double>("mesh_dof");
6822 xt::pyarray<double>& mesh_velocity_dof = args.array<double>("mesh_velocity_dof");
6823 double MOVING_DOMAIN = args.scalar<double>("MOVING_DOMAIN");
6824 xt::pyarray<int>& mesh_l2g = args.array<int>("mesh_l2g");
6825 xt::pyarray<double>& mesh_trial_trace_ref = args.array<double>("mesh_trial_trace_ref");
6826 xt::pyarray<double>& mesh_grad_trial_trace_ref = args.array<double>("mesh_grad_trial_trace_ref");
6827 xt::pyarray<double>& normal_ref = args.array<double>("normal_ref");
6828 xt::pyarray<double>& boundaryJac_ref = args.array<double>("boundaryJac_ref");
6829 xt::pyarray<int>& vel_l2g = args.array<int>("vel_l2g");
6830 xt::pyarray<double>& u_dof = args.array<double>("u_dof");
6831 xt::pyarray<double>& v_dof = args.array<double>("v_dof");
6832 xt::pyarray<double>& w_dof = args.array<double>("w_dof");
6833 xt::pyarray<double>& vos_dof = args.array<double>("vos_dof");
6834 xt::pyarray<double>& vel_trial_trace_ref = args.array<double>("vel_trial_trace_ref");
6835 xt::pyarray<double>& ebqe_velocity = args.array<double>("ebqe_velocity");
6836 xt::pyarray<double>& velocityAverage = args.array<double>("velocityAverage");
6837 int permutations[nQuadraturePoints_elementBoundary];
6838 double xArray_left[nQuadraturePoints_elementBoundary*3],
6839 xArray_right[nQuadraturePoints_elementBoundary*3];
6840 for (int i=0;i<nQuadraturePoints_elementBoundary;i++)
6841 permutations[i]=i;//just to initialize
6842 for (int ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
6843 {
6844 int ebN = exteriorElementBoundariesArray[ebNE];
6845 for (int kb=0;kb<nQuadraturePoints_elementBoundary;kb++)
6846 {
6847 int ebN_kb_nSpace = ebN*nQuadraturePoints_elementBoundary*nSpace+kb*nSpace,
6848 ebNE_kb_nSpace = ebNE*nQuadraturePoints_elementBoundary*nSpace+kb*nSpace;
6849 velocityAverage[ebN_kb_nSpace+0]=ebqe_velocity[ebNE_kb_nSpace+0];
6850 velocityAverage[ebN_kb_nSpace+1]=ebqe_velocity[ebNE_kb_nSpace+1];
6851 velocityAverage[ebN_kb_nSpace+2]=ebqe_velocity[ebNE_kb_nSpace+2];
6852 }//ebNE
6853 }
6854 for (int ebNI = 0; ebNI < nInteriorElementBoundaries_global; ebNI++)
6855 {
6856 int ebN = interiorElementBoundariesArray[ebNI],
6857 left_eN_global = elementBoundaryElementsArray[ebN*2+0],
6858 left_ebN_element = elementBoundaryLocalElementBoundariesArray[ebN*2+0],
6859 right_eN_global = elementBoundaryElementsArray[ebN*2+1],
6860 right_ebN_element = elementBoundaryLocalElementBoundariesArray[ebN*2+1],
6861 left_eN_nDOF_trial_element = left_eN_global*nDOF_trial_element,
6862 right_eN_nDOF_trial_element = right_eN_global*nDOF_trial_element;
6863 double jac[nSpace*nSpace],
6864 jacDet,
6865 jacInv[nSpace*nSpace],
6866 boundaryJac[nSpace*(nSpace-1)],
6867 metricTensor[(nSpace-1)*(nSpace-1)],
6868 metricTensorDetSqrt,
6869 normal[3],
6870 x,y,z,
6871 xt,yt,zt,integralScaling;
6872
6873 for (int kb=0;kb<nQuadraturePoints_elementBoundary;kb++)
6874 {
6875 ck.calculateMapping_elementBoundary(left_eN_global,
6876 left_ebN_element,
6877 kb,
6878 left_ebN_element*nQuadraturePoints_elementBoundary+kb,
6879 mesh_dof.data(),
6880 mesh_l2g.data(),
6881 mesh_trial_trace_ref.data(),
6882 mesh_grad_trial_trace_ref.data(),
6883 boundaryJac_ref.data(),
6884 jac,
6885 jacDet,
6886 jacInv,
6887 boundaryJac,
6888 metricTensor,
6889 metricTensorDetSqrt,
6890 normal_ref.data(),
6891 normal,
6892 x,y,z);
6893 xArray_left[kb*3+0] = x;
6894 xArray_left[kb*3+1] = y;
6895 xArray_left[kb*3+2] = z;
6896 ck.calculateMapping_elementBoundary(right_eN_global,
6897 right_ebN_element,
6898 kb,
6899 right_ebN_element*nQuadraturePoints_elementBoundary+kb,
6900 mesh_dof.data(),
6901 mesh_l2g.data(),
6902 mesh_trial_trace_ref.data(),
6903 mesh_grad_trial_trace_ref.data(),
6904 boundaryJac_ref.data(),
6905 jac,
6906 jacDet,
6907 jacInv,
6908 boundaryJac,
6909 metricTensor,
6910 metricTensorDetSqrt,
6911 normal_ref.data(),
6912 normal,
6913 x,y,z);
6914 ck.calculateMappingVelocity_elementBoundary(left_eN_global,
6915 left_ebN_element,
6916 kb,
6917 left_ebN_element*nQuadraturePoints_elementBoundary+kb,
6918 mesh_velocity_dof.data(),
6919 mesh_l2g.data(),
6920 mesh_trial_trace_ref.data(),
6921 xt,yt,zt,
6922 normal,
6923 boundaryJac,
6924 metricTensor,
6925 integralScaling);
6926 xArray_right[kb*3+0] = x;
6927 xArray_right[kb*3+1] = y;
6928 xArray_right[kb*3+2] = z;
6929 }
6930 for (int kb_left=0;kb_left<nQuadraturePoints_elementBoundary;kb_left++)
6931 {
6932 double errorNormMin = 1.0;
6933 for (int kb_right=0;kb_right<nQuadraturePoints_elementBoundary;kb_right++)
6934 {
6935 double errorNorm=0.0;
6936 for (int I=0;I<nSpace;I++)
6937 {
6938 errorNorm += fabs(xArray_left[kb_left*3+I]
6939 -
6940 xArray_right[kb_right*3+I]);
6941 }
6942 if (errorNorm < errorNormMin)
6943 {
6944 permutations[kb_right] = kb_left;
6945 errorNormMin = errorNorm;
6946 }
6947 }
6948 }
6949 for (int kb=0;kb<nQuadraturePoints_elementBoundary;kb++)
6950 {
6951 int ebN_kb_nSpace = ebN*nQuadraturePoints_elementBoundary*nSpace+kb*nSpace;
6952 double u_left=0.0,
6953 v_left=0.0,
6954 w_left=0.0,
6955 u_right=0.0,
6956 v_right=0.0,
6957 w_right=0.0,
6958 vos_left=0.0,
6959 vos_right=0.0,
6960 porosity_left=0.0,
6961 porosity_right=0.0;
6962 int left_kb = kb,
6963 right_kb = permutations[kb],
6964 left_ebN_element_kb_nDOF_test_element=(left_ebN_element*nQuadraturePoints_elementBoundary+left_kb)*nDOF_test_element,
6965 right_ebN_element_kb_nDOF_test_element=(right_ebN_element*nQuadraturePoints_elementBoundary+right_kb)*nDOF_test_element;
6966 //
6967 //calculate the velocity solution at quadrature points on left and right
6968 //
6969 ck.valFromDOF(vos_dof.data(),&vel_l2g[left_eN_nDOF_trial_element],&vel_trial_trace_ref[left_ebN_element_kb_nDOF_test_element],vos_left);
6970 ck.valFromDOF(u_dof.data(),&vel_l2g[left_eN_nDOF_trial_element],&vel_trial_trace_ref[left_ebN_element_kb_nDOF_test_element],u_left);
6971 ck.valFromDOF(v_dof.data(),&vel_l2g[left_eN_nDOF_trial_element],&vel_trial_trace_ref[left_ebN_element_kb_nDOF_test_element],v_left);
6972 ck.valFromDOF(w_dof.data(),&vel_l2g[left_eN_nDOF_trial_element],&vel_trial_trace_ref[left_ebN_element_kb_nDOF_test_element],w_left);
6973 //
6974 ck.valFromDOF(vos_dof.data(),&vel_l2g[right_eN_nDOF_trial_element],&vel_trial_trace_ref[right_ebN_element_kb_nDOF_test_element],vos_right);
6975 ck.valFromDOF(u_dof.data(),&vel_l2g[right_eN_nDOF_trial_element],&vel_trial_trace_ref[right_ebN_element_kb_nDOF_test_element],u_right);
6976 ck.valFromDOF(v_dof.data(),&vel_l2g[right_eN_nDOF_trial_element],&vel_trial_trace_ref[right_ebN_element_kb_nDOF_test_element],v_right);
6977 ck.valFromDOF(w_dof.data(),&vel_l2g[right_eN_nDOF_trial_element],&vel_trial_trace_ref[right_ebN_element_kb_nDOF_test_element],w_right);
6978 //
6979 /* porosity_left = 1.0 - vos_left; */
6980 /* porosity_right = 1.0 - vos_right; */
6981 velocityAverage[ebN_kb_nSpace+0]=0.5*(u_left + u_right);
6982 velocityAverage[ebN_kb_nSpace+1]=0.5*(v_left + v_right);
6983 velocityAverage[ebN_kb_nSpace+2]=0.5*(w_left + w_right);
6984 }//ebNI
6985 }
6986 }
6987
6988 void getBoundaryDOFs(arguments_dict& args)
6989 {
6990 xt::pyarray<double>& mesh_dof = args.array<double>("mesh_dof");
6991 xt::pyarray<int>& mesh_l2g = args.array<int>("mesh_l2g");
6992 xt::pyarray<double>& mesh_trial_trace_ref = args.array<double>("mesh_trial_trace_ref");
6993 xt::pyarray<double>& mesh_grad_trial_trace_ref = args.array<double>("mesh_grad_trial_trace_ref");
6994 xt::pyarray<double>& dS_ref = args.array<double>("dS_ref");
6995 xt::pyarray<double>& vel_test_trace_ref = args.array<double>("vel_test_trace_ref");
6996 xt::pyarray<double>& normal_ref = args.array<double>("normal_ref");
6997 xt::pyarray<double>& boundaryJac_ref = args.array<double>("boundaryJac_ref");
6998 xt::pyarray<int>& vel_l2g = args.array<int>("vel_l2g");
6999 int nExteriorElementBoundaries_global = args.scalar<int>("nExteriorElementBoundaries_global");
7000 xt::pyarray<int>& exteriorElementBoundariesArray = args.array<int>("exteriorElementBoundariesArray");
7001 xt::pyarray<int>& elementBoundaryElementsArray = args.array<int>("elementBoundaryElementsArray");
7002 xt::pyarray<int>& elementBoundaryLocalElementBoundariesArray = args.array<int>("elementBoundaryLocalElementBoundariesArray");
7003 xt::pyarray<double>& isBoundary_1D = args.array<double>("isBoundary_1D");
7004 //
7005 //loop over exterior element boundaries to calculate surface integrals and load into element and global residuals
7006 //
7007 //ebNE is the Exterior element boundary INdex
7008 //ebN is the element boundary INdex
7009 //eN is the element index
7010 for (int ebNE = 0; ebNE < nExteriorElementBoundaries_global; ebNE++)
7011 {
7012 int ebN = exteriorElementBoundariesArray[ebNE],
7013 eN = elementBoundaryElementsArray[ebN*2+0],
7014 ebN_local = elementBoundaryLocalElementBoundariesArray[ebN*2+0],
7015 eN_nDOF_trial_element = eN*nDOF_trial_element;
7016 double
7017 elementIsBoundary[nDOF_test_element];
7018 for (int i=0;i<nDOF_test_element;i++)
7019 elementIsBoundary[i]=0.0;
7020 for (int kb=0;kb<nQuadraturePoints_elementBoundary;kb++)
7021 {
7022 int ebNE_kb = ebNE*nQuadraturePoints_elementBoundary+kb,
7023 ebNE_kb_nSpace = ebNE_kb*nSpace,
7024 ebN_local_kb = ebN_local*nQuadraturePoints_elementBoundary+kb,
7025 ebN_local_kb_nSpace = ebN_local_kb*nSpace;
7026 double
7027 jac_ext[nSpace*nSpace],
7028 jacDet_ext,
7029 jacInv_ext[nSpace*nSpace],
7030 boundaryJac[nSpace*(nSpace-1)],
7031 metricTensor[(nSpace-1)*(nSpace-1)],
7032 metricTensorDetSqrt,
7033 dS, vel_test_dS[nDOF_test_element],
7034 normal[3],x_ext,y_ext,z_ext;
7035 //compute information about mapping from reference element to physical element
7036 ck.calculateMapping_elementBoundary(eN,
7037 ebN_local,
7038 kb,
7039 ebN_local_kb,
7040 mesh_dof.data(),
7041 mesh_l2g.data(),
7042 mesh_trial_trace_ref.data(),
7043 mesh_grad_trial_trace_ref.data(),
7044 boundaryJac_ref.data(),
7045 jac_ext,
7046 jacDet_ext,
7047 jacInv_ext,
7048 boundaryJac,
7049 metricTensor,
7050 metricTensorDetSqrt,
7051 normal_ref.data(),
7052 normal,
7053 x_ext,y_ext,z_ext);
7054 dS = metricTensorDetSqrt*dS_ref[kb];
7055 //precalculate test function products with integration weights
7056 for (int j=0;j<nDOF_trial_element;j++)
7057 vel_test_dS[j] = fabs(vel_test_trace_ref[ebN_local_kb*nDOF_test_element+j])*dS;
7058 //
7059 //update residuals
7060 //
7061 for (int i=0;i<nDOF_test_element;i++)
7062 elementIsBoundary[i] += vel_test_dS[i];
7063 }//kb
7064 //
7065 //update the element and global residual storage
7066 //
7067 for (int i=0;i<nDOF_test_element;i++)
7068 {
7069 int eN_i = eN*nDOF_test_element+i;
7070 isBoundary_1D[vel_l2g[eN_i]] += elementIsBoundary[i];
7071 }//i
7072 }//ebNE
7073 }
7074 };//RANS3PF
7075
7076 inline cppRANS3PF_base* newRANS3PF(int nSpaceIn,
7077 int nQuadraturePoints_elementIn,
7078 int nDOF_mesh_trial_elementIn,
7079 int nDOF_trial_elementIn,
7080 int nDOF_test_elementIn,
7081 int nQuadraturePoints_elementBoundaryIn,
7082 int CompKernelFlag,
7083 double aDarcy,
7084 double betaForch,
7085 double grain,
7086 double packFraction,
7087 double packMargin,
7088 double maxFraction,
7089 double frFraction,
7090 double sigmaC,
7091 double C3e,
7092 double C4e,
7093 double eR,
7094 double fContact,
7095 double mContact,
7096 double nContact,
7097 double angFriction,
7098 double vos_limiter,
7099 double mu_fr_limiter
7100 )
7101 {
7102 cppRANS3PF_base *rvalue = proteus::chooseAndAllocateDiscretization<cppRANS3PF_base, cppRANS3PF, CompKernel>(nSpaceIn,
7103 nQuadraturePoints_elementIn,
7104 nDOF_mesh_trial_elementIn,
7105 nDOF_trial_elementIn,
7106 nDOF_test_elementIn,
7107 nQuadraturePoints_elementBoundaryIn,
7108 CompKernelFlag);
7109 rvalue->setSedClosure(aDarcy,
7110 betaForch,
7111 grain,
7112 packFraction,
7113 packMargin,
7114 maxFraction,
7115 frFraction,
7116 sigmaC,
7117 C3e,
7118 C4e,
7119 eR,
7120 fContact,
7121 mContact,
7122 nContact,
7123 angFriction,
7124 vos_limiter,
7125 mu_fr_limiter
7126 );
7127 return rvalue;
7128 }
7129} //proteus
7130
7131#endif
nu_0
double nu_0
Definition ErrorResidualMethod.cpp:22
rho_1
double rho_1
Definition ErrorResidualMethod.cpp:22
nu_1
double nu_1
Definition ErrorResidualMethod.cpp:22
rho_0
double rho_0
Definition ErrorResidualMethod.cpp:22
n
Int n
Definition Headers.h:28
u
Double u
Definition Headers.h:89
vy
Double vy
Definition Headers.h:98
z
Double * z
Definition Headers.h:49
v
Double v
Definition Headers.h:95
psi
Double psi
Definition Headers.h:78
vx
Double vx
Definition Headers.h:97
cMax
#define cMax
Definition NCLS3P.h:11
cE
#define cE
Definition NCLS3P.h:10
DM3
const double DM3
Definition RANS2P.h:25
DM
const double DM
Definition RANS2P.h:23
DM2
const double DM2
Definition RANS2P.h:24
USE_CYLINDER_AS_PARTICLE
#define USE_CYLINDER_AS_PARTICLE
Definition RANS3PF.h:45
C_FOR_GAMMA_INDICATOR
#define C_FOR_GAMMA_INDICATOR
Definition RANS3PF.h:37
sgn3p
double sgn3p(double val)
Definition RANS3PF.h:16
USE_GAMMA_INDICATOR
#define USE_GAMMA_INDICATOR
Definition RANS3PF.h:38
CELL_BASED_EV_COEFF
#define CELL_BASED_EV_COEFF
Definition RANS3PF.h:34
EPS_FOR_GAMMA_INDICATOR
#define EPS_FOR_GAMMA_INDICATOR
Definition RANS3PF.h:36
ANISOTROPIC_DIFFUSION
#define ANISOTROPIC_DIFFUSION
Definition RANS3PF.h:39
equivalent_polynomials::GeneralizedFunctions_mix
Definition equivalent_polynomials.h:1285
equivalent_polynomials::GeneralizedFunctions_mix::useExact
bool useExact
Definition equivalent_polynomials.h:1289
equivalent_polynomials::GeneralizedFunctions_mix::set_quad
void set_quad(unsigned int q)
Definition equivalent_polynomials.h:1325
equivalent_polynomials::GeneralizedFunctions_mix::H
double H(double eps, double phi)
Definition equivalent_polynomials.h:1337
equivalent_polynomials::GeneralizedFunctions_mix::ImH
double ImH(double eps, double phi)
Definition equivalent_polynomials.h:1345
equivalent_polynomials::GeneralizedFunctions_mix::D
double D(double eps, double phi)
Definition equivalent_polynomials.h:1353
equivalent_polynomials::GeneralizedFunctions_mix::calculate
int calculate(const double *phi_dof, const double *phi_nodes, const double *xi_r, double ma, double mb, double jf, bool isBoundary, bool scale)
Definition equivalent_polynomials.h:1294
proteus::cppHsuSedStress::betaCoeff
double betaCoeff(double sedF, double rhoFluid, const double uFluid[nSpace], const double uSolid[nSpace], double nu)
Definition SedClosure.h:71
proteus::cppRANS3PF_base
Definition RANS3PF.h:60
proteus::cppRANS3PF_base::TransportMatrix
std::valarray< double > TransportMatrix
Definition RANS3PF.h:62
proteus::cppRANS3PF_base::vStar_min_hiHe
std::valarray< double > vStar_min_hiHe
Definition RANS3PF.h:65
proteus::cppRANS3PF_base::setSedClosure
virtual void setSedClosure(double aDarcy, double betaForch, double grain, double packFraction, double packMargin, double maxFraction, double frFraction, double sigmaC, double C3e, double C4e, double eR, double fContact, double mContact, double nContact, double angFriction, double vos_limiter, double mu_fr_limiter)
Definition RANS3PF.h:68
proteus::cppRANS3PF_base::uStar_hi
std::valarray< double > uStar_hi
Definition RANS3PF.h:64
proteus::cppRANS3PF_base::TransposeTransportMatrix
std::valarray< double > TransposeTransportMatrix
Definition RANS3PF.h:62
proteus::cppRANS3PF_base::uStar_min_hiHe
std::valarray< double > uStar_min_hiHe
Definition RANS3PF.h:65
proteus::cppRANS3PF_base::wStar_gamma
std::valarray< double > wStar_gamma
Definition RANS3PF.h:66
proteus::cppRANS3PF_base::wStar_min_hiHe
std::valarray< double > wStar_min_hiHe
Definition RANS3PF.h:65
proteus::cppRANS3PF_base::vStar_gamma
std::valarray< double > vStar_gamma
Definition RANS3PF.h:66
proteus::cppRANS3PF_base::uStar_gamma
std::valarray< double > uStar_gamma
Definition RANS3PF.h:66
proteus::cppRANS3PF_base::den_hi
std::valarray< double > den_hi
Definition RANS3PF.h:64
proteus::cppRANS3PF_base::calculateJacobian
virtual void calculateJacobian(arguments_dict &args, bool useExact)=0
proteus::cppRANS3PF_base::~cppRANS3PF_base
virtual ~cppRANS3PF_base()
Definition RANS3PF.h:67
proteus::cppRANS3PF_base::calculateVelocityAverage
virtual void calculateVelocityAverage(arguments_dict &args)=0
proteus::cppRANS3PF_base::getBoundaryDOFs
virtual void getBoundaryDOFs(arguments_dict &args)=0
proteus::cppRANS3PF_base::vStar_hi
std::valarray< double > vStar_hi
Definition RANS3PF.h:64
proteus::cppRANS3PF_base::vStar_psi
std::valarray< double > vStar_psi
Definition RANS3PF.h:63
proteus::cppRANS3PF_base::wStar_hi
std::valarray< double > wStar_hi
Definition RANS3PF.h:64
proteus::cppRANS3PF_base::calculateResidual
virtual void calculateResidual(arguments_dict &args, bool useExact)=0
proteus::cppRANS3PF_base::uStar_psi
std::valarray< double > uStar_psi
Definition RANS3PF.h:63
proteus::cppRANS3PF_base::wStar_psi
std::valarray< double > wStar_psi
Definition RANS3PF.h:63
proteus::cppRANS3PF::calculateVelocityAverage
void calculateVelocityAverage(arguments_dict &args)
Definition RANS3PF.h:6813
proteus::cppRANS3PF::updateSolidParticleTerms
void updateSolidParticleTerms(bool element_owned, const double particle_nitsche, const double dV, const int nParticles, const int sd_offset, double *particle_signed_distances, double *particle_signed_distance_normals, double *particle_velocities, double *particle_centroids, int use_ball_as_particle, double *ball_center, double *ball_radius, double *ball_velocity, double *ball_angular_velocity, const double porosity, const double penalty, const double alpha, const double beta, const double eps_rho, const double eps_mu, const double rho_0, const double nu_0, const double rho_1, const double nu_1, const double useVF, const double vf, const double phi, const double x, const double y, const double z, const double p, const double u, const double v, const double w, const double uStar, const double vStar, const double wStar, const double eps_s, const double grad_u[nSpace], const double grad_v[nSpace], const double grad_w[nSpace], double &mom_u_source, double &mom_v_source, double &mom_w_source, double dmom_u_source[nSpace], double dmom_v_source[nSpace], double dmom_w_source[nSpace], double mom_u_adv[nSpace], double mom_v_adv[nSpace], double mom_w_adv[nSpace], double dmom_u_adv_u[nSpace], double dmom_v_adv_v[nSpace], double dmom_w_adv_w[nSpace], double &mom_u_ham, double dmom_u_ham_grad_u[nSpace], double &mom_v_ham, double dmom_v_ham_grad_v[nSpace], double &mom_w_ham, double dmom_w_ham_grad_w[nSpace], double *particle_netForces, double *particle_netMoments, double *particle_surfaceArea)
Definition RANS3PF.h:601
proteus::cppRANS3PF::exteriorNumericalAdvectiveFluxDerivatives
void exteriorNumericalAdvectiveFluxDerivatives(const int &isDOFBoundary_p, const int &isDOFBoundary_u, const int &isDOFBoundary_v, const int &isDOFBoundary_w, const int &isFluxBoundary_p, const int &isFluxBoundary_u, const int &isFluxBoundary_v, const int &isFluxBoundary_w, const double &oneByRho, const double n[nSpace], const double &porosity, const double &bc_p, const double &bc_u, const double &bc_v, const double &bc_w, const double bc_f_mass[nSpace], const double bc_f_umom[nSpace], const double bc_f_vmom[nSpace], const double bc_f_wmom[nSpace], const double &bc_flux_mass, const double &bc_flux_umom, const double &bc_flux_vmom, const double &bc_flux_wmom, const double &p, const double &u, const double &v, const double &w, const double f_mass[nSpace], const double f_umom[nSpace], const double f_vmom[nSpace], const double f_wmom[nSpace], const double df_mass_du[nSpace], const double df_mass_dv[nSpace], const double df_mass_dw[nSpace], const double df_umom_dp[nSpace], const double df_umom_du[nSpace], const double df_umom_dv[nSpace], const double df_umom_dw[nSpace], const double df_vmom_dp[nSpace], const double df_vmom_du[nSpace], const double df_vmom_dv[nSpace], const double df_vmom_dw[nSpace], const double df_wmom_dp[nSpace], const double df_wmom_du[nSpace], const double df_wmom_dv[nSpace], const double df_wmom_dw[nSpace], double &dflux_mass_du, double &dflux_mass_dv, double &dflux_mass_dw, double &dflux_umom_dp, double &dflux_umom_du, double &dflux_umom_dv, double &dflux_umom_dw, double &dflux_vmom_dp, double &dflux_vmom_du, double &dflux_vmom_dv, double &dflux_vmom_dw, double &dflux_wmom_dp, double &dflux_wmom_du, double &dflux_wmom_dv, double &dflux_wmom_dw, double *velocity_star)
Definition RANS3PF.h:1164
proteus::cppRANS3PF::getBoundaryDOFs
void getBoundaryDOFs(arguments_dict &args)
Definition RANS3PF.h:6988
proteus::cppRANS3PF::updateTurbulenceClosure
void updateTurbulenceClosure(const int turbulenceClosureModel, const double eps_rho, const double eps_mu, const double rho_0, const double nu_0, const double rho_1, const double nu_1, const double useVF, const double vf, const double phi, const double porosity, const double eddy_visc_coef_0, const double turb_var_0, const double turb_var_1, const double turb_grad_0[nSpace], double &eddy_viscosity, double mom_uu_diff_ten[nSpace], double mom_vv_diff_ten[nSpace], double mom_ww_diff_ten[nSpace], double mom_uv_diff_ten[1], double mom_uw_diff_ten[1], double mom_vu_diff_ten[1], double mom_vw_diff_ten[1], double mom_wu_diff_ten[1], double mom_wv_diff_ten[1], double &mom_u_source, double &mom_v_source, double &mom_w_source)
Definition RANS3PF.h:812
proteus::cppRANS3PF::get_distance_to_ith_ball
void get_distance_to_ith_ball(int n_balls, double *ball_center, double *ball_radius, int I, double x, double y, double z, double &distance)
Definition RANS3PF.h:1456
proteus::cppRANS3PF::closure
cppHsuSedStress< 3 > closure
Definition RANS3PF.h:108
proteus::cppRANS3PF::calculateSubgridError_tau
void calculateSubgridError_tau(const double &Ct_sge, const double &Cd_sge, const double G[nSpace *nSpace], const double &G_dd_G, const double &tr_G, const double &A0, const double Ai[nSpace], const double &Kij, const double &pfac, double &tau_v, double &tau_p, double &q_cfl)
Definition RANS3PF.h:936
proteus::cppRANS3PF::get_velocity_to_ith_ball
void get_velocity_to_ith_ball(int n_balls, double *ball_center, double *ball_radius, double *ball_velocity, double *ball_angular_velocity, int I, double x, double y, double z, double &vx, double &vy, double &vz)
Definition RANS3PF.h:1487
proteus::cppRANS3PF::gf_s
GeneralizedFunctions< nSpace, 1, nQuadraturePoints_element, nQuadraturePoints_elementBoundary > gf_s
Definition RANS3PF.h:113
proteus::cppRANS3PF::surrogate_boundary_elements
std::vector< int > surrogate_boundary_elements
Definition RANS3PF.h:106
proteus::cppRANS3PF::calculateSubgridError_tauRes
void calculateSubgridError_tauRes(const double &tau_p, const double &tau_v, const double &pdeResidualP, const double &pdeResidualU, const double &pdeResidualV, const double &pdeResidualW, double &subgridErrorP, double &subgridErrorU, double &subgridErrorV, double &subgridErrorW)
Definition RANS3PF.h:957
proteus::cppRANS3PF::exteriorNumericalDiffusiveFlux
void exteriorNumericalDiffusiveFlux(const double &eps, const double &phi, int *rowptr, int *colind, const int &isDOFBoundary, const int &isFluxBoundary, const double n[nSpace], double *bc_a, const double &bc_u, const double &bc_flux, double *a, const double grad_potential[nSpace], const double &u, const double &penalty, double &flux)
Definition RANS3PF.h:1321
proteus::cppRANS3PF::calculateJacobian
void calculateJacobian(arguments_dict &args, bool useExact)
Definition RANS3PF.h:4443
proteus::cppRANS3PF::ExteriorNumericalDiffusiveFluxJacobian
double ExteriorNumericalDiffusiveFluxJacobian(const double &eps, const double &phi, int *rowptr, int *colind, const int &isDOFBoundary, const int &isFluxBoundary, const double n[nSpace], double *a, const double &v, const double grad_v[nSpace], const double &penalty)
Definition RANS3PF.h:1369
proteus::cppRANS3PF::setSedClosure
void setSedClosure(double aDarcy, double betaForch, double grain, double packFraction, double packMargin, double maxFraction, double frFraction, double sigmaC, double C3e, double C4e, double eR, double fContact, double mContact, double nContact, double angFriction, double vos_limiter, double mu_fr_limiter)
Definition RANS3PF.h:150
proteus::cppRANS3PF::exteriorNumericalAdvectiveFlux
void exteriorNumericalAdvectiveFlux(const int &isDOFBoundary_p, const int &isDOFBoundary_u, const int &isDOFBoundary_v, const int &isDOFBoundary_w, const int &isFluxBoundary_p, const int &isFluxBoundary_u, const int &isFluxBoundary_v, const int &isFluxBoundary_w, const double &oneByRho, const double &bc_oneByRho, const double n[nSpace], const double &porosity, const double &bc_p, const double &bc_u, const double &bc_v, const double &bc_w, const double bc_f_mass[nSpace], const double bc_f_umom[nSpace], const double bc_f_vmom[nSpace], const double bc_f_wmom[nSpace], const double &bc_flux_mass, const double &bc_flux_umom, const double &bc_flux_vmom, const double &bc_flux_wmom, const double &p, const double &u, const double &v, const double &w, const double f_mass[nSpace], const double f_umom[nSpace], const double f_vmom[nSpace], const double f_wmom[nSpace], const double df_mass_du[nSpace], const double df_mass_dv[nSpace], const double df_mass_dw[nSpace], const double df_umom_dp[nSpace], const double df_umom_du[nSpace], const double df_umom_dv[nSpace], const double df_umom_dw[nSpace], const double df_vmom_dp[nSpace], const double df_vmom_du[nSpace], const double df_vmom_dv[nSpace], const double df_vmom_dw[nSpace], const double df_wmom_dp[nSpace], const double df_wmom_du[nSpace], const double df_wmom_dv[nSpace], const double df_wmom_dw[nSpace], double &flux_mass, double &flux_umom, double &flux_vmom, double &flux_wmom, double *velocity_star, double *velocity)
Definition RANS3PF.h:1017
proteus::cppRANS3PF::calculateResidual
void calculateResidual(arguments_dict &args, bool useExact)
Definition RANS3PF.h:1505
proteus::cppRANS3PF::gf
GeneralizedFunctions< nSpace, 1, nQuadraturePoints_element, nQuadraturePoints_elementBoundary > gf
Definition RANS3PF.h:112
proteus::cppRANS3PF::Dot
double Dot(const double vec1[nSpace], const double vec2[nSpace])
Definition RANS3PF.h:187
proteus::cppRANS3PF::get_cross_product
void get_cross_product(const double *u, const double *v, double res[3])
Definition RANS3PF.h:1425
proteus::cppRANS3PF::calculateSubgridError_tau
void calculateSubgridError_tau(const double &hFactor, const double &elementDiameter, const double &dmt, const double &dm, const double df[nSpace], const double &a, const double &pfac, double &tau_v, double &tau_p, double &cfl)
Definition RANS3PF.h:908
proteus::cppRANS3PF::evaluateCoefficients
void evaluateCoefficients(const double eps_rho, const double eps_mu, const double eps_s, const double sigma, const double rho_0, double nu_0, const double rho_1, double nu_1, const double h_e, const double smagorinskyConstant, const int turbulenceClosureModel, const double g[nSpace], const double useVF, const double &vf, const double &phi, const double n[nSpace], const double distance_to_omega_solid, const double &kappa, const double porosity, const double &p, const double grad_p[nSpace], const double grad_u[nSpace], const double grad_v[nSpace], const double grad_w[nSpace], const double &u, const double &v, const double &w, const double &uStar, const double &vStar, const double &wStar, double &eddy_viscosity, double &mom_u_acc, double &dmom_u_acc_u, double &mom_v_acc, double &dmom_v_acc_v, double &mom_w_acc, double &dmom_w_acc_w, double mass_adv[nSpace], double dmass_adv_u[nSpace], double dmass_adv_v[nSpace], double dmass_adv_w[nSpace], double mom_u_adv[nSpace], double dmom_u_adv_u[nSpace], double dmom_u_adv_v[nSpace], double dmom_u_adv_w[nSpace], double mom_v_adv[nSpace], double dmom_v_adv_u[nSpace], double dmom_v_adv_v[nSpace], double dmom_v_adv_w[nSpace], double mom_w_adv[nSpace], double dmom_w_adv_u[nSpace], double dmom_w_adv_v[nSpace], double dmom_w_adv_w[nSpace], double mom_uu_diff_ten[nSpace], double mom_vv_diff_ten[nSpace], double mom_ww_diff_ten[nSpace], double mom_uv_diff_ten[1], double mom_uw_diff_ten[1], double mom_vu_diff_ten[1], double mom_vw_diff_ten[1], double mom_wu_diff_ten[1], double mom_wv_diff_ten[1], double &mom_u_source, double &mom_v_source, double &mom_w_source, double &mom_u_ham, double dmom_u_ham_grad_p[nSpace], double dmom_u_ham_grad_u[nSpace], double &mom_v_ham, double dmom_v_ham_grad_p[nSpace], double dmom_v_ham_grad_v[nSpace], double &mom_w_ham, double dmom_w_ham_grad_p[nSpace], double dmom_w_ham_grad_w[nSpace], double &rhoSave, double &nuSave, int KILL_PRESSURE_TERM, int MULTIPLY_EXTERNAL_FORCE_BY_DENSITY, double forcex, double forcey, double forcez, int MATERIAL_PARAMETERS_AS_FUNCTION, double density_as_function, double dynamic_viscosity_as_function, int USE_SBM, double x, double y, double z, int use_ball_as_particle, double *ball_center, double *ball_radius, double *ball_velocity, double *ball_angular_velocity, int INT_BY_PARTS_PRESSURE)
Definition RANS3PF.h:206
proteus::cppRANS3PF::updateDarcyForchheimerTerms_Ergun
void updateDarcyForchheimerTerms_Ergun(const double alpha, const double beta, const double eps_rho, const double eps_mu, const double rho_0, const double nu_0, const double rho_1, const double nu_1, double nu_t, const double useVF, const double vf, const double phi, const double u, const double v, const double w, const double uStar, const double vStar, const double wStar, const double eps_s, const double phi_s, const double u_s, const double v_s, const double w_s, const double uStar_s, const double vStar_s, const double wStar_s, double &mom_u_source, double &mom_v_source, double &mom_w_source, double dmom_u_source[nSpace], double dmom_v_source[nSpace], double dmom_w_source[nSpace], double gradC_x, double gradC_y, double gradC_z)
Definition RANS3PF.h:526
proteus::cppRANS3PF::nSpace2
const int nSpace2
Definition RANS3PF.h:110
proteus::cppRANS3PF::get_normal_to_ith_ball
void get_normal_to_ith_ball(int n_balls, double *ball_center, double *ball_radius, int I, double x, double y, double z, double &nx, double &ny, double &nz)
Definition RANS3PF.h:1468
proteus::cppRANS3PF::surrogate_boundaries
std::vector< int > surrogate_boundaries
Definition RANS3PF.h:106
proteus::cppRANS3PF::get_distance_to_ball
int get_distance_to_ball(int n_balls, double *ball_center, double *ball_radius, double x, double y, double z, double &distance)
Definition RANS3PF.h:1435
proteus::cppRANS3PF::get_stress_in_n
void get_stress_in_n(const double *grad_u, const double *grad_v, const double *grad_w, const double *n, double p, double mu, double f[3])
Definition RANS3PF.h:1411
proteus::cppRANS3PF::get_dot_product
double get_dot_product(const double *u, const double *v)
Definition RANS3PF.h:1431
proteus::cppRANS3PF::surrogate_boundary_particle
std::vector< int > surrogate_boundary_particle
Definition RANS3PF.h:106
proteus::cppRANS3PF::calculateTangentialGradient
void calculateTangentialGradient(const double normal[nSpace], const double vel_grad[nSpace], double vel_tgrad[nSpace])
Definition RANS3PF.h:196
proteus::cppRANS3PF::ck
CompKernelType ck
Definition RANS3PF.h:111
proteus::cppRANS3PF::calculateSubgridErrorDerivatives_tauRes
void calculateSubgridErrorDerivatives_tauRes(const double &tau_p, const double &tau_v, const double dpdeResidualP_du[nDOF_trial_element], const double dpdeResidualP_dv[nDOF_trial_element], const double dpdeResidualP_dw[nDOF_trial_element], const double dpdeResidualU_dp[nDOF_trial_element], const double dpdeResidualU_du[nDOF_trial_element], const double dpdeResidualV_dp[nDOF_trial_element], const double dpdeResidualV_dv[nDOF_trial_element], const double dpdeResidualW_dp[nDOF_trial_element], const double dpdeResidualW_dw[nDOF_trial_element], double dsubgridErrorP_du[nDOF_trial_element], double dsubgridErrorP_dv[nDOF_trial_element], double dsubgridErrorP_dw[nDOF_trial_element], double dsubgridErrorU_dp[nDOF_trial_element], double dsubgridErrorU_du[nDOF_trial_element], double dsubgridErrorV_dp[nDOF_trial_element], double dsubgridErrorV_dv[nDOF_trial_element], double dsubgridErrorW_dp[nDOF_trial_element], double dsubgridErrorW_dw[nDOF_trial_element])
Definition RANS3PF.h:976
proteus::cppRANS3PF::nDOF_test_X_trial_element
const int nDOF_test_X_trial_element
Definition RANS3PF.h:109
proteus::cppRANS3PF::calculateCFL
void calculateCFL(const double &hFactor, const double &elementDiameter, const double &dm, const double df[nSpace], double &cfl)
Definition RANS3PF.h:793
proteus::cppRANS3PF::get_symmetric_gradient_dot_vec
void get_symmetric_gradient_dot_vec(const double *grad_u, const double *grad_v, const double *grad_w, const double *n, double res[3])
Definition RANS3PF.h:1401
equivalent_polynomials.h
df
double df(double C, double b, double a, int q, int r)
Definition analyticalSolutions.c:2209
vel
void vel(double rS, double norm_v, double r, double theta, double *vR, double *vTHETA)
Definition analyticalSolutions.c:2163
w
#define w(x)
Definition jf.h:22
POWER_SMOOTHNESS_INDICATOR
#define POWER_SMOOTHNESS_INDICATOR
Definition m_comp_co2.h:22
proteus
Definition ADR.h:19
proteus::GeneralizedFunctions
equivalent_polynomials::GeneralizedFunctions_mix< nSpace, nP_ifem, nP, nQ, nEBQ, true > GeneralizedFunctions
Definition ADR.h:21
proteus::phi
double phi(const double &g, const double &h, const double &hL, const double &hR, const double &uL, const double &uR)
Definition SW2DCV.h:62
proteus::newRANS3PF
cppRANS3PF_base * newRANS3PF(int nSpaceIn, int nQuadraturePoints_elementIn, int nDOF_mesh_trial_elementIn, int nDOF_trial_elementIn, int nDOF_test_elementIn, int nQuadraturePoints_elementBoundaryIn, int CompKernelFlag, double aDarcy, double betaForch, double grain, double packFraction, double packMargin, double maxFraction, double frFraction, double sigmaC, double C3e, double C4e, double eR, double fContact, double mContact, double nContact, double angFriction, double vos_limiter, double mu_fr_limiter)
Definition RANS3PF.h:7076
proteus::chooseAndAllocateDiscretization
Model_Base * chooseAndAllocateDiscretization(int nSpaceIn, int nQuadraturePoints_elementIn, int nDOF_mesh_trial_elementIn, int nDOF_trial_elementIn, int nDOF_test_elementIn, int nDOF_v_trial_elementIn, int nDOF_v_test_elementIn, int nQuadraturePoints_elementBoundaryIn, int CompKernelFlag)
Definition MixedModelFactory.h:48
proteus::f
double f(const double &g, const double &h, const double &hZ)
Definition SW2DCV.h:58
proteus::arguments_dict
Definition ArgumentsDict.h:70
proteus::arguments_dict::scalar
T & scalar(const std::string &key)
proteus::arguments_dict::array
xt::pyarray< T > & array(const std::string &key)
Generated on for proteus by doxygen 1.18.0