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