Finite Element Domain Decomposition Library
FEDDLib
Loading...
Searching...
No Matches
AssembleFENavierStokes_def.hpp
1#ifndef ASSEMBLEFENAVIERSTOKES_DEF_hpp
2#define ASSEMBLEFENAVIERSTOKES_DEF_hpp
3
4namespace FEDD {
5
6template <class SC, class LO, class GO, class NO>
7AssembleFENavierStokes<SC,LO,GO,NO>::AssembleFENavierStokes(int flag, vec2D_dbl_Type nodesRefConfig, ParameterListPtr_Type params,tuple_disk_vec_ptr_Type tuple):
8AssembleFE<SC,LO,GO,NO>(flag, nodesRefConfig, params,tuple)
9{
10 int locVelocity=0;
11 int locPressure=0;
12 if(std::get<0>(this->diskTuple_->at(0))=="Velocity"){
13 locVelocity=0;
14 locPressure=1;
15 }
16 else if(std::get<0>(this->diskTuple_->at(1))=="Velocity"){
17 locVelocity=1;
18 locPressure=0;
19 }
20 else
21 TEUCHOS_TEST_FOR_EXCEPTION( true, std::logic_error, "No discretisation Information for Velocity in Navier Stokes Element." );
22
23
26 FETypeVelocity_ = std::get<1>(this->diskTuple_->at(locVelocity));
27 FETypePressure_ =std::get<1>(this->diskTuple_->at(locPressure));
28
29 dofsVelocity_ = std::get<2>(this->diskTuple_->at(locVelocity));
30 dofsPressure_ =std::get<2>(this->diskTuple_->at(locPressure));
31
32 numNodesVelocity_ = std::get<3>(this->diskTuple_->at(locVelocity));
33 numNodesPressure_=std::get<3>(this->diskTuple_->at(locPressure));
34
35 dofsElementVelocity_ = dofsVelocity_*numNodesVelocity_;
36 dofsElementPressure_ = dofsPressure_*numNodesPressure_;
37
38 //this->solution_ = vec_dbl_Type(dofsElementVelocity_); //dofsElementPressure_+
39 this->solutionVelocity_ = vec_dbl_Type(dofsElementVelocity_);
40 this->solutionPressure_ = vec_dbl_Type(dofsElementPressure_);
41
42 viscosity_ = this->params_->sublist("Parameter").get("Viscosity",1.);
43 density_ = this->params_->sublist("Parameter").get("Density",1.);
44
45 dofsElement_ = dofsElementVelocity_+ dofsElementPressure_;
46
47 SmallMatrix_Type coeff(2);
48 coeff[0][0]=1.; coeff[0][1] = 1.; coeff[1][0] = 1.; coeff[1][1] = 1.; // we keep it constant like this for now. For BDF time disc. okay.
49 coeff_ = coeff;
50
51 // Set the linearization type for the assembleFEElement objects
52 if(this->params_->sublist("General").get("Linearization","FixedPoint") == "FixedPointNewton")
53 {
54 this->linearization_ = this->params_->sublist("General").get("Initial_Linearization","FixedPoint"); // Default is FixedPoint
55 }
56 else
57 {
58 this->linearization_ = this->params_->sublist("General").get("Linearization","FixedPoint");
59 }
60}
61
62template <class SC, class LO, class GO, class NO>
63void AssembleFENavierStokes<SC,LO,GO,NO>::setCoeff(SmallMatrix_Type coeff) {
64 // We only substitute the coefficients if the matrix has the same
65 // size. In some non timedepenent cases the coeff matrix can be empty.
66 // We prevent that case.
67 if(coeff.size() == 2)
68 coeff_ = coeff;
69
70}
71
72template <class SC, class LO, class GO, class NO>
73void AssembleFENavierStokes<SC,LO,GO,NO>::assembleJacobian() {
74
75 SmallMatrixPtr_Type elementMatrixN =Teuchos::rcp( new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_));
76 SmallMatrixPtr_Type elementMatrixW =Teuchos::rcp( new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_));
77
78 if(this->newtonStep_ ==0){
79
80 SmallMatrixPtr_Type elementMatrixA =Teuchos::rcp( new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_));
81 SmallMatrixPtr_Type elementMatrixB =Teuchos::rcp( new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_));
82
83 constantMatrix_.reset(new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_));
84
85 assemblyLaplacian(elementMatrixA);
86
87 elementMatrixA->scale(viscosity_);
88 elementMatrixA->scale(density_);
89
90 constantMatrix_->add( (*elementMatrixA),(*constantMatrix_));
91
92 assemblyDivAndDivT(elementMatrixB); // For Matrix B
93
94 elementMatrixB->scale(-1.);
95
96 constantMatrix_->add( (*elementMatrixB),(*constantMatrix_));
97 }
98
99 ANB_.reset(new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_)); // A + B + N
100 ANB_->add( (*constantMatrix_),(*ANB_));
101
102 assemblyAdvection(elementMatrixN);
103 elementMatrixN->scale(density_);
104 ANB_->add( (*elementMatrixN),(*ANB_));
105 if(this->linearization_ != "FixedPoint"){
106 assemblyAdvectionInU(elementMatrixW);
107 elementMatrixW->scale(density_);
108 }
109
110 //elementMatrix->add((*constantMatrix_),(*elementMatrix));
111 this->jacobian_.reset(new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_));
112
113 this->jacobian_->add((*ANB_),(*this->jacobian_));
114 // If the linearization is Newtons Method we need to add W-Matrix
115 if(this->linearization_ != "FixedPoint"){
116 this->jacobian_->add((*elementMatrixW),(*this->jacobian_)); // int add(SmallMatrix<T> &bMat, SmallMatrix<T> &cMat); //this+B=C elementMatrix + constantMatrix_;
117 }
118}
119
120template <class SC, class LO, class GO, class NO>
121void AssembleFENavierStokes<SC,LO,GO,NO>::assembleFixedPoint() {
122
123 SmallMatrixPtr_Type elementMatrixN =Teuchos::rcp( new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_));
124
125 if(this->newtonStep_ ==0){
126 SmallMatrixPtr_Type elementMatrixA =Teuchos::rcp( new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_));
127 SmallMatrixPtr_Type elementMatrixB =Teuchos::rcp( new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_));
128
129 constantMatrix_.reset(new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_));
130
131 assemblyLaplacian(elementMatrixA);
132
133 elementMatrixA->scale(viscosity_);
134 elementMatrixA->scale(density_);
135
136 constantMatrix_->add( (*elementMatrixA),(*constantMatrix_));
137
138 assemblyDivAndDivT(elementMatrixB); // For Matrix B
139
140 elementMatrixB->scale(-1.);
141
142 constantMatrix_->add( (*elementMatrixB),(*constantMatrix_));
143 }
144
145 ANB_.reset(new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_)); // A + B + N
146 ANB_->add( (*constantMatrix_),(*ANB_));
147
148 assemblyAdvection(elementMatrixN);
149 elementMatrixN->scale(density_);
150 ANB_->add( (*elementMatrixN),(*ANB_));
151
152}
153
154
155template <class SC, class LO, class GO, class NO>
156void AssembleFENavierStokes<SC,LO,GO,NO>::assemblyLaplacian(SmallMatrixPtr_Type &elementMatrix) {
157
158 int dim = this->getDim();
159 int numNodes= numNodesVelocity_;
160 std::string FEType = FETypeVelocity_;
161 int dofs = dofsVelocity_;
162
163 vec3D_dbl_ptr_Type dPhi;
164 vec_dbl_ptr_Type weights = Teuchos::rcp(new vec_dbl_Type(0));
165
166 // inner( grad(u) , grad(v) ) has twice the polyonimial degree than grad(u) or grad(v).
167 UN deg = 2*Helper::determineDegree(dim,FEType,Helper::Deriv1);
168 // std::cout << " Degree Laplace " << deg << " Grad " << Grad << " FeType " << FEType << std::endl;
169 Helper::getDPhi(dPhi, weights, dim, FEType, deg);
170
171 SC detB;
172 SC absDetB;
173 SmallMatrix<SC> B(dim);
174 SmallMatrix<SC> Binv(dim);
175
176 buildTransformation(B);
177
178 detB = B.computeInverse(Binv);
179 absDetB = std::fabs(detB);
180
181 vec3D_dbl_Type dPhiTrans( dPhi->size(), vec2D_dbl_Type( dPhi->at(0).size(), vec_dbl_Type(dim,0.) ) );
182 Helper::applyBTinv( dPhi, dPhiTrans, Binv );
183
184 for (UN i=0; i < numNodes; i++) {
185 Teuchos::Array<SC> value( dPhiTrans[0].size(), 0. );
186 for (UN j=0; j < numNodes; j++) {
187 for (UN w=0; w<dPhiTrans.size(); w++) {
188 for (UN d=0; d<dim; d++){
189 value[j] += weights->at(w) * dPhiTrans[w][i][d] * dPhiTrans[w][j][d];
190 }
191 }
192 value[j] *= absDetB;
193 /*if (std::fabs(value[j]) < std::pow(10,-14)) {
194 value[j] = 0.;
195 }*/
196 for (UN d=0; d<dofs; d++) {
197 (*elementMatrix)[i*dofs +d][j*dofs+d] = value[j];
198 }
199 }
200
201 }
202}
203
204// Assemble RHS with updated solution coming from Fixed Point Iter or der Newton.
205template <class SC, class LO, class GO, class NO>
206void AssembleFENavierStokes<SC,LO,GO,NO>::assembleRHS(){
207
208 SmallMatrixPtr_Type elementMatrixN =Teuchos::rcp( new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_));
209
210 ANB_.reset(new SmallMatrix_Type( dofsElementVelocity_+numNodesPressure_)); // A + B + N
211 ANB_->add( (*constantMatrix_),(*ANB_));
212
213 assemblyAdvection(elementMatrixN);
214 elementMatrixN->scale(density_);
215 ANB_->add( (*elementMatrixN),(*ANB_));
216
217 this->rhsVec_.reset( new vec_dbl_Type ( dofsElement_,0.) );
218 // Multiplying ANB_ * solution // ANB Matrix without nonlinear part.
219 int s=0,t=0;
220 for(int i=0 ; i< ANB_->size();i++){
221 if (i >= dofsElementVelocity_)
222 s=1;
223 for(int j=0; j < ANB_->size(); j++){
224 if(j >= dofsElementVelocity_)
225 t=1;
226 (*this->rhsVec_)[i] += (*ANB_)[i][j]*(*this->solution_)[j]*coeff_[s][t];
227 }
228 t=0;
229 }
230}
231
232
233template <class SC, class LO, class GO, class NO>
234void AssembleFENavierStokes<SC,LO,GO,NO>::assemblyAdvection(SmallMatrixPtr_Type &elementMatrix){
235
236 int dim = this->getDim();
237 int numNodes= numNodesVelocity_;
238 std::string FEType = FETypeVelocity_;
239 int dofs = dofsVelocity_;
240
241 vec3D_dbl_ptr_Type dPhi;
242 vec2D_dbl_ptr_Type phi;
243 vec_dbl_ptr_Type weights = Teuchos::rcp(new vec_dbl_Type(0));
244
245 // inner( inner( uh , nabla )phi_j , phi_i )
246 // For uh: degPhi, for nabla phi_j: degGradPhi, for phi_i: degPhi.
247 UN degPhi = Helper::determineDegree(dim,FEType,Helper::Deriv0);
248 UN degGradPhi = Helper::determineDegree(dim,FEType,Helper::Deriv1);
249 UN deg = degPhi + degGradPhi + degPhi;
250
251 Helper::getDPhi(dPhi, weights, dim, FEType, deg);
252 Helper::getPhi(phi, weights, dim, FEType, deg);
253
254 SC detB;
255 SC absDetB;
256 SmallMatrix<SC> B(dim);
257 SmallMatrix<SC> Binv(dim);
258
259 vec2D_dbl_Type uLoc( dim, vec_dbl_Type( weights->size() , -1. ) );
260
261 buildTransformation(B);
262 detB = B.computeInverse(Binv);
263 absDetB = std::fabs(detB);
264
265 vec3D_dbl_Type dPhiTrans( dPhi->size(), vec2D_dbl_Type( dPhi->at(0).size(), vec_dbl_Type(dim,0.) ) );
266 Helper::applyBTinv( dPhi, dPhiTrans, Binv );
267
268 for (int w=0; w<phi->size(); w++){ //quads points
269 for (int d=0; d<dim; d++) {
270 uLoc[d][w] = 0.;
271 for (int i=0; i < phi->at(0).size(); i++) {
272 LO index = dim * i + d;
273 uLoc[d][w] += (*this->solution_)[index] * phi->at(w).at(i);
274 }
275 }
276
277 }
278
279 for (UN i=0; i < phi->at(0).size(); i++) {
280 Teuchos::Array<SC> value( dPhiTrans[0].size(), 0. );
281 Teuchos::Array<GO> indices( dPhiTrans[0].size(), 0 );
282 for (UN j=0; j < value.size(); j++) {
283 for (UN w=0; w<dPhiTrans.size(); w++) {
284 for (UN d=0; d<dim; d++){
285 value[j] += weights->at(w) * uLoc[d][w] * (*phi)[w][i] * dPhiTrans[w][j][d];
286 }
287 }
288 value[j] *= absDetB;
289
290 /*if (setZeros_ && std::fabs(value[j]) < myeps_) {
291 value[j] = 0.;
292 }*/
293
294
295 }
296 for (UN d=0; d<dim; d++) {
297 for (UN j=0; j < indices.size(); j++)
298 (*elementMatrix)[i*dofs +d][j*dofs+d] = value[j];
299
300 }
301
302 }
303
304}
305
306
307template <class SC, class LO, class GO, class NO>
308void AssembleFENavierStokes<SC,LO,GO,NO>::assemblyAdvectionInU(SmallMatrixPtr_Type &elementMatrix){
309
310 int dim = this->getDim();
311 int numNodes= numNodesVelocity_;
312 std::string FEType = FETypeVelocity_;
313 int dofs = dofsVelocity_;
314
315
316 vec3D_dbl_ptr_Type dPhi;
317 vec2D_dbl_ptr_Type phi;
318 vec_dbl_ptr_Type weights = Teuchos::rcp(new vec_dbl_Type(0));
319
320 // inner( inner( phi_j , nabla )uh , phi_i )
321 // For phi_j: degPhi, for nabla uh: degGradPhi, for phi_i: degPhi.
322 UN degPhi = Helper::determineDegree(dim,FEType,Helper::Deriv0);
323 UN degGradPhi = Helper::determineDegree(dim,FEType,Helper::Deriv1);
324 UN deg = degPhi + degGradPhi + degPhi;
325
326 Helper::getDPhi(dPhi, weights, dim, FEType, deg);
327 Helper::getPhi(phi, weights, dim, FEType, deg);
328
329 SC detB;
330 SC absDetB;
331 SmallMatrix<SC> B(dim);
332 SmallMatrix<SC> Binv(dim);
333
334 vec2D_dbl_Type uLoc( dim, vec_dbl_Type( weights->size() , -1. ) );
335
336 buildTransformation(B);
337 detB = B.computeInverse(Binv);
338 absDetB = std::fabs(detB);
339
340 vec3D_dbl_Type dPhiTrans( dPhi->size(), vec2D_dbl_Type( dPhi->at(0).size(), vec_dbl_Type(dim,0.) ) );
341 Helper::applyBTinv( dPhi, dPhiTrans, Binv );
342 //UN FEloc = checkFE(dim,FEType);
343
344
345 std::vector<SmallMatrix<SC> > duLoc( weights->size(), SmallMatrix<SC>(dim) ); //for all quad points p_i each matrix is [u_x * grad Phi(p_i), u_y * grad Phi(p_i), u_z * grad Phi(p_i) (if 3D) ], duLoc[w] = [[phixx;phixy],[phiyx;phiyy]] (2D)
346
347 for (int w=0; w<dPhiTrans.size(); w++){ //quads points
348 for (int d1=0; d1<dim; d1++) {
349 for (int i=0; i < dPhiTrans[0].size(); i++) {
350 LO index = dim *i+ d1;
351 for (int d2=0; d2<dim; d2++)
352 duLoc[w][d2][d1] += (*this->solution_)[index] * dPhiTrans[w][i][d2];
353 }
354 }
355 }
356
357 for (UN i=0; i < phi->at(0).size(); i++) {
358 for (UN d1=0; d1<dim; d1++) {
359 Teuchos::Array<SC> value( dim*phi->at(0).size(), 0. ); //These are value (W_ix,W_iy,W_iz)
360 for (UN j=0; j < phi->at(0).size(); j++) {
361 for (UN d2=0; d2<dim; d2++){
362 for (UN w=0; w<phi->size(); w++) {
363 value[ dim * j + d2 ] += weights->at(w) * duLoc[w][d2][d1] * (*phi)[w][i] * (*phi)[w][j];
364 }
365 value[ dim * j + d2 ] *= absDetB;
366 }
367 }
368 for (UN j=0; j < phi->at(0).size(); j++){
369 for (UN d=0; d<dofs; d++) {
370 (*elementMatrix)[i*dofs +d1][j*dofs+d] = value[j*dofs+d];
371 }
372 }
373
374 }
375 }
376}
377
378
379
380template <class SC, class LO, class GO, class NO>
381void AssembleFENavierStokes<SC,LO,GO,NO>::assemblyDivAndDivT(SmallMatrixPtr_Type &elementMatrix) {
382
383 vec3D_dbl_ptr_Type dPhi;
384 vec2D_dbl_ptr_Type phi;
385 vec_dbl_ptr_Type weights = Teuchos::rcp(new vec_dbl_Type(0));
386 int dim = this->dim_;
387
388 // psi_k * div(phi_j)
389 // for pressure function psi_k: degPhi_pres, for velocity term div(phi_j): degGradPhi_vel
390 UN degGradPhi_vel = Helper::determineDegree(dim,FETypeVelocity_,Helper::Deriv1);
391 UN degPhi_pres = Helper::determineDegree(dim,FETypePressure_,Helper::Deriv0);
392 UN deg = degGradPhi_vel + degPhi_pres;
393
394 Helper::getDPhi(dPhi, weights, dim, FETypeVelocity_, deg);
395
396 //if (FETypePressure_=="P1-disc-global")
397 // Helper::getPhiGlobal(phi, weights, dim, FETypePressure_, deg);
398 if (FETypePressure_=="P1-disc" && FETypeVelocity_=="Q2" )
399 Helper::getPhi(phi, weights, dim, FETypePressure_, deg, FETypeVelocity_);
400 else
401 Helper::getPhi(phi, weights, dim, FETypePressure_, deg);
402
403 SC detB;
404 SC absDetB;
405 SmallMatrix<SC> B(dim);
406 SmallMatrix<SC> Binv(dim);
407
408
409 buildTransformation(B);
410 detB = B.computeInverse(Binv);
411 absDetB = std::fabs(detB);
412
413 vec3D_dbl_Type dPhiTrans( dPhi->size(), vec2D_dbl_Type( dPhi->at(0).size(), vec_dbl_Type(dim,0.) ) );
414 Helper::applyBTinv( dPhi, dPhiTrans, Binv );
415
416 Teuchos::Array<GO> rowIndex( 1, 0 );
417 Teuchos::Array<SC> value(1, 0.);
418
419
420 for (UN i=0; i < phi->at(0).size(); i++) {
421 if (FETypePressure_=="P0")
422 rowIndex[0] = GO ( 0 );
423 else
424 rowIndex[0] = GO ( i );
425
426 for (UN j=0; j < dPhiTrans[0].size(); j++) {
427 for (UN d=0; d<dim; d++){
428 value[0] = 0.;
429 for (UN w=0; w<dPhiTrans.size(); w++)
430 value[0] += weights->at(w) * phi->at(w)[i] * dPhiTrans[w][j][d];
431 value[0] *= absDetB;
432
433
434 (*elementMatrix)[rowIndex[0]+dofsVelocity_*numNodesVelocity_][dofsVelocity_ * j + d] +=value[0];
435 (*elementMatrix)[dofsVelocity_ * j + d][dofsVelocity_*numNodesVelocity_+rowIndex[0]] +=value[0];
436 }
437 }
438 }
439 //elementMatrix->print();
440 // We compute value twice, maybe we should change this
441 /*for (UN i=0; i < dPhiTrans[0].size(); i++) {
442
443 Teuchos::Array<Teuchos::Array<SC> >valueVec( dim, Teuchos::Array<SC>( phi->at(0).size(), 0. ) );
444 Teuchos::Array<GO> indices( phi->at(0).size(), 0 );
445 for (UN j=0; j < valueVec[0].size(); j++) {
446 for (UN w=0; w<dPhiTrans.size(); w++) {
447 for (UN d=0; d<dim; d++)
448 valueVec[d][j] += weights->at(w) * phi->at(w)[j] * dPhiTrans[w][i][d];
449 }
450 for (UN d=0; d<dim; d++){
451 valueVec[d][j] *= absDetB;
452 if (setZeros_ && std::fabs(valueVec[d][j]) < myeps_) {
453 valueVec[d][j] = 0.;
454 }
455 }
456 }
457
458 for (UN j=0; j < indices.size(); j++){
459 if (FEType2=="P0")
460 indices[j] = GO ( mapping2->getGlobalElement( T ) );
461 else
462 indices[j] = GO ( mapping2->getGlobalElement( elements2->getElement(T).getNode(j) ) );
463 }
464 for (UN d=0; d<dim; d++) {
465 GO row = GO ( dim * mapping1->getGlobalElement( elements1->getElement(T).getNode(i) ) + d );
466 BTmat->insertGlobalValues( row, indices(), valueVec[d]() );
467 }
468
469 }*/
470
471
472}
473
474
482
483template <class SC, class LO, class GO, class NO>
484void AssembleFENavierStokes<SC,LO,GO,NO>::buildTransformation(SmallMatrix<SC>& B){
485
486 TEUCHOS_TEST_FOR_EXCEPTION( (B.size()<2 || B.size()>3), std::logic_error, "Initialize SmallMatrix for transformation.");
487 UN index;
488 UN index0 = 0;
489 for (UN j=0; j<B.size(); j++) {
490 index = j+1;
491 for (UN i=0; i<B.size(); i++) {
492 B[i][j] = this->nodesRefConfig_.at(index).at(i) - this->nodesRefConfig_.at(index0).at(i);
493 }
494 }
495
496}
497
498}
499#endif
500
FEDD::AssembleFENavierStokes::assembleFixedPoint
void assembleFixedPoint()
Assembly of FixedPoint- Matrix (System Matrix K with current u)
Definition AssembleFENavierStokes_def.hpp:121
FEDD::AssembleFENavierStokes::dofsVelocity_
int dofsVelocity_
Definition AssembleFENavierStokes_decl.hpp:110
FEDD::AssembleFENavierStokes::assembleJacobian
void assembleJacobian() override
Assemble the element Jacobian matrix.
Definition AssembleFENavierStokes_def.hpp:73
FEDD::AssembleFENavierStokes::buildTransformation
void buildTransformation(SmallMatrix< SC > &B)
Building Transformation.
Definition AssembleFENavierStokes_def.hpp:484
FEDD::AssembleFENavierStokes< SC, LO, GO, NO >::assemblyDivAndDivT
void assemblyDivAndDivT(SmallMatrixPtr_Type &elementMatrix)
FEDD::AssembleFENavierStokes< SC, LO, GO, NO >::assemblyAdvectionInU
void assemblyAdvectionInU(SmallMatrixPtr_Type &elementMatrix)
FEDD::AssembleFENavierStokes< SC, LO, GO, NO >::assemblyAdvection
void assemblyAdvection(SmallMatrixPtr_Type &elementMatrix)
FEDD::AssembleFENavierStokes::assembleRHS
void assembleRHS() override
Assemble the element right hand side vector.
Definition AssembleFENavierStokes_def.hpp:206
FEDD::AssembleFENavierStokes< SC, LO, GO, NO >::assemblyLaplacian
void assemblyLaplacian(SmallMatrixPtr_Type &elementMatrix)
FEDD::AssembleFENavierStokes::AssembleFENavierStokes
AssembleFENavierStokes(int flag, vec2D_dbl_Type nodesRefConfig, ParameterListPtr_Type parameters, tuple_disk_vec_ptr_Type tuple)
Constructor for AssembleFEAceNavierStokes.
Definition AssembleFENavierStokes_def.hpp:7
FEDD::AssembleFE< default_sc, default_lo, default_go, default_no >::AssembleFE
AssembleFE(int flag, vec2D_dbl_Type nodesRefConfig, ParameterListPtr_Type parameters, tuple_disk_vec_ptr_Type tuple)
Definition AssembleFE_def.hpp:8
FEDD::AssembleFE< default_sc, default_lo, default_go, default_no >::nodesRefConfig_
vec2D_dbl_Type nodesRefConfig_
Definition AssembleFE_decl.hpp:255
FEDD::Helper::determineDegree
static UN determineDegree(UN dim, std::string FEType, VarType orderOfDerivative)
Determine polynomial degree of a finite element basis function or its gradient that is required to se...
Definition Helper.cpp:68
FEDD::Helper::applyBTinv
static void applyBTinv(vec3D_dbl_ptr_Type &dPhiIn, vec3D_dbl_Type &dPhiOut, const SmallMatrix< SC > &Binv)
Applying the transformation matriX B to the gradient of phi, as is done in when transforming the grad...
Definition Helper.cpp:200
FEDD::Helper::Deriv0
@ Deriv0
order 0, f(x)
Definition Helper.hpp:27
FEDD::Helper::Deriv1
@ Deriv1
order 1, gradient(f(x))
Definition Helper.hpp:28
FEDD::Helper::getPhi
static int getPhi(vec2D_dbl_ptr_Type &Phi, vec_dbl_ptr_Type &weightsPhi, int dim, std::string FEType, int Degree, std::string FETypeQuadPoints="")
Get basisfunction phi per quadrature point.
Definition Helper.cpp:921
FEDD::Helper::getDPhi
static int getDPhi(vec3D_dbl_ptr_Type &DPhi, vec_dbl_ptr_Type &weightsDPhi, int Dimension, std::string FEType, int Degree)
Full matrix representation of gradient of a basis function for each quadrature point.
Definition Helper.cpp:215
FEDD::SmallMatrix
This class represents a templated small Matrix of type T. Primarily created for 2x2 and 3x3 matrices....
Definition SmallMatrix.hpp:20
FEDD
Adaptive Mesh Refinement.
Definition AdaptiveMeshRefinement_decl.hpp:36