Finite Element Domain Decomposition Library
FEDDLib
Loading...
Searching...
No Matches
FE_decl.hpp
1#ifndef FE_DECL_hpp
2#define FE_DECL_hpp
3
4#include "FE_ElementAssembly.hpp"
5
6#include <boost/function.hpp>
7
16
17namespace FEDD {
18class DataElement {
19 public:
20 DataElement();
21 DataElement(int size);
22 std::vector<double> getHp();
23 std::vector<double> getHt();
24 void setHp( double* ht);
25 private:
26 std::vector<double> ht_;
27 std::vector<double> hp_;
28};
29
30
31template <class SC = default_sc, class LO = default_lo, class GO = default_go, class NO = default_no>
32class FE: public FE_ElementAssembly<SC,LO,GO,NO> {
33 public:
34
35 typedef Domain<SC,LO,GO,NO> Domain_Type;
36 typedef Teuchos::RCP<Domain_Type> DomainPtr_Type;
37 typedef Teuchos::RCP<const Domain_Type> DomainConstPtr_Type;
38 typedef std::vector<DomainConstPtr_Type> DomainConstPtr_vec_Type;
39
40 typedef Teuchos::RCP<Mesh<SC,LO,GO,NO> > MeshPtr_Type;
41 typedef MeshUnstructured<SC,LO,GO,NO> MeshUnstr_Type;
42 typedef Teuchos::RCP<MeshUnstr_Type> MeshUnstrPtr_Type;
43
44 typedef Elements Elements_Type;
45 typedef Teuchos::RCP<Elements_Type> ElementsPtr_Type;
46 typedef Teuchos::RCP<const Elements_Type> ElementsConstPtr_Type;
47
48 typedef Matrix<SC,LO,GO,NO> Matrix_Type;
49 typedef Teuchos::RCP<Matrix_Type> MatrixPtr_Type;
50
51 typedef typename Matrix_Type::MapPtr_Type MapPtr_Type;
52 typedef typename Matrix_Type::MapConstPtr_Type MapConstPtr_Type;
53
54 typedef MultiVector<SC,LO,GO,NO> MultiVector_Type;
55 typedef Teuchos::RCP<MultiVector_Type> MultiVectorPtr_Type;
56 typedef Teuchos::RCP<const MultiVector_Type> MultiVectorConstPtr_Type;
57
58 typedef std::vector<GO> vec_GO_Type;
59 typedef std::vector<vec_GO_Type> vec2D_GO_Type;
60 typedef std::vector<vec2D_GO_Type> vec3D_GO_Type;
61 typedef Teuchos::RCP<vec3D_GO_Type> vec3D_GO_ptr_Type;
62
63 typedef boost::function<void(double* x, double* res, double t, const double* parameters)> BC_func_Type;
64
65 typedef AssembleFE<SC,LO,GO,NO> AssembleFE_Type;
66 typedef Teuchos::RCP<AssembleFE_Type> AssembleFEPtr_Type;
67
68 typedef AssembleFENavierStokes<SC,LO,GO,NO> AssembleFENavierStokes_Type;
69 typedef Teuchos::RCP<AssembleFENavierStokes_Type> AssembleFENavierStokesPtr_Type;
70
71 typedef AssembleFEGeneralizedNewtonian<SC,LO,GO,NO> AssembleFEGeneralizedNewtonian_Type;
72 typedef Teuchos::RCP<AssembleFEGeneralizedNewtonian_Type> AssembleFEGeneralizedNewtonianPtr_Type;
73
74 typedef AssembleFE_SCI_SMC_Active_Growth_Reorientation<SC,LO,GO,NO> AssembleFE_SCI_SMC_Active_Growth_Reorientation_Type;
75 typedef Teuchos::RCP<AssembleFE_SCI_SMC_Active_Growth_Reorientation_Type> AssembleFE_SCI_SMC_Active_Growth_Reorientation_Ptr_Type;
76
77 typedef std::vector<AssembleFEPtr_Type> AssembleFEPtr_vec_Type;
78
79 typedef BlockMatrix<SC,LO,GO,NO> BlockMatrix_Type ;
80 typedef Teuchos::RCP<BlockMatrix_Type> BlockMatrixPtr_Type;
81
82 typedef BlockMultiVector<SC,LO,GO,NO> BlockMultiVector_Type ;
83 typedef Teuchos::RCP<BlockMultiVector_Type> BlockMultiVectorPtr_Type;
84
85 typedef SmallMatrix<SC> SmallMatrix_Type;
86 typedef Teuchos::RCP<SmallMatrix_Type> SmallMatrixPtr_Type;
87
88 /* ###################################################################### */
89
90 FE(bool saveAssembly=false);
91
92 void assemblyIdentity(MatrixPtr_Type &A);
93
94 void assemblySurfaceRobinBC(int dim,
95 std::string FETypeP,
96 std::string FETypeV,
97 MultiVectorPtr_Type u,
98 MatrixPtr_Type A,
99 std::vector<SC> &funcParameter,
100 RhsFunc_Type func,
101 ParameterListPtr_Type params);
102
103 void assemblySurfaceIntegral(int dim,
104 std::string FEType,
105 MultiVectorPtr_Type a,
106 std::string fieldType,
107 RhsFunc_Type func,
108 std::vector<SC>& funcParameter);
109
110 void assemblySurfaceIntegralExternal(int dim,
111 std::string FEType,
112 MultiVectorPtr_Type f,
113 MultiVectorPtr_Type d_rep,
114 std::vector<SC>& funcParameter,
115 RhsFunc_Type func,
116 ParameterListPtr_Type params,
117 int FEloc=0);
118
119 void assemblyNonlinearSurfaceIntegralExternal(int dim,
120 std::string FEType,
121 MultiVectorPtr_Type f,
122 MultiVectorPtr_Type d_rep,
123 MatrixPtr_Type &Kext,
124 std::vector<SC>& funcParameter,
125 RhsFunc_Type func,
126 ParameterListPtr_Type params,
127 int FEloc = 0);
128
129 void assemblySurfaceIntegralFlag(int dim,
130 std::string FEType,
131 MultiVectorPtr_Type a,
132 std::string fieldType,
133 BC_func_Type func,
134 std::vector<SC>& funcParameter);
135
136 double assemblyResistanceBoundary(int dim,
137 std::string FEType,
138 MultiVectorPtr_Type f,
139 MultiVectorPtr_Type u_rep,
140 vec_dbl_Type flowRate_vec,
141 std::vector<SC>& funcParameter,
142 RhsFunc_Type func,
143 ParameterListPtr_Type params,
144 int FEloc=0);
145 double assemblyAbsorbingBoundary(int dim,
146 std::string FEType,
147 MultiVectorPtr_Type f,
148 MultiVectorPtr_Type u_rep,
149 vec_dbl_Type flowRate_vec,
150 std::vector<SC>& funcParameter,
151 RhsFunc_Type func,
152 double areaOutlet_init,
153 double areaOutlet_T,
154 ParameterListPtr_Type params,
155 int FEloc=0);
156
157 double assemblyAbsorbingBoundaryPaper(int dim,
158 std::string FEType,
159 MultiVectorPtr_Type f,
160 MultiVectorPtr_Type u_rep,
161 vec_dbl_Type flowRate_vec,
162 std::vector<SC>& funcParameter,
163 RhsFunc_Type func,
164 double areaOutlet_init,
165 double areaOutlet_T,
166 ParameterListPtr_Type params,
167 int FEloc=0);
168 double assemblyAbsorbingResistanceBoundary(int dim,
169 std::string FEType,
170 MultiVectorPtr_Type f,
171 MultiVectorPtr_Type u_rep,
172 vec_dbl_Type flowRate_vec,
173 std::vector<SC>& funcParameter,
174 RhsFunc_Type func,
175 double areaOutlet_init,
176 ParameterListPtr_Type params,
177 int FEloc=0);
178 void assemblyArea(int dim,
179 double &area,
180 int inflowFlag,
181 int FEloc=0);
182
183 int assemblyFlowRate(int dim,
184 double &flowRateParabolic,
185 std::string FEType,
186 int dofs,
187 int inflowFlag,
188 MultiVectorPtr_Type solution_rep,
189 int FEloc=0) ;
190
191 void assemblyAverageVelocity(int dim,
192 double &averageVelocity,
193 std::string FEType,
194 int dofs, int flag,
195 MultiVectorPtr_Type solution_rep,
196 int FEloc=0);
197
198 void assemblyPressureMeanValue(int dim, std::string FEType, MultiVectorPtr_Type a);
199
200 // void assemblyAceGenTPM( MatrixPtr_Type &A00,
201 // MatrixPtr_Type &A01,
202 // MatrixPtr_Type &A10,
203 // MatrixPtr_Type &A11,
204 // MultiVectorPtr_Type &F0,
205 // MultiVectorPtr_Type &F1,
206 // MapPtr_Type &mapRepeated1,
207 // MapPtr_Type &mapRepeated2,
208 // ParameterListPtr_Type parameterList,
209 // MultiVectorPtr_Type u_repeatedNewton=Teuchos::null,
210 // MultiVectorPtr_Type p_repeatedNewton=Teuchos::null,
211 // MultiVectorPtr_Type u_repeatedTime=Teuchos::null,
212 // MultiVectorPtr_Type p_repeatedTime=Teuchos::null,
213 // bool update=true,
214 // bool updateHistory=true);
215
216
217 void applyBTinv(vec3D_dbl_ptr_Type& dPhiIn,
218 vec3D_dbl_Type& dPhiOut,
219 SmallMatrix<SC>& Binv);
220
221 void applyBTinv(vec3D_dbl_ptr_Type& dPhiIn,
222 vec3D_dbl_Type& dPhiOut,
223 const SmallMatrix<SC>& Binv);
224
225 void assemblyLaplace(int Dimension,
226 std::string FEType,
227 int degree,
228 MatrixPtr_Type &A,
229 bool callFillComplete = true,
230 int FELocExternal = -1);
231
232 void assemblyMass(int dim,
233 std::string FEType,
234 std::string fieldType,
235 MatrixPtr_Type &A,
236 bool callFillComplete = true);
237
238 // Ueberladung der Assemblierung der Massematrix fuer FSI, da
239 // checkFE sonst auch fuer das Strukturproblem FEloc = 1 liefert (= Fluid)
240 // und somit die welche domain und Map in der Assemblierung genutzt wird.
241 void assemblyMass(int dim,
242 std::string FEType,
243 std::string fieldType,
244 MatrixPtr_Type &A,
245 int FEloc,
246 bool callFillComplete = true);
247
248 void assemblyLaplaceVecField(int dim,
249 std::string FEType,
250 int degree,
251 MatrixPtr_Type &A,
252 bool callFillComplete = true);
253
254 void assemblyLaplaceVecFieldV2(int dim,
255 std::string FEType,
256 int degree,
257 MatrixPtr_Type &A,
258 bool callFillComplete = true);
259
260
261 // // Assembling the reaction term of the reaction diffusion equation. Maybe add default function.
262 // void assemblyLinearReactionTerm(int dim,
263 // std::string FEType,
264 // MatrixPtr_Type &A,
265 // bool callFillComplete,
266 // std::vector<SC>& funcParameter,
267 // RhsFunc_Type reactionFunc);
268
269 // // Assembling the reaction term of the reaction diffusion equation. Maybe add default function.
270 // void assemblyReactionTerm(int dim,
271 // std::string FEType,
272 // MatrixPtr_Type &A,
273 // MultiVectorPtr_Type u,
274 // bool callFillComplete,
275 // std::vector<SC>& funcParameter,
276 // RhsFunc_Type reactionFunc);
277
278 // // Assembling the reaction term of the reaction diffusion equation. Maybe add default function.
279 // void assemblyDReactionTerm(int dim,
280 // std::string FEType,
281 // MatrixPtr_Type &A,
282 // MultiVectorPtr_Type u,
283 // bool callFillComplete,
284 // std::vector<SC>& funcParameter,
285 // RhsFunc_Type reactionFunc);
286
287 void assemblyLinElasXDimE(int dim,
288 std::string FEType,
289 MatrixPtr_Type &A,
290 MultiVectorPtr_Type eModVec,
291 double nu,
292 bool callFillComplete=true);
293
294 void determineEMod(std::string FEType,
295 MultiVectorPtr_Type solution,
296 MultiVectorPtr_Type &eModVec,
297 DomainConstPtr_Type domain,
298 ParameterListPtr_Type params);
299 void assemblyLaplaceDiffusion(int Dimension,
300 std::string FEType,
301 int degree,
302 MatrixPtr_Type &A,
303 vec2D_dbl_Type diffusionTensor,
304 bool callFillComplete = true,
305 int FELocExternal = -1);
306
307 void assemblyElasticityJacobianAndStressAceFEM(int dim,
308 std::string FEType,
309 MatrixPtr_Type &A,
310 MultiVectorPtr_Type &f,
311 MultiVectorPtr_Type u,
312 ParameterListPtr_Type pList,
313 double C,
314 bool callFillComplete=true);
315
316 void assemblyElasticityJacobianAceFEM(int dim,
317 std::string FEType,
318 MatrixPtr_Type &A,
319 MultiVectorPtr_Type u,
320 std::string material_model,
321 double E,
322 double nu,
323 double C,
324 bool callFillComplete=true);
325
326 void assemblyElasticityStressesAceFEM(int dim,
327 std::string FEType,
328 MultiVectorPtr_Type &f,
329 MultiVectorPtr_Type u,
330 std::string material_model,
331 double E,
332 double nu,
333 double C,
334 bool callFillComplete=true);
335
336 void assemblyAdvectionVecField(int dim,
337 std::string FEType,
338 MatrixPtr_Type &A,
339 MultiVectorPtr_Type u,
340 bool callFillComplete);
341
342 void assemblyAdvectionInUVecField(int dim,
343 std::string FEType,
344 MatrixPtr_Type &A,
345 MultiVectorPtr_Type u,
346 bool callFillComplete);
347
348 void assemblyAdvectionVecFieldScalar(int dim,
349 std::string FEType,
350 std::string FETypeV,
351 MatrixPtr_Type &A,
352 MultiVectorPtr_Type u,
353 bool callFillComplete);
354
355 void assemblyDivAndDivT( int dim,
356 std::string FEType1,
357 std::string FEType2,
358 int degree,
359 MatrixPtr_Type &Bmat,
360 MatrixPtr_Type &BTmat,
361 MapConstPtr_Type map1,
362 MapConstPtr_Type map2,
363 bool callFillComplete = true);
364
365 void assemblyDivAndDivTFast( int dim,
366 std::string FEType1,
367 std::string FEType2,
368 int degree,
369 MatrixPtr_Type &Bmat,
370 MatrixPtr_Type &BTmat,
371 MapConstPtr_Type map1,
372 MapConstPtr_Type map2,
373 bool callFillComplete = true);
374
375
377 void assemblyBDStabilization(int dim,
378 std::string FEType,
379 MatrixPtr_Type &A,
380 bool callFillComplete = true);
381
384 void assemblyLaplaceXDim(int dim,
385 std::string FEType,
386 MatrixPtr_Type &A,
387 CoeffFuncDbl_Type func,
388 double* parameters,
389 bool callFillComplete = true);
390
392 void assemblyStress(int dim,
393 std::string FEType,
394 MatrixPtr_Type &A,
395 CoeffFunc_Type func,
396 int* parameters,
397 bool callFillComplete = true);
398
401 void assemblyLinElasXDim(int dim,
402 std::string FEType,
403 MatrixPtr_Type &A,
404 double lambda,
405 double mu,
406 bool callFillComplete = true);
407
414 void assemblyAdditionalConvection(int dim,
415 std::string FEType,
416 MatrixPtr_Type &A,
417 MultiVectorPtr_Type w,
418 bool callFillComplete = true);
419
420 // Das ist Assemblierungsroutine fuer die Kopplungsbloecke C1, C2 und C3 und deren Transponierte.
421 // Die entsprechende Skalierung wird hinterher in dem Problem gemacht. Hier wird die entsprechende
422 // Einheitsmatrix (auf den Interfaceknoten) gesetzt.
423 void assemblyFSICoupling(int dim,
424 std::string FEType,
425 MatrixPtr_Type &C,
426 MatrixPtr_Type &C_T,
427 int FEloc1, // 0 = Fluid, 2 = Struktur
428 int FEloc2,
429 MapConstPtr_Type map1, // DomainMap: InterfaceMapVecFieldUnique = Spalten von C_T
430 MapConstPtr_Type map2, // RangeMap: this->getDomain(0)->getMapVecFieldUnique() = Zeilen von C_T
431 bool callFillComplete = true);
432
433 void assemblyDummyCoupling( int dim,
434 std::string FEType,
435 MatrixPtr_Type &C,
436 int FEloc, // 0 = Fluid, 2 = Struktur
437 bool callFillComplete);
438
439
440 // Das ist Assemblierungsroutine fuer den Kopplungsblock C4, der
441 // Geometrie und Struktur koppelt. Ist nur bei geometrisch implizit von Noeten.
442 void assemblyGeometryCoupling(int dim,
443 std::string FEType,
444 MatrixPtr_Type &C,
445 int FEloc, // wie oben. Allerdings 4 = Geometrie (= 0)
446 MapConstPtr_Type map1, // Fluid-Interface-Map
447 MapConstPtr_Type map2, // DomainMap: this->getDomain(2)->getMapVecFieldUnique() = Spalten von C
448 MapConstPtr_Type map3, // RangeMap: this->getDomain(4)->getMapVecFieldUnique() = Zeilen von C
449 bool callFillComplete = true);
450
451 // Shape-Derivatives fuer die Geschwindigkeit; die Hauptvariable ist \delta d und Testfunktion ist v:
452 // Spannung 1: DK1 = - \mu \int [ \grad(u) \grad(\delta d) + [\grad(\delta d)]^T [\grad(u)]^T ] : \grad(v) d\Omega
453 // Spannung 2: DK2 = \int [ \sigma \eta ] : \grad(v) d\Omega
454 // mit \sigma = \mu ( \grad(u) + [\grad(u)]^T ) - pI und \eta = I (\nabla \cdot \delta d) - [\grad(\delta d)]^T.
455 // Konvektion: DN = \rho \int (u - w)^T \eta [\grad(u)]^T v d\Omega
456 // Impliziter Anteil der Konvektion: DW = - \rho \frac{1}{k} \int (\delta d \cdot \nabla) u v d\Omega
457 // aehnlich zur Newton-Matrix W aus Navier-Stokes, wobei k = dt = Zeitschrittweite
458 // Zusaetzlicher Term wg. non-conservatie: DP = - \rho \int ( \grad(w) : \eta ) u \cdot v d\Omega
459 // Massematrix und impliziter Anteil wg. non-conservative:
460 // DM = \rho \frac{1.5}{k} \int (\nabla \cdot \delta d) u \cdot v d\Omega (Massematrix aus BDF2)
461 // - \rho \frac{1}{k} \int (\nabla \cdot \delta d) u \cdot v d\Omega
462 // = \rho \frac{0.5}{k} \int (\nabla \cdot \delta d) u \cdot v d\Omega
463 // ACHTUNG: Der erste Koeffizient \frac{1.5}{k} ist durch den fuehrenden Koeffizienten
464 // bei der BDF2-Zeitintegration nach Normierung gegeben (bei BDF2 also 3/2 = 1.5).
465 void assemblyShapeDerivativeVelocity(int dim,
466 std::string FEType1,
467 std::string FEType2,
468 MatrixPtr_Type &D,
469 int FEloc, // 4 = Fluid (Velocity)
470 MultiVectorPtr_Type u, // Geschwindigkeit
471 MultiVectorPtr_Type w, // Beschleunigung Gitter
472 MultiVectorPtr_Type p, // Druck
473 double dt, // Zeitschrittweite
474 double rho, // Dichte vom Fluid
475 double nu, // Viskositaet vom Fluid
476 bool callFillComplete = true);
477
478
479 // Shape-Derivatives fuer Div-Nebenbedingung; Hauptvariable ist \delta d und Testfunktion ist q:
480 // Divergenz: DB = - \int q \grad(u) : \eta d\Omega
481 void assemblyShapeDerivativeDivergence(int dim,
482 std::string FEType1,
483 std::string FEType2,
484 MatrixPtr_Type &DB,
485 int FEloc1, // 1 = Fluid-Pressure
486 int FEloc2, // 4 = Fluid-Velocity
487 MapConstPtr_Type map1_unique, // Pressure-Map
488 MapConstPtr_Type map2_unique, // Velocity-Map unique als VecField
489 MultiVectorPtr_Type u, // Geschwindigkeit
490 bool callFillComplete = true);
491
492
493 void assemblyRHS(int dim,
494 std::string FEType,
495 MultiVectorPtr_Type a,
496 std::string fieldType,
497 RhsFunc_Type func,
498 std::vector<SC>& funcParameter
499 );
500
501 void assemblyRHSDegTest( int dim,
502 std::string FEType,
503 MultiVectorPtr_Type a,
504 std::string fieldType,
505 RhsFunc_Type func,
506 std::vector<SC>& funcParameter,
507 int degree) ;
508
509 void buildFullDPhi(vec3D_dbl_ptr_Type dPhi, Teuchos::Array<SmallMatrix<double> >& dPhiMat);
510
511 void fillMatrixArray(SmallMatrix<double> &matIn, double* matArrayOut, std::string order, int offset=0);
512
513 void epsilonTensor(vec_dbl_Type &basisValues, SmallMatrix<SC> &epsilonValues, int activeDof);
514
515 Teuchos::RCP<ElementSpec> es_;
516
517/* ----------------------------------------------------------------------------------------*/
518private:
519
520 //Start of AceGen code
529 void nh3d(double* v, double (*E), double (*Nu), double** F , double** Pmat, double**** Amat);
530
540 void mr3d(double* v, double (*E), double (*Nu), double (*C), double** F, double** Pmat, double**** Amat);
541
550 void stvk3d(double* v,double (*lam),double (*mue),double** F,double** Pmat,double**** Amat);
551
560 void stvk2d(double* v, double (*lam),double (*mue),double** F ,double** Pmat,double**** Amat);
561
562 // void SMTSetElSpecBiot(ElementSpec *es,int *idata/*not needed*/,int ic,int ng, vec_dbl_Type& paraVec);
563
564 // void SMTSetElSpecBiotStVK(ElementSpec *es,int *idata/*not needed*/,int ic,int ng, vec_dbl_Type& paraVec);
565
566 // void SMTSetElSpecBiot3D(ElementSpec *es,int *idata/*not needed*/,int ic,int ng, vec_dbl_Type& paraVec);
567
568 // void SKR_Biot(double* v,ElementSpec *es,ElementData *ed, NodeSpec **ns, NodeData **nd,double *rdata,int *idata,double *p,double **s);
569
570 // void SKR_Biot_StVK(double* v,ElementSpec *es,ElementData *ed, NodeSpec **ns, NodeData **nd,double *rdata,int *idata,double *p,double **s);
571
572 // void SKR_Biot3D(double* v,ElementSpec *es,ElementData *ed, NodeSpec **ns, NodeData **nd,double *rdata,int *idata,double *p,double **s);
573
574 //End of AceGen code
575
576 void applyDiff(vec3D_dbl_Type& dPhiIn,
577 vec3D_dbl_Type& dPhiOut,
578 SmallMatrix<SC>& diffT);
579
580
581 std::vector<Teuchos::RCP<DataElement> > ed_;
582};
583}
584#endif
FEDD::AssembleFEGeneralizedNewtonian
Definition AssembleFEGeneralizedNewtonian_decl.hpp:21
FEDD::AssembleFENavierStokes
Definition AssembleFENavierStokes_decl.hpp:13
FEDD::AssembleFE_SCI_SMC_Active_Growth_Reorientation
Definition AssembleFE_SCI_SMC_Active_Growth_Reorientation_decl.hpp:29
FEDD::AssembleFE
This abstract class defining the interface for any type of element assembly rountines in the FEDDLib.
Definition AssembleFE_decl.hpp:61
FEDD::BlockMatrix
Definition BlockMatrix_decl.hpp:25
FEDD::BlockMultiVector
Definition BlockMultiVector_decl.hpp:25
FEDD::Domain
Definition Domain_decl.hpp:20
FEDD::Elements
Definition Elements.hpp:23
FEDD::FE::assemblyNonlinearSurfaceIntegralExternal
void assemblyNonlinearSurfaceIntegralExternal(int dim, std::string FEType, MultiVectorPtr_Type f, MultiVectorPtr_Type d_rep, MatrixPtr_Type &Kext, std::vector< SC > &funcParameter, RhsFunc_Type func, ParameterListPtr_Type params, int FEloc=0)
assemblyNonlinearSurfaceIntegralExternal -
Definition FE_def.hpp:6627
FEDD::FE::assemblyAdvectionVecFieldScalar
void assemblyAdvectionVecFieldScalar(int dim, std::string FEType, std::string FETypeV, MatrixPtr_Type &A, MultiVectorPtr_Type u, bool callFillComplete)
Assembly of operator \int ((u_h \cdot \nabla ) p_h)p_h dx.
Definition FE_def.hpp:2338
FEDD::FE::assemblyDivAndDivT
void assemblyDivAndDivT(int dim, std::string FEType1, std::string FEType2, int degree, MatrixPtr_Type &Bmat, MatrixPtr_Type &BTmat, MapConstPtr_Type map1, MapConstPtr_Type map2, bool callFillComplete=true)
Assembly of \int q_h (nabla \cdot v_h) dx.
Definition FE_def.hpp:2425
FEDD::FE::assemblyStress
void assemblyStress(int dim, std::string FEType, MatrixPtr_Type &A, CoeffFunc_Type func, int *parameters, bool callFillComplete=true)
(\grad u + (\grad u)^T, \grad v ); symmetrischer Gradient, wenn func = 1.0
Definition FE_def.hpp:2914
FEDD::FE::assemblyBDStabilization
void assemblyBDStabilization(int dim, std::string FEType, MatrixPtr_Type &A, bool callFillComplete=true)
Bochev- Dohrmann Stabilization.
Definition FE_def.hpp:2649
FEDD::FE::assemblyDivAndDivTFast
void assemblyDivAndDivTFast(int dim, std::string FEType1, std::string FEType2, int degree, MatrixPtr_Type &Bmat, MatrixPtr_Type &BTmat, MapConstPtr_Type map1, MapConstPtr_Type map2, bool callFillComplete=true)
Assembly of \int q_h (nabla \cdot v_h) dx.
Definition FE_def.hpp:2555
FEDD::FE::assemblyLaplaceXDim
void assemblyLaplaceXDim(int dim, std::string FEType, MatrixPtr_Type &A, CoeffFuncDbl_Type func, double *parameters, bool callFillComplete=true)
Definition FE_def.hpp:2732
FEDD::FE::assemblyAdvectionVecField
void assemblyAdvectionVecField(int dim, std::string FEType, MatrixPtr_Type &A, MultiVectorPtr_Type u, bool callFillComplete)
Assembly of operator \int ((u_h \cdot \nabla ) v_h)v_h dx.
Definition FE_def.hpp:2153
FEDD::FE::assemblyAdvectionInUVecField
void assemblyAdvectionInUVecField(int dim, std::string FEType, MatrixPtr_Type &A, MultiVectorPtr_Type u, bool callFillComplete)
Assembly of operator \int ((v_h \cdot \nabla ) u_h)v_h dx.
Definition FE_def.hpp:2247
FEDD::FE::FE
FE(bool saveAssembly=false)
Constructor of FE calling the constructor of FE_ElementAssembly accordingly.
Definition FE_def.hpp:64
FEDD::FE::assemblyLinElasXDimE
void assemblyLinElasXDimE(int dim, std::string FEType, MatrixPtr_Type &A, MultiVectorPtr_Type eModVec, double nu, bool callFillComplete=true)
Same as assemblyLinElasXDim except for changing E Module Value.
Definition FE_def.hpp:4763
FEDD::FE::assemblyAdditionalConvection
void assemblyAdditionalConvection(int dim, std::string FEType, MatrixPtr_Type &A, MultiVectorPtr_Type w, bool callFillComplete=true)
Addional Matrix due to ALE derivation: \int \rho_f div(w) u_h \cdot v_f dx, with mesh velocity w.
Definition FE_def.hpp:5075
FEDD::FE::assemblyLinElasXDim
void assemblyLinElasXDim(int dim, std::string FEType, MatrixPtr_Type &A, double lambda, double mu, bool callFillComplete=true)
Definition FE_def.hpp:4408
FEDD::FE::assemblyPressureMeanValue
void assemblyPressureMeanValue(int dim, std::string FEType, MultiVectorPtr_Type a)
Assembling \int p \dx = 0. Thus, we need the integral part for the mean pressure value.
Definition FE_def.hpp:7057
FEDD::Matrix
Definition Matrix_decl.hpp:30
FEDD::MeshUnstructured
Definition MeshUnstructured_decl.hpp:33
FEDD::MultiVector
Definition MultiVector_decl.hpp:61
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