svMultiPhysics
Loading...
Searching...
No Matches
ComMod.h
1/* Copyright (c) Stanford University, The Regents of the University of California, and others.
2 *
3 * All Rights Reserved.
4 *
5 * See Copyright-SimVascular.txt for additional details.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining
8 * a copy of this software and associated documentation files (the
9 * "Software"), to deal in the Software without restriction, including
10 * without limitation the rights to use, copy, modify, merge, publish,
11 * distribute, sublicense, and/or sell copies of the Software, and to
12 * permit persons to whom the Software is furnished to do so, subject
13 * to the following conditions:
14 *
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
19 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
20 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
21 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
22 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
25 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
27 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31// The classes defined here duplicate the data structures in the Fortran COMMOD module
32// defined in MOD.f.
33//
34// All of the data structures used for the mesh, boundarsy conditions and solver parameters, etc.
35// are defined here.
36
37#ifndef COMMOD_H
38#define COMMOD_H
39
40#include "Array.h"
41#include "Array3.h"
42#include "CepMod.h"
43#include "ChnlMod.h"
44#include "CmMod.h"
45#include "Parameters.h"
46#include "Timer.h"
47#include "Vector.h"
48
49#include "DebugMsg.h"
50
51#include "consts.h"
52
53#include "fils_struct.hpp"
54
55#include "Parameters.h"
56
57#include "ArtificialNeuralNetMaterial.h"
58
59#include <array>
60#include <iostream>
61#include <string>
62#include <vector>
63#include <fstream>
64#include <sstream>
65
66class LinearAlgebra;
67
68/// @brief Fourier coefficients that are used to specify unsteady BCs
69//
70class fcType
71{
72 public:
73
74 bool defined() { return n != 0; };
75
76 // If this is a ramp function
77 bool lrmp = false;
78
79 // Number of Fourier coefficient
80 int n = 0;
81
82 // No. of dimensions (scalar or vector)
83 int d = 0;
84
85 // Initial value
87
88 // Time derivative of linear part
90
91 // Period
92 double T = 0.0;
93
94 // Initial time
95 double ti = 0.0;
96
97 // Imaginary part of coefficint
98 Array<double> i;
99
100 // Real part of coefficint
101 Array<double> r;
102};
103
104/// @brief Moving boundary data structure (used for general BC)
105//
107{
108 public:
109
110 bool defined() { return dof != 0; };
111
112 // Degrees of freedom of d(:,.,.)
113 int dof = 0;
114
115 // Number of time points to be read
116 int nTP = 0;
117
118 // The period of data
119 double period = 0.0;
120
121 // Time points
123
124 // Displacements at each direction, location, and time point
126};
127
129{
130 public:
131
132 // Proximal resistance
133 double Rp = 0.0;
134
135 // Capacitance
136 double C = 0.0;
137
138 // Distance resistance
139 double Rd = 0.0;
140
141 // Distal pressure
142 double Pd = 0.0;
143
144 // Initial value
145 double Xo = 0.0;
146};
147
148/// @brief Boundary condition data type
149//
151{
152 public:
153
154 // Strong/Weak application of Dirichlet BC
155 bool weakDir = false;
156
157 // Whether load vector changes with deformation
158 // (Neu - struct/ustruct only)
159 bool flwP = false;
160
161 // Robin: apply only in normal direction
162 bool rbnN = false;
163
164 // Strong/Weak application of Dirichlet BC
165 int clsFlgRis = 0;
166
167 // Pre/Res/Flat/Para... boundary types
168 //
169 // This stores differnt BCs as bitwise values.
170 //
171 int bType = 0;
172
173 // Pointer to coupledBC%face
174 int cplBCptr = -1;
175
176 // The face index that corresponds to this BC
177 int iFa = -1;
178
179 // The mesh index that corresponds to this BC
180 int iM = -1;
181
182 // Pointer to FSILS%bc
183 int lsPtr = -1;
184
185 // Undeforming Neu BC master-slave node parameters.
186 int masN = 0;
187
188 // Defined steady value
189 double g = 0.0;
190
191 // Neu: defined resistance
192 double r = 0.0;
193
194 // Robin: stiffness
195 double k = 0.0;
196
197 // Robin: damping
198 double c = 0.0;
199
200 // RIS0D: resistance
201 double resistance = 0.0;
202
203 // Penalty parameters for weakly applied Dir BC
204 Vector<double> tauB{0.0, 0.0};
205 //double tauB[2];
206
207 // Direction vector for imposing the BC
208 Vector<int> eDrn;
209
210 // Defined steady vector (traction)
212
213 // Spatial dependant BC (profile data)
215
216 // General BC (unsteady and UD combination)
217 //
218 // This is declare ALLOCATABLE in MOD.f.
219 //
220 MBType gm;
221
222 // Time dependant BC (Unsteady imposed value);
223 //
224 // This is declare ALLOCATABLE in MOD.f.
225 //
226 fcType gt;
227
228 // Neu: RCR
229 rcrType RCR;
230};
231
232/// @brief Class storing data for B-Splines.
233//
234class bsType
235{
236 public:
237
238 // Number of knots (p + nNo + 1)
239 int n = 0;
240
241 // Number of Gauss points for integration
242 int nG = 0;
243
244 // Number of knot spans (element)
245 int nEl = 0;
246
247 // Number of control points (nodes)
248 int nNo = 0;
249
250 // Number of sample points in each element (for output)
251 int nSl = 0;
252
253 // The order
254 int p = 0;
255
256 // Knot vector.
258};
259
260/// @brief Function spaces (basis) type.
261//
262class fsType {
263
264 public:
265
266 fsType();
267
268 void destroy();
269
270 // Whether the basis function is linear
271 bool lShpF = false;
272
273 // Element type
274 consts::ElementType eType = consts::ElementType::NA;
275
276 // Number of basis functions, typically equals msh%eNoN
277 int eNoN = 0;
278
279 // Number of Gauss points for integration
280 int nG = 0;
281
282 // Gauss weights
284
285 // Gauss integration points in parametric space
286 Array<double> xi;
287
288 // Bounds on Gauss integration points in parametric space
289 Array<double> xib;
290
291 // Parent shape function
292 Array<double> N;
293
294 // Bounds on shape functions
295 Array<double> Nb;
296
297 // Parent shape functions gradient
299
300 // Second derivatives of shape functions - used for shells & IGA
301 Array3<double> Nxx;
302};
303
304//--------
305// bfType
306//--------
307// Body force data structure type
308//
310{
311 public:
312
313 std::string file_name;
314 std::string mesh_name;
315
316 // Type of body force applied
317 int bType = 0;
318
319 // No. of dimensions (1 or nsd)
320 int dof = 0;
321
322 // Mesh index corresponding to this body force
323 int iM = -1;
324
325 // Steady value
327
328 // Steady but spatially dependant
329 Array<double> bx;
330
331 // Time dependant (unsteady imposed value)
332 fcType bt;
333
334 // General (unsteady and spatially dependent combination)
335 MBType bm;
336};
337
338// Fiber stress type
340{
341 public:
342
343 // Type of fiber stress
344 int fType = 0;
345
346 // Constant steady value
347 double g = 0.0;
348
349 // Cross fiber stress parameter
350 double eta_s = 0.0;
351
352 // Unsteady time-dependent values
353 fcType gt;
354};
355
356/// @brief Structural domain type
357//
359{
360 public:
361 // Type of constitutive model (volumetric) for struct/FSI
362 consts::ConstitutiveModelType volType = consts::ConstitutiveModelType::stIso_NA;
363
364 // Penalty parameter
365 double Kpen = 0.0;
366
367 // Type of constitutive model (isochoric) for struct/FSI
368 consts::ConstitutiveModelType isoType = consts::ConstitutiveModelType::stIso_NA;
369
370 // Parameters specific to the constitutive model (isochoric)
371 // NeoHookean model (C10 = mu/2)
372 double C10 = 0.0;
373
374 // Mooney-Rivlin model (C10, C01)
375 double C01 = 0.0;
376
377 // Holzapfel model(a, b, aff, bff, ass, bss, afs, bfs, kap)
378 double a = 0.0;
379 double b = 0.0;
380 double aff = 0.0;
381 double bff = 0.0;
382 double ass = 0.0;
383 double bss = 0.0;
384 double afs = 0.0;
385 double bfs = 0.0;
386
387 // Collagen fiber dispersion parameter (Holzapfel model)
388 double kap = 0.0;
389
390 // Heaviside function parameter (Holzapfel-Ogden model)
391 double khs = 100.0;
392
393 // Lee-Sacks model
394 double a0 = 0.0;
395 double b1 = 0.0;
396 double b2 = 0.0;
397 double mu0 = 0.0;
398
399 // Fiber reinforcement stress
400 fibStrsType Tf;
401
402 // CANN Model/UAnisoHyper_inv
404
405 stModelType();
406};
407
408
409/// @brief Fluid viscosity model type
410//
412{
413 public:
414
415 // Type of constitutive model for fluid viscosity
416 consts::FluidViscosityModelType viscType = consts::FluidViscosityModelType::viscType_NA;
417
418 // Limiting zero shear-rate viscosity value
419 double mu_o = 0.0;
420
421 // Limiting high shear-rate viscosity (asymptotic) value (at infinity)
422 double mu_i = 0.0;
423
424 // Strain-rate tensor multiplier
425 double lam = 0.0;
426
427 // Strain-rate tensor exponent
428 double a = 0.0;
429
430 // Power-law exponent
431 double n = 0.0;
432};
433
434/// @brief Fluid viscosity model type
435//
437{
438 public:
439
440 // Type of constitutive model for fluid viscosity
441 consts::SolidViscosityModelType viscType = consts::SolidViscosityModelType::viscType_NA;
442
443 // Viscosity value
444 double mu = 0.0;
445};
446
447/// @brief Domain type is to keep track with element belong to which domain
448/// and also different physical quantities
449//
451{
452 public:
453 dmnType();
454 ~dmnType();
455
456 // The domain ID. Default includes entire domain
457 int Id = -1;
458
459 // Which physics must be solved in this domain
460 consts::EquationType phys = consts::EquationType::phys_NA;
461
462 // The volume of this domain
463 double v = 0.0;
464
465 // General physical properties such as density, elastic modulus...
466 // FIX davep double prop[maxNProp] ;
467 std::map<consts::PhysicalProperyType,double> prop;
468 //double prop[consts::maxNProp];
469
470 // Electrophysiology model
471 cepModelType cep;
472
473 // Structure material model
474 stModelType stM;
475
476 // Viscosity model for fluids
477 fluidViscModelType fluid_visc;
478
479 // Viscosity model for solids
480 solidViscModelType solid_visc;
481};
482
483/// @brief Mesh adjacency (neighboring element for each element)
484//
486{
487 public:
488 void destroy();
489
490 // No of non-zeros
491 int nnz = 0;
492
493 // Column pointer
494 Vector<int> pcol;
495
496 // Row pointer
497 Vector<int> prow;
498
499};
500
501/// @brief Tracer type used for immersed boundaries. Identifies traces of
502/// nodes and integration points on background mesh elements
503//
505{
506 public:
507 // No. of non-zero nodal traces
508 int n = 0;
509
510 // No. of non-zero integration point traces
511 int nG = 0;
512
513 // Local to global nodes maping nNo --> tnNo
514 Vector<int> gN;
515
516 // Self pointer of each trace to the IB integration point and
517 // element ID
518 Array<int> gE;
519
520 // Nodal trace pointer array stores two values for each trace.
521 // (1) background mesh element to which the trace points to,
522 // (2) mesh ID
523 Array<int> nptr;
524
525 // Integration point tracer array stores two values for each trace
526 // (1) background mesh element to which the trace points to,
527 // (2) mesh ID
528 Array<int> gptr;
529
530 // Parametric coordinate for each nodal trace
531 Array<double> xi;
532
533 // Parametric coordinate for each Gauss point trace
534 Array<double> xiG;
535};
536
537/// @brief The face type containing mesh at boundary
538//
540{
541 public:
542 faceType();
543 ~faceType();
544
545 void destroy();
546
547 //faceType& operator=(const faceType& rhs);
548
549 // Parametric direction normal to this face (NURBS)
550 int d = 0;
551
552 // Number of nodes (control points) in a single element
553 int eNoN = 0;
554
555 // Element type
556 consts::ElementType eType = consts::ElementType::NA;
557
558 // The mesh index that this face belongs to
559 int iM = 0;
560
561 // Number of elements
562 int nEl = 0;
563
564 // Global number of elements
565 int gnEl = 0;
566
567 // Number of function spaces
568 int nFs = 0;
569
570 // Number of Gauss points for integration
571 int nG = 0;
572
573 // Number of nodes
574 int nNo = 0;
575
576 // Global element Ids
577 Vector<int> gE;
578
579 // Global node Ids
580 Vector<int> gN;
581
582 // Global to local maping tnNo --> nNo
583 Vector<int> lN;
584
585 // Connectivity array
586 Array<int> IEN;
587
588 // EBC array (gE + gIEN)
589 Array<int> gebc;
590
591 // Surface area
592 double area = 0.0;
593
594 // Gauss point weights
596
597 // Position coordinates
598 Array<double> x;
599
600 // Gauss points in parametric space
601 Array<double> xi;
602
603 // Shape functions at Gauss points
604 Array<double> N;
605
606 // Normal vector to each nodal point
607 Array<double> nV;
608
609 // Shape functions derivative at Gauss points
610 // double Nx(:,:,:);
612
613 // Second derivatives of shape functions - for shells & IGA
614 // double Nxx(:,:,:);
615 Array3<double> Nxx;
616
617 // Face name for flux files
618 std::string name;
619
620 // Face nodal adjacency
621 adjType nAdj;
622
623 // Face element adjacency
624 adjType eAdj;
625
626 // Function spaces (basis)
627 std::vector<fsType> fs;
628
629 // TRI3 quadrature modifier
630 double qmTRI3 = 2.0/3.0;
631};
632
633/// @brief Store options for output types.
634//
636 bool boundary_integral = false;
637 bool spatial = false;
638 bool volume_integral = false;
639
640 bool no_options_set() {
641 return !(boundary_integral | spatial | volume_integral);
642 }
643
644 void set_option(consts::OutputType type, bool value)
645 {
646 if (type == consts::OutputType::boundary_integral) {
647 boundary_integral = value;
648 } else if (type == consts::OutputType::spatial) {
649 spatial = value;
650 } else if (type == consts::OutputType::volume_integral) {
651 volume_integral = value;
652 }
653 }
654};
655
656/// @brief Declared type for outputed variables
657//
659{
660 public:
661
662 // Options to write various output types.
663 OutputOptions options;
664
665 // The group that this belong to (one of outType_*)
666 consts::OutputNameType grp = consts::OutputNameType::outGrp_NA;
667
668 // Length of the outputed variable
669 int l = 0;
670
671 // Offset from the first index
672 int o = 0;
673
674 // The name to be used for the output and also in input file
675 std::string name;
676};
677
678/// @brief Linear system of equations solver type
679//
681{
682 public:
683
684 /// @brief LS solver (IN)
685 consts::SolverType LS_type = consts::SolverType::lSolver_NA;
686
687 /// @brief Successful solving (OUT)
688 bool suc = false;
689
690 /// @brief Maximum iterations (IN)
691 int mItr = 1000;
692
693 /// @brief Space dimension (IN)
694 int sD = 0;
695
696 /// @brief Number of iteration (OUT)
697 int itr = 0;
698
699 /// @brief Number of Ax multiple (OUT)
700 int cM = 0;
701
702 /// @brief Number of |x| norms (OUT)
703 int cN = 0;
704
705 /// @brief Number of <x.y> dot products (OUT)
706 int cD = 0;
707
708 /// @brief Only for data alignment (-)
709 int reserve = 0;
710
711 /// @brief Absolute tolerance (IN)
712 double absTol = 1e-08;
713
714 /// @brief Relative tolerance (IN)
715 double relTol = 0.0;
716
717 /// @brief Initial norm of residual (OUT)
718 double iNorm = 0.0;
719
720 /// @brief Final norm of residual (OUT)
721 double fNorm = 0.0;
722
723 /// @brief Res. rduction in last itr. (OUT)
724 double dB = 0.0;
725
726 /// @brief Calling duration (OUT)
727 double callD = 0.0;
728
729 //@brief Configuration file for linear solvers (Trilinos, PETSc)
730 std::string config;
731};
732
733
734/// @brief Contact model type
735//
737{
738 public:
739 // Contact model
740 consts::ContactModelType cType = consts::ContactModelType::cntctM_NA;
741
742 // Penalty parameter
743 double k = 0.0;
744
745 // Min depth of penetration
746 double h = 0.0;
747
748 // Max depth of penetration
749 double c = 0.0;
750
751 // Min norm of face normals in contact
752 double al = 0.0;
753
754 // Tolerance
755 double tol = 0.0;
756};
757
759{
760 public:
761 // GenBC_Dir/GenBC_Neu
762 consts::CplBCType bGrp = consts::CplBCType::cplBC_NA;
763
764 // Pointer to X
765 int Xptr = -1;
766
767 // Internal genBC use
768 int eqv = 0;
769
770 // Flow rates at t
771 double Qo = 0.0;
772
773 // Flow rates at t+dt
774 double Qn = 0.0;
775
776 // Pressures at t
777 double Po = 0.0;
778
779 // Pressures at t+dt
780 double Pn = 0.0;
781
782 // Imposed flow/pressure
783 double y = 0.0;
784
785 // Name of the face
786 std::string name;
787
788 // RCR type BC
789 rcrType RCR;
790};
791
792//----------------------------
793// svZeroDSolverInterfaceType
794//----------------------------
795// This class stores information used to interface to
796// the svZeroDSolver.
797//
799{
800 public:
801
802 // The path/name of the 0D solver shared library.
803 std::string solver_library;
804
805 // Maps a 0D block name with a 3D face name representing the
806 // coupling of a 0D block with a 3D face.
807 std::map<std::string,std::string> block_surface_map;
808
809 // The path/name of the 0D solver JSON file.
810 std::string configuration_file;
811
812 // How often the 0D contribution to solver tangent matrix is added.
813 std::string coupling_type;
814
815 // Initialize the 0D flows.
816 bool have_initial_flows = false;
817 double initial_flows;
818
819 // Initialize the 0D pressures.
820 bool have_initial_pressures = false;
821 double initial_pressures;
822
823 // If the data has been set for the interface. This is only true if
824 // the svZeroDSolver_interface XML parameter has been defined.
825 bool has_data = false;
826
827 void set_data(const svZeroDSolverInterfaceParameters& params);
828 void add_block_face(const std::string& block_name, const std::string& face_name);
829};
830
831/// @brief For coupled 0D-3D problems
832//
834{
835 public:
836 cplBCType();
837 /// @brief Is multi-domain active
838 bool coupled = false;
839
840 /// @brief Whether to use genBC
841 bool useGenBC = false;
842
843 // Whether to use svZeroD
844 bool useSvZeroD = false;
845
846 // Whether to initialize RCR from flow data
847 bool initRCR = false;
848
849 /// @brief Number of coupled faces
850 int nFa = 0;
851
852 /// @brief Number of unknowns in the 0D domain
853 int nX = 0;
854
855 /// @brief Number of output variables addition to nX
856 int nXp = 0;
857
858 /// @brief Implicit/Explicit/Semi-implicit schemes
859 consts::CplBCType schm = consts::CplBCType::cplBC_NA;
860 //int schm = cplBC_NA;
861
862 /// @brief Path to the 0D code binary file
863 std::string binPath;
864
865 /// @brief File name for communication between 0D and 3D
866 std::string commuName;
867 //std::string commuName = ".CPLBC_0D_3D.tmp";
868
869 svZeroDSolverInterfaceType svzerod_solver_interface;
870
871 /// @brief The name of history file containing "X"
872 std::string saveName;
873 //std::string(LEN=stdL) :: saveName = "LPN.dat";
874
875 /// @brief New time step unknowns in the 0D domain
877
878 /// @brief Old time step unknowns in the 0D domain
880
881 /// @brief Output variables to be printed
883
884 /// @brief Data structure used for communicating with 0D code
885 std::vector<cplFaceType> fa;
886};
887
888/// @brief This is the container for a mesh or NURBS patch, those specific
889/// to NURBS are noted
890//
892{
893 public:
894 mshType();
895 std::string dname = "";
896
897/*
898 mshType(const mshType &other)
899 {
900 std::cout << "c c c c c mshType copy c c c c c" << std::endl;
901 }
902
903 mshType& operator = (const mshType &other)
904 {
905 std::cout << "= = = = = mshType assignment = = = = =" << std::endl;
906 return *this;
907 }
908*/
909
910 ~mshType()
911 {
912 //std::cout << "- - - - - mshType dtor - - - - - dname: " << dname << std::endl;
913 };
914
915 /// @brief Whether the shape function is linear
916 bool lShpF = false;
917
918 /// @brief Whether the mesh is shell
919 bool lShl = false;
920
921 /// @brief Whether the mesh is fibers (Purkinje)
922 bool lFib = false;
923
924 /// @brief Element type
925 consts::ElementType eType = consts::ElementType::NA;
926 //int eType = eType_NA
927
928 /// @brief Number of nodes (control points) in a single element
929 int eNoN = 0;
930
931 /// @brief Global number of elements (knot spans)
932 int gnEl = 0;
933
934 /// @brief Global number of nodes (control points) on a single mesh
935 int gnNo = 0;
936
937 /// @brief Number of element face. Used for reading Gambit mesh files
938 int nEf = 0;
939
940 /// @brief Number of elements (knot spans)
941 int nEl = 0;
942
943 /// @brief Number of faces
944 int nFa = 0;
945
946 /// @brief Number of function spaces
947 int nFs = 0;
948
949 /// @brief Number of Gauss points for integration
950 int nG = 0;
951
952 /// @brief Number of nodes (control points) for 2D elements?
953 int nNo = 0;
954
955 /// @brief Number of elements sample points to be outputs (NURBS)
956 int nSl = 0;
957
958 /// @brief The element type recognized by VTK format
959 int vtkType = 0;
960
961 /// @brief Number of fiber directions
962 int nFn = 0;
963
964 /// @brief Mesh scale factor
965 double scF = 0.0;
966
967 /// @brief IB: Mesh size parameter
968 double dx = 0.0;
969
970 /// @brief RIS resistance value
971 double res = 0.0;
972
973 /// @brief RIS projection tolerance
974 double tol = 0.0;
975
976 /// @brief The volume of this mesh
977 double v = 0.0;
978
979 /// @breif ordering: node ordering for boundaries
980 std::vector<std::vector<int>> ordering;
981
982 /// @brief Element distribution between processors
984
985 /// @brief Element domain ID number
987
988 /// @brief Global nodes maping nNo --> tnNo
990
991 /// @brief GLobal projected nodes mapping projected -> unprojected mapping
993
994 /// @brief Global connectivity array mappig eNoN,nEl --> gnNo
995 Array<int> gIEN;
996
997 /// @brief The connectivity array mapping eNoN,nEl --> nNo
998 Array<int> IEN;
999
1000 /// @brief gIEN mapper from old to new
1002
1003 /// @brief Local knot pointer (NURBS)
1004 Array<int> INN;
1005
1006 /// @brief Global to local maping tnNo --> nNo
1008
1009 /// @brief Shells: extended IEN array with neighboring nodes
1010 Array<int> eIEN;
1011
1012 /// @brief Shells: boundary condition variable
1013 Array<int> sbc;
1014
1015 /// @brief IB: Whether a cell is a ghost cell or not
1017
1018 /// @brief Control points weights (NURBS)
1020
1021 /// @brief Gauss weights
1023
1024 /// @brief Gauss integration points in parametric space
1025 Array<double> xi;
1026
1027 /// @brief Bounds on parameteric coordinates
1028 Array<double> xib;
1029
1030 /// @brief Position coordinates (not always, however, as they get overwritten by read_vtu_pdata())
1031 Array<double> x;
1032
1033 /// @brief Parent shape function
1034 Array<double> N;
1035
1036 /// @brief Shape function bounds
1037 Array<double> Nb;
1038
1039 /// @brief Normal vector to each nodal point (for Shells)
1040 Array<double> nV;
1041
1042 /// @brief Fiber orientations stored at the element level - used for
1043 /// electrophysiology and solid mechanics
1044 Array<double> fN;
1045
1046 /// @brief Parent shape functions gradient
1047 /// double Nx(:,:,:)
1049
1050 /// @brief Second derivatives of shape functions - used for shells & IGA
1051 /// davep double Nxx(:,:,:)
1053
1054 /// @brief Solution field (displacement, velocity, pressure, etc.) for a known, potentially
1055 /// time-varying, quantity of interest across a mesh
1057
1058 /// @brief Mesh Name
1059 std::string name;
1060
1061 /// @brief Mesh nodal adjacency
1063
1064 /// @brief Mesh element adjacency
1066
1067 /// @brief Function spaces (basis)
1068 std::vector<fsType> fs;
1069
1070 /// @brief BSpline in different directions (NURBS)
1071 std::vector<bsType> bs;
1072
1073 /// @brief Faces are stored in this variable
1074 std::vector<faceType> fa;
1075
1076 /// @brief IB: tracers
1078
1079 /// @brief RIS: flags of whether elemets are adjacent to RIS projections
1080 // std::vector<bool> eRIS;
1082
1083 /// @brief RIS: processor ids to change element partitions to
1085
1086 /// @brief TET4 quadrature modifier
1087 double qmTET4 = (5.0+3.0*sqrt(5.0))/20.0;
1088
1089 private:
1090 //mshType(const mshType&);
1091 //mshType& operator=(const mshType&);
1092
1093};
1094
1095/// @brief Equation type
1096//
1098{
1099 public:
1100 eqType();
1101 ~eqType();
1102
1103 /// @brief Should be satisfied in a coupled/uncoupled fashion
1104 bool coupled = false;
1105 //bool coupled = .TRUE.
1106
1107 /// @brief Satisfied/not satisfied
1108 bool ok = false;
1109
1110 /// @brief Use C++ Trilinos framework for the linear solvers
1111 bool useTLS = false;
1112
1113 /// @brief Use C++ Trilinos framework for assembly and for linear solvers
1114 bool assmTLS = false;
1115
1116 /// @brief Degrees of freedom
1117 int dof = 0;
1118
1119 /// @brief Pointer to end of unknown Yo(:,s:e)
1120 int e = -1;
1121
1122 /// @brief Pointer to start of unknown Yo(:,s:e)
1123 int s = -1;
1124
1125 /// @brief Number of performed iterations
1126 int itr = 0;
1127
1128 /// @brief Maximum iteration for this eq.
1129 int maxItr = 5;
1130
1131 /// @brief Minimum iteration for this eq.
1132 int minItr = 1;
1133
1134 /// @brief Number of possible outputs
1135 int nOutput = 0;
1136
1137 /// @brief IB: Number of possible outputs
1138 int nOutIB = 0;
1139
1140 /// @brief URIS: Number of possible outputs
1141 int nOutURIS = 0;
1142
1143 /// @brief Number of domains
1144 int nDmn = 0;
1145
1146 /// @brief IB: Number of immersed domains
1147 int nDmnIB = 0;
1148
1149 /// @brief Number of BCs
1150 int nBc = 0;
1151
1152 /// @brief Number of BCs on immersed surfaces
1153 int nBcIB = 0;
1154
1155 /// @brief Number of BFs
1156 int nBf = 0;
1157
1158 /// @brief Type of equation fluid/heatF/heatS/lElas/FSI
1159 consts::EquationType phys = consts::EquationType::phys_NA;
1160
1161 // Parameters used for the Generalized α− Method.
1162 //
1163 /// @brief \f$\alpha_f\f$
1164 double af = 0.0;
1165
1166 /// @brief \f$\alpha_m\f$
1167 ///
1168 /// For second order equations: am = (2.0 - roInf) / (1.0 + roInf)
1169 /// First order equations: am = 0.5 * (3.0 - roInf) / (1.0 + roInf)
1170 //
1171 double am = 0.0;
1172
1173 /// @brief \f$\beta\f$
1174 double beta = 0.0;
1175
1176 /// @brief \f$\gamma\f$
1177 double gam = 0.0;
1178
1179 /// @brief Initial norm of residual
1180 double iNorm = 0.0;
1181
1182 /// @brief First iteration norm
1183 double pNorm = 0.0;
1184
1185 /// @brief \f$\rho_{infinity}\f$
1186 double roInf = 0.0;
1187
1188 /// @brief Accepted relative tolerance
1189 double tol = 0.0;
1190
1191 /// @brief Equation symbol
1192 std::string sym;
1193 //std::string(LEN=2) :: sym = "NA";
1194
1195 /// @brief type of linear solver
1197
1198 /// @brief The type of interface to a numerical linear algebra library.
1199 consts::LinearAlgebraType linear_algebra_type;
1200
1201 /// @brief The type of assembly interface to a numerical linear algebra library.
1202 consts::LinearAlgebraType linear_algebra_assembly_type;
1203
1204 /// @brief The type of preconditioner used by the interface to a numerical linear algebra library.
1205 consts::PreconditionerType linear_algebra_preconditioner = consts::PreconditionerType::PREC_FSILS;
1206
1207 /// @brief Interface to a numerical linear algebra library.
1209
1210 /// @brief FSILS type of linear solver
1211 fsi_linear_solver::FSILS_lsType FSILS;
1212
1213 /// @brief BCs associated with this equation;
1214 std::vector<bcType> bc;
1215
1216 /// @brief IB: BCs associated with this equation on immersed surfaces
1217 std::vector<bcType> bcIB;
1218
1219 /// @brief domains that this equation must be solved
1220 std::vector<dmnType> dmn;
1221
1222 /// @brief IB: immersed domains that this equation must be solved
1223 std::vector<dmnType> dmnIB;
1224
1225 /// @brief Outputs
1226 std::vector<outputType> output;
1227
1228 /// @brief IB: Outputs
1229 std::vector<outputType> outIB;
1230
1231 /// @brief URIS: Outputs
1232 std::vector<outputType> outURIS;
1233
1234 /// @brief Body force associated with this equation
1235 std::vector<bfType> bf;
1236};
1237
1238/// @brief This type will be used to write data in the VTK files.
1239//
1241{
1242 public:
1243
1244 // Element number of nodes
1245 int eNoN = 0;
1246
1247 // Number of elements
1248 int nEl = 0;
1249
1250 // Number of nodes
1251 int nNo = 0;
1252
1253 // vtk type
1254 int vtkType = 0;
1255
1256 // Connectivity array
1257 Array<int> IEN;
1258
1259 // Element based variables to be written
1260 Array<double> xe;
1261
1262 // All the variables after transformation to global format
1263 Array<double> gx;
1264
1265 // All the variables to be written (including position)
1266 Array<double> x;
1267};
1268
1269
1271{
1272 public:
1273
1274 rmshType();
1275
1276 /// @brief Whether remesh is required for problem or not
1277 bool isReqd = false;
1278
1279 /// @brief Method for remeshing: 1-TetGen, 2-MeshSim
1280 consts::MeshGeneratorType method = consts::MeshGeneratorType::RMSH_TETGEN;
1281
1282 /// @brief Counter to track number of remesh done
1283 int cntr = 0;
1284
1285 /// @brief Time step from which remeshing is done
1286 int rTS = 0;
1287
1288 /// @brief Time step freq for saving data
1289 int cpVar = 0;
1290
1291 /// @brief Time step at which forced remeshing is done
1292 int fTS = 1000;
1293
1294 /// @brief Time step frequency for forced remeshing
1295 int freq = 1000;
1296
1297 /// @brief Time where remeshing starts
1298 double time = 0.0;
1299
1300 /// @brief Mesh quality parameters
1301 double minDihedAng = 0.0;
1302 double maxRadRatio = 0.0;
1303
1304 /// @brief Edge size of mesh
1306
1307 /// @brief Initial norm of an equation
1309
1310 /// @brief Copy of solution variables where remeshing starts
1311 Array<double> A0;
1312 Array<double> Y0;
1313 Array<double> D0;
1314
1315 /// @brief Flag is set if remeshing is required for each mesh
1316 std::vector<bool> flag;
1317};
1318
1320{
1321 public:
1322 /// @brief Num traces (nodes) local to each process
1324
1325 /// @brief Pointer to global trace (node num) stacked contiguously
1327
1328 /// @brief Num traces (Gauss points) local to each process
1330
1331 /// @brief Pointer to global trace (Gauss point) stacked contiguously
1333};
1334
1335
1336/// @brief Immersed Boundary (IB) data type
1337//
1339{
1340 public:
1341
1342 /// @brief Whether any file being saved
1343 bool savedOnce = false;
1344 //bool savedOnce = .FALSE.
1345
1346 /// @brief IB method
1347 int mthd = 0;
1348 //int mthd = ibMthd_NA;
1349
1350 /// @brief IB coupling
1351 int cpld = 0;
1352 //int cpld = ibCpld_NA;
1353
1354 /// @brief IB interpolation method
1355 int intrp = 0;
1356 //int intrp = ibIntrp_NA;
1357
1358 /// @brief Current IB domain ID
1359 int cDmn = 0;
1360
1361 /// @brief Current equation
1362 int cEq = 0;
1363
1364 /// @brief Total number of IB nodes
1365 int tnNo = 0;
1366
1367 /// @brief Number of IB meshes
1368 int nMsh = 0;
1369
1370 /// @brief IB call duration (1: total time; 2: update; 3,4: communication)
1371 double callD[4] = {0.0, 0.0, 0.0, 0.0};
1372
1373 /// @brief IB Domain ID
1375
1376 /// @brief Row pointer (for sparse LHS matrix storage)
1378
1379 /// @brief Column pointer (for sparse LHS matrix storage)
1381
1382 /// @brief IB position coordinates
1383 Array<double> x;
1384
1385 /// @brief Velocity (new)
1386 Array<double> Yb;
1387
1388 /// @brief Time derivative of displacement (old)
1389 Array<double> Auo;
1390
1391 /// @brief Time derivative of displacement (new)
1392 Array<double> Aun;
1393
1394 /// @brief Time derivative of displacement (n+am)
1395 Array<double> Auk;
1396
1397 /// @brief Displacement (old)
1398 Array<double> Ubo;
1399
1400 /// @brief Displacement (new)
1401 Array<double> Ubn;
1402
1403 /// @brief Displacement (n+af)
1404 Array<double> Ubk;
1405
1406 /// @brief Displacement (projected on background mesh, old)
1407 Array<double> Uo;
1408
1409 /// @brief Displacement (projected on background mesh, new, n+af)
1410 Array<double> Un;
1411
1412 /// @brief Residual (FSI force)
1413 Array<double> R;
1414
1415 /// @brief Residual (displacement, background mesh)
1416 Array<double> Ru;
1417
1418 /// @brief Residual (displacement, IB mesh)
1419 Array<double> Rub;
1420
1421 /// @brief LHS tangent matrix for displacement
1422 Array<double> Ku;
1423
1424 /// @brief DERIVED class VARIABLES IB meshes;
1425 std::vector<mshType> msh;
1426
1427 /// @brief IB communicator
1429};
1430
1431/// @brief Data type for Resistive Immersed Surface
1432//
1434{
1435 public:
1436
1437 /// @brief Number of RIS surface
1438 int nbrRIS = 0;
1439
1440 /// @brief Count time steps where no check is needed
1442
1443 /// @brief List of meshes, and faces connected. The first face is the
1444 // proximal pressure's face, while the second is the distal one
1446
1447 /// @brief Resistance value
1449
1450 /// @brief Flag closed surface active, the valve is considerd open initially
1451 std::vector<bool> clsFlg;
1452
1453 /// @brief Mean distal and proximal pressure (1: distal, 2: proximal)
1454 Array<double> meanP;
1455
1456 /// @brief Mean flux on the RIS surface
1458
1459 /// @brief Status RIS interface
1460 std::vector<bool> status;
1461};
1462
1463/// @brief Unfitted Resistive Immersed surface data type
1464//
1466{
1467 public:
1468
1469 // Name of the URIS instance.
1470 std::string name;
1471
1472 // Whether any file has been saved.
1473 bool savedOnce = false;
1474
1475 // Total number of IB nodes.
1476 int tnNo = 0;
1477
1478 // Number of IB meshes.
1479 int nFa = 0;
1480
1481 // Position coordinates (2D array: rows x columns).
1482 Array<double> x;
1483
1484 // Displacement (new) (2D array).
1485 Array<double> Yd;
1486
1487 // Default signed distance value away from the valve.
1488 double sdf_default = 10.0;
1489
1490 // Default distance value of the valve boundary (valve thickness).
1491 double sdf_deps = 0.04;
1492
1493 // Default distance value of the valve boundary when the valve is closed.
1494 double sdf_deps_close = 0.25;
1495
1496 // Displacements of the valve when it opens (3D array).
1497 Array3<double> DxOpen;
1498
1499 // Displacements of the valve when it closes (3D array).
1500 Array3<double> DxClose;
1501
1502 // Normal vector pointing in the positive flow direction (1D array).
1503 Vector<double> nrm;
1504
1505 // Close flag.
1506 bool clsFlg = true;
1507
1508 // Iteration count.
1509 int cnt = 1000000;
1510
1511 // URIS: signed distance function of each node to the uris (1D array).
1512 Vector<double> sdf;
1513
1514 // Mesh scale factor.
1515 double scF = 1.0;
1516
1517 // Mean pressure upstream.
1518 double meanPU = 0.0;
1519
1520 // Mean pressure downstream.
1521 double meanPD = 0.0;
1522
1523 // Relaxation factor to compute weighted averages of pressure values.
1524 double relax_factor = 0.5;
1525
1526 // Array to store the fluid mesh elements that the uris node is in (2D array).
1527 Array<int> elemId;
1528
1529 // Array to count how many times a uris node is found in the fluid mesh of a processor (1D array).
1530 Vector<int> elemCounter;
1531
1532 // Derived type variables
1533 // IB meshes
1534 std::vector<mshType> msh;
1535
1536};
1537
1538/// @brief The ComMod class duplicates the data structures in the Fortran COMMOD module
1539/// defined in MOD.f.
1540///
1541/// The data members here are the global variables exposed by the COMMOD module.
1542//
1543class ComMod {
1544
1545 public:
1546 ComMod();
1547 ~ComMod();
1548
1549 //----- bool members -----//
1550
1551 /// @brief Whether there is a requirement to update mesh and Dn-Do variables
1552 bool dFlag = false;
1553
1554 /// @brief Whether mesh is moving
1555 bool mvMsh = false;
1556
1557 /// @brief Whether to averaged results
1558 bool saveAve = false;
1559
1560 /// @brief Whether to save to VTK files
1561 bool saveVTK = false;
1562
1563 /// @brief Whether any file being saved
1564 bool savedOnce = false;
1565
1566 /// @brief Whether to use separator in output
1567 bool sepOutput = false;
1568
1569 /// @brief Whether start from beginning or from simulations
1570 bool stFileFlag = false;
1571
1572 /// @brief Whether to overwrite restart file or not
1573 bool stFileRepl = false;
1574
1575 /// @brief Restart simulation after remeshing
1576 bool resetSim = false;
1577
1578 /// @brief Check IEN array for initial mesh
1579 bool ichckIEN = false;
1580
1581 /// @brief Reset averaging variables from zero
1582 bool zeroAve = false;
1583
1584 /// @brief Whether CMM equation is initialized
1585 bool cmmInit = false;
1586
1587 /// @brief Whether variable wall properties are used for CMM
1588 bool cmmVarWall = false;
1589
1590 /// @brief Whether shell equation is being solved
1591 bool shlEq = false;
1592
1593 /// @brief Whether PRESTRESS is being solved
1594 bool pstEq = false;
1595
1596 /// @brief Whether velocity-pressure based structural dynamics solver is used
1597 bool sstEq = false;
1598
1599 /// @brief Whether to detect and apply any contact model
1600 bool iCntct = false;
1601
1602 /// @brief Whether any Immersed Boundary (IB) treatment is required
1603 bool ibFlag = false;
1604
1605 /// @brief Postprocess step - convert bin to vtk
1606 bool bin2VTK = false;
1607
1608 /// @brief Whether any RIS surface is considered
1609 bool risFlag = false;
1610
1611 /// @brief Whether any one-sided RIS surface with 0D coupling is considered
1612 bool ris0DFlag = false;
1613
1614 /// @brief Whether any URIS surface is considered
1615 bool urisFlag = false;
1616
1617 /// @brief Whether the URIS surface is active
1618 bool urisActFlag = false;
1619
1620 /// @brief Number of URIS surfaces (uninitialized, to be set later)
1622
1623 /// @brief URIS resistance
1624 double urisRes;
1625
1626 /// @brief URIS resistance when the valve is closed
1628
1629 /// @brief Whether to use precomputed state-variable solutions
1630 bool usePrecomp = false;
1631 //----- int members -----//
1632
1633 /// @brief Current domain
1634 int cDmn = 0;
1635
1636 /// @brief Current equation
1637 int cEq = 0;
1638
1639 /// @brief Current time step
1640 int cTS = 0;
1641
1642 std::array<double,3> timeP;
1643
1644 /// @brief Starting time step
1645 int startTS = 0;
1646
1647 /// @brief Current equation degrees of freedom
1648 int dof = 0;
1649
1650 /// @brief Global total number of nodes, across all meshes (total) and all
1651 /// procs (global)
1652 int gtnNo = 0;
1653
1654 /// @brief Number of equations
1655 int nEq = 0;
1656
1657 /// @brief Number of faces in the LHS passed to FSILS
1658 int nFacesLS = 0;
1659
1660 /// @brief Number of meshes
1661 int nMsh = 0;
1662
1663 /// @brief Number of spatial dimensions
1664 int nsd = 0;
1665
1666 /// @brief Number of time steps
1667 int nTS = 0;
1668
1669 /// @brief Number of initialization time steps
1670 int nITs = 0;
1671
1672 /// @brief stFiles record length
1673 int recLn = 0;
1674
1675 /// @brief Start saving after this number of time step
1676 int saveATS = 0;
1677
1678 /// @brief Increment in saving solutions
1679 int saveIncr = 0;
1680
1681 /// @brief Stamp ID to make sure simulation is compatible with stFiles
1682 std::array<int,7> stamp;
1683
1684 /// @brief Increment in saving restart file
1685 int stFileIncr = 0;
1686
1687 /// @brief Total number of degrees of freedom per node
1688 int tDof = 0;
1689
1690 /// @brief Total number of nodes (number of nodes on current proc across
1691 /// all meshes)
1692 int tnNo = 0;
1693
1694 /// @brief Restart Time Step
1695 int rsTS = 0;
1696
1697 /// @brief Number of stress values to be stored
1698 int nsymd = 0;
1699
1700 /// @brief Nbr of iterations
1701 int RisnbrIter = 0;
1702
1703
1704 //----- double members -----//
1705
1706 /// @brief Time step size
1707 double dt = 0.0;
1708
1709 /// @brief Time step size of the precomputed state-variables
1710 double precompDt = 0.0;
1711
1712 /// @brief Time
1713 double time = 0.0;
1714
1715
1716 //----- string members -----//
1717
1718 /// @brief Initialization file path
1719 std::string iniFilePath;
1720
1721 /// @brief Saved output file name
1722 std::string saveName;
1723
1724 /// @brief Restart file name
1725 std::string stFileName;
1726
1727 /// @brief Stop_trigger file name
1728 std::string stopTrigName;
1729
1730 /// @brief Precomputed state-variable file name
1731 std::string precompFileName;
1732
1733 /// @brief Precomputed state-variable field name
1734 std::string precompFieldName;
1735 // ALLOCATABLE DATA
1736
1737 /// @brief Column pointer (for sparse LHS matrix structure)
1738 /// Modified in: lhsa()
1740
1741 /// @brief Domain ID
1743
1744 /// @brief Local to global pointer tnNo --> gtnNo
1746
1747 /// @brief Row pointer (for sparse LHS matrix structure)
1748 /// Modified in: lhsa()
1750
1751 /// @brief Array that maps global node id to rowN in the matrix
1752 /// Modified in: lhsa()
1754
1755 /// @brief Boundary nodes set for CMM initialization and for zeroing-out
1756 /// non-wall nodal displacements
1758
1759 /// @brief IB: iblank used for immersed boundaries (1 => solid, 0 => fluid)
1761
1762 /// @brief TODO: for now, better to organize these within a class
1763 struct Array2D {
1764 // std::vector<std::vector<int>> map;
1765 Array<int> map;
1766 };
1767
1768 /// @brief RIS mapping array, with local (mesh) enumeration
1769 std::vector<Array2D> risMapList;
1770
1771 /// @brief RIS mapping array, with global (total) enumeration
1772 std::vector<Array2D> grisMapList;
1773
1774 /// @brief Old time derivative of variables (acceleration); known result at current time step
1775 Array<double> Ao;
1776
1777 /// @brief New time derivative of variables (acceleration); unknown result at next time step
1778 Array<double> An;
1779
1780 /// @brief Old integrated variables (displacement)
1781 Array<double> Do;
1782
1783 /// @brief New integrated variables (displacement)
1784 Array<double> Dn;
1785
1786 /// @brief Residual vector
1787 Array<double> R;
1788
1789 /// @brief LHS matrix
1790 Array<double> Val;
1791
1792 /// @brief Position vector of mesh nodes (in ref config)
1793 Array<double> x;
1794
1795 /// @brief Old variables (velocity); known result at current time step
1796 Array<double> Yo;
1797
1798 /// @brief New variables (velocity); unknown result at next time step
1799 Array<double> Yn;
1800
1801 /// @brief Body force
1802 Array<double> Bf;
1803
1804 //-----------------------------------------------------
1805 // Additional arrays for velocity-based formulation of
1806 // nonlinear solid mechanics.
1807 //-----------------------------------------------------
1808
1809 /// @brief Time derivative of displacement
1810 Array<double> Ad;
1811
1812 /// @brief Residual of the displacement equation
1813 Array<double> Rd;
1814
1815 /// @brief LHS matrix for displacement equation
1816 Array<double> Kd;
1817
1818 /// @brief Variables for prestress calculations
1819 Array<double> pS0;
1820 Array<double> pSn;
1821 Vector<double> pSa;
1822
1823 /// @brief Temporary storage for initializing state variables
1825 Array<double> Vinit;
1826 Array<double> Dinit;
1827
1828 /// @brief CMM-variable wall properties: 1-thickness, 2-Elasticity modulus
1829 Array<double> varWallProps;
1830
1831 //------------------------
1832 // DERIVED TYPE VARIABLES
1833 //------------------------
1834
1835 /// @brief Coupled BCs structures used for multidomain simulations
1837
1838 /// @brief All data related to equations are stored in this container
1839 std::vector<eqType> eq;
1840
1841 /// @brief FSILS data structure to produce LHS sparse matrix
1842 fsi_linear_solver::FSILS_lhsType lhs;
1843
1844 /// @brief All the meshes are stored in this variable
1845 std::vector<mshType> msh;
1846
1847 /// @brief Input/output to the screen is handled by this structure
1848 chnlType std, err, wrn, dbg;
1849
1850 /// @brief To group above channels
1852
1853 /// @brief The general communicator
1855
1856 /// @brief Remesher type
1858
1859 /// @brief Contact model type
1861
1862 /// @brief IB: Immersed boundary data structure
1864
1865 /// @brief risFace object
1867
1868 /// @brief unfitted RIS object
1869 std::vector<urisType> uris;
1870
1871 bool debug_active = false;
1872
1873 Timer timer;
1874};
1875
1876#endif
1877
The Array3 template class implements a simple interface to 3D arrays.
Definition Array3.h:52
Definition ArtificialNeuralNetMaterial.h:57
The ComMod class duplicates the data structures in the Fortran COMMOD module defined in MOD....
Definition ComMod.h:1543
std::string stopTrigName
Stop_trigger file name.
Definition ComMod.h:1728
ibType ib
IB: Immersed boundary data structure.
Definition ComMod.h:1863
int stFileIncr
Increment in saving restart file.
Definition ComMod.h:1685
int nITs
Number of initialization time steps.
Definition ComMod.h:1670
bool ibFlag
Whether any Immersed Boundary (IB) treatment is required.
Definition ComMod.h:1603
Vector< int > colPtr
Column pointer (for sparse LHS matrix structure) Modified in: lhsa()
Definition ComMod.h:1739
bool zeroAve
Reset averaging variables from zero.
Definition ComMod.h:1582
std::string saveName
Saved output file name.
Definition ComMod.h:1722
std::vector< Array2D > grisMapList
RIS mapping array, with global (total) enumeration.
Definition ComMod.h:1772
int nMsh
Number of meshes.
Definition ComMod.h:1661
chnlType std
Input/output to the screen is handled by this structure.
Definition ComMod.h:1848
bool savedOnce
Whether any file being saved.
Definition ComMod.h:1564
risFaceType ris
risFace object
Definition ComMod.h:1866
bool stFileRepl
Whether to overwrite restart file or not.
Definition ComMod.h:1573
Array< double > varWallProps
CMM-variable wall properties: 1-thickness, 2-Elasticity modulus.
Definition ComMod.h:1829
Array< double > x
Position vector of mesh nodes (in ref config)
Definition ComMod.h:1793
bool cmmVarWall
Whether variable wall properties are used for CMM.
Definition ComMod.h:1588
std::array< int, 7 > stamp
Stamp ID to make sure simulation is compatible with stFiles.
Definition ComMod.h:1682
Array< double > Ad
Time derivative of displacement.
Definition ComMod.h:1810
int cTS
Current time step.
Definition ComMod.h:1640
int dof
Current equation degrees of freedom.
Definition ComMod.h:1648
bool urisFlag
Whether any URIS surface is considered.
Definition ComMod.h:1615
int gtnNo
Global total number of nodes, across all meshes (total) and all procs (global)
Definition ComMod.h:1652
std::string stFileName
Restart file name.
Definition ComMod.h:1725
int tnNo
Total number of nodes (number of nodes on current proc across all meshes)
Definition ComMod.h:1692
int nsd
Number of spatial dimensions.
Definition ComMod.h:1664
int nFacesLS
Number of faces in the LHS passed to FSILS.
Definition ComMod.h:1658
int nsymd
Number of stress values to be stored.
Definition ComMod.h:1698
Array< double > Yn
New variables (velocity); unknown result at next time step.
Definition ComMod.h:1799
double urisRes
URIS resistance.
Definition ComMod.h:1624
bool ichckIEN
Check IEN array for initial mesh.
Definition ComMod.h:1579
std::string iniFilePath
Initialization file path.
Definition ComMod.h:1719
Vector< int > rowPtr
Row pointer (for sparse LHS matrix structure) Modified in: lhsa()
Definition ComMod.h:1749
std::string precompFileName
Precomputed state-variable file name.
Definition ComMod.h:1731
std::vector< Array2D > risMapList
RIS mapping array, with local (mesh) enumeration.
Definition ComMod.h:1769
int cEq
Current equation.
Definition ComMod.h:1637
Vector< int > cmmBdry
Boundary nodes set for CMM initialization and for zeroing-out non-wall nodal displacements.
Definition ComMod.h:1757
Array< double > Val
LHS matrix.
Definition ComMod.h:1790
bool bin2VTK
Postprocess step - convert bin to vtk.
Definition ComMod.h:1606
bool saveAve
Whether to averaged results.
Definition ComMod.h:1558
bool saveVTK
Whether to save to VTK files.
Definition ComMod.h:1561
int tDof
Total number of degrees of freedom per node.
Definition ComMod.h:1688
std::vector< urisType > uris
unfitted RIS object
Definition ComMod.h:1869
bool ris0DFlag
Whether any one-sided RIS surface with 0D coupling is considered.
Definition ComMod.h:1612
bool risFlag
Whether any RIS surface is considered.
Definition ComMod.h:1609
std::string precompFieldName
Precomputed state-variable field name.
Definition ComMod.h:1734
bool cmmInit
Whether CMM equation is initialized.
Definition ComMod.h:1585
Array< double > Rd
Residual of the displacement equation.
Definition ComMod.h:1813
cplBCType cplBC
Coupled BCs structures used for multidomain simulations.
Definition ComMod.h:1836
double time
Time.
Definition ComMod.h:1713
Array< double > Dn
New integrated variables (displacement)
Definition ComMod.h:1784
bool pstEq
Whether PRESTRESS is being solved.
Definition ComMod.h:1594
bool resetSim
Restart simulation after remeshing.
Definition ComMod.h:1576
Array< double > An
New time derivative of variables (acceleration); unknown result at next time step.
Definition ComMod.h:1778
double dt
Time step size.
Definition ComMod.h:1707
bool urisActFlag
Whether the URIS surface is active.
Definition ComMod.h:1618
Array< double > R
Residual vector.
Definition ComMod.h:1787
rmshType rmsh
Remesher type.
Definition ComMod.h:1857
int saveIncr
Increment in saving solutions.
Definition ComMod.h:1679
bool usePrecomp
Whether to use precomputed state-variable solutions.
Definition ComMod.h:1630
ioType io
To group above channels.
Definition ComMod.h:1851
cntctModelType cntctM
Contact model type.
Definition ComMod.h:1860
double urisResClose
URIS resistance when the valve is closed.
Definition ComMod.h:1627
int RisnbrIter
Nbr of iterations.
Definition ComMod.h:1701
cmType cm
The general communicator.
Definition ComMod.h:1854
int nUris
Number of URIS surfaces (uninitialized, to be set later)
Definition ComMod.h:1621
int startTS
Starting time step.
Definition ComMod.h:1645
Vector< int > idMap
Array that maps global node id to rowN in the matrix Modified in: lhsa()
Definition ComMod.h:1753
bool stFileFlag
Whether start from beginning or from simulations.
Definition ComMod.h:1570
bool sepOutput
Whether to use separator in output.
Definition ComMod.h:1567
bool shlEq
Whether shell equation is being solved.
Definition ComMod.h:1591
std::vector< eqType > eq
All data related to equations are stored in this container.
Definition ComMod.h:1839
bool iCntct
Whether to detect and apply any contact model.
Definition ComMod.h:1600
double precompDt
Time step size of the precomputed state-variables.
Definition ComMod.h:1710
Array< double > Do
Old integrated variables (displacement)
Definition ComMod.h:1781
bool dFlag
Whether there is a requirement to update mesh and Dn-Do variables.
Definition ComMod.h:1552
int cDmn
Current domain.
Definition ComMod.h:1634
int nTS
Number of time steps.
Definition ComMod.h:1667
Array< double > Ao
Old time derivative of variables (acceleration); known result at current time step.
Definition ComMod.h:1775
int nEq
Number of equations.
Definition ComMod.h:1655
Vector< int > iblank
IB: iblank used for immersed boundaries (1 => solid, 0 => fluid)
Definition ComMod.h:1760
Array< double > Kd
LHS matrix for displacement equation.
Definition ComMod.h:1816
std::vector< mshType > msh
All the meshes are stored in this variable.
Definition ComMod.h:1845
int recLn
stFiles record length
Definition ComMod.h:1673
int rsTS
Restart Time Step.
Definition ComMod.h:1695
bool mvMsh
Whether mesh is moving.
Definition ComMod.h:1555
Vector< double > Pinit
Temporary storage for initializing state variables.
Definition ComMod.h:1824
Vector< int > ltg
Local to global pointer tnNo --> gtnNo.
Definition ComMod.h:1745
fsi_linear_solver::FSILS_lhsType lhs
FSILS data structure to produce LHS sparse matrix.
Definition ComMod.h:1842
Array< double > Yo
Old variables (velocity); known result at current time step.
Definition ComMod.h:1796
Array< double > Bf
Body force.
Definition ComMod.h:1802
Vector< int > dmnId
Domain ID.
Definition ComMod.h:1742
Array< double > pS0
Variables for prestress calculations.
Definition ComMod.h:1819
int saveATS
Start saving after this number of time step.
Definition ComMod.h:1676
bool sstEq
Whether velocity-pressure based structural dynamics solver is used.
Definition ComMod.h:1597
The LinearAlgebra class provides an abstract interface to linear algebra frameworks: FSILS,...
Definition LinearAlgebra.h:40
Moving boundary data structure (used for general BC)
Definition ComMod.h:107
Keep track of time.
Definition Timer.h:40
The Vector template class is used for storing int and double data.
Definition Vector.h:50
Mesh adjacency (neighboring element for each element)
Definition ComMod.h:486
Boundary condition data type.
Definition ComMod.h:151
Definition ComMod.h:310
Class storing data for B-Splines.
Definition ComMod.h:235
Cardiac electrophysiology model type.
Definition CepMod.h:158
Channel type, used in I/O.
Definition ChnlMod.h:46
The cmType class stores data and defines methods used for mpi communication.
Definition CmMod.h:82
Contact model type.
Definition ComMod.h:737
For coupled 0D-3D problems.
Definition ComMod.h:834
consts::CplBCType schm
Implicit/Explicit/Semi-implicit schemes.
Definition ComMod.h:859
int nX
Number of unknowns in the 0D domain.
Definition ComMod.h:853
int nFa
Number of coupled faces.
Definition ComMod.h:850
Vector< double > xo
Old time step unknowns in the 0D domain.
Definition ComMod.h:879
bool useGenBC
Whether to use genBC.
Definition ComMod.h:841
std::string binPath
Path to the 0D code binary file.
Definition ComMod.h:863
std::string saveName
The name of history file containing "X".
Definition ComMod.h:872
std::string commuName
File name for communication between 0D and 3D.
Definition ComMod.h:866
bool coupled
Is multi-domain active.
Definition ComMod.h:838
std::vector< cplFaceType > fa
Data structure used for communicating with 0D code.
Definition ComMod.h:885
Vector< double > xp
Output variables to be printed.
Definition ComMod.h:882
Vector< double > xn
New time step unknowns in the 0D domain.
Definition ComMod.h:876
int nXp
Number of output variables addition to nX.
Definition ComMod.h:856
Definition ComMod.h:759
This type will be used to write data in the VTK files.
Definition ComMod.h:1241
Domain type is to keep track with element belong to which domain and also different physical quantiti...
Definition ComMod.h:451
Equation type.
Definition ComMod.h:1098
LinearAlgebra * linear_algebra
Interface to a numerical linear algebra library.
Definition ComMod.h:1208
double roInf
Definition ComMod.h:1186
int maxItr
Maximum iteration for this eq.
Definition ComMod.h:1129
int s
Pointer to start of unknown Yo(:,s:e)
Definition ComMod.h:1123
int nDmnIB
IB: Number of immersed domains.
Definition ComMod.h:1147
bool coupled
Should be satisfied in a coupled/uncoupled fashion.
Definition ComMod.h:1104
bool ok
Satisfied/not satisfied.
Definition ComMod.h:1108
int nBcIB
Number of BCs on immersed surfaces.
Definition ComMod.h:1153
std::string sym
Equation symbol.
Definition ComMod.h:1192
bool assmTLS
Use C++ Trilinos framework for assembly and for linear solvers.
Definition ComMod.h:1114
lsType ls
type of linear solver
Definition ComMod.h:1196
std::vector< outputType > outIB
IB: Outputs.
Definition ComMod.h:1229
double tol
Accepted relative tolerance.
Definition ComMod.h:1189
bool useTLS
Use C++ Trilinos framework for the linear solvers.
Definition ComMod.h:1111
int itr
Number of performed iterations.
Definition ComMod.h:1126
double gam
Definition ComMod.h:1177
std::vector< outputType > outURIS
URIS: Outputs.
Definition ComMod.h:1232
int nBc
Number of BCs.
Definition ComMod.h:1150
int e
Pointer to end of unknown Yo(:,s:e)
Definition ComMod.h:1120
std::vector< dmnType > dmn
domains that this equation must be solved
Definition ComMod.h:1220
consts::PreconditionerType linear_algebra_preconditioner
The type of preconditioner used by the interface to a numerical linear algebra library.
Definition ComMod.h:1205
int nOutIB
IB: Number of possible outputs.
Definition ComMod.h:1138
double am
Definition ComMod.h:1171
double iNorm
Initial norm of residual.
Definition ComMod.h:1180
consts::LinearAlgebraType linear_algebra_assembly_type
The type of assembly interface to a numerical linear algebra library.
Definition ComMod.h:1202
consts::LinearAlgebraType linear_algebra_type
The type of interface to a numerical linear algebra library.
Definition ComMod.h:1199
int nOutURIS
URIS: Number of possible outputs.
Definition ComMod.h:1141
std::vector< bfType > bf
Body force associated with this equation.
Definition ComMod.h:1235
double pNorm
First iteration norm.
Definition ComMod.h:1183
double af
Definition ComMod.h:1164
int nBf
Number of BFs.
Definition ComMod.h:1156
int nDmn
Number of domains.
Definition ComMod.h:1144
int nOutput
Number of possible outputs.
Definition ComMod.h:1135
std::vector< dmnType > dmnIB
IB: immersed domains that this equation must be solved.
Definition ComMod.h:1223
std::vector< bcType > bc
BCs associated with this equation;.
Definition ComMod.h:1214
std::vector< bcType > bcIB
IB: BCs associated with this equation on immersed surfaces.
Definition ComMod.h:1217
int dof
Degrees of freedom.
Definition ComMod.h:1117
fsi_linear_solver::FSILS_lsType FSILS
FSILS type of linear solver.
Definition ComMod.h:1211
consts::EquationType phys
Type of equation fluid/heatF/heatS/lElas/FSI.
Definition ComMod.h:1159
std::vector< outputType > output
Outputs.
Definition ComMod.h:1226
double beta
Definition ComMod.h:1174
int minItr
Minimum iteration for this eq.
Definition ComMod.h:1132
The face type containing mesh at boundary.
Definition ComMod.h:540
void destroy()
Free memory and reset some data members.
Definition ComMod.cpp:147
Fourier coefficients that are used to specify unsteady BCs.
Definition ComMod.h:71
Definition ComMod.h:340
Fluid viscosity model type.
Definition ComMod.h:412
Function spaces (basis) type.
Definition ComMod.h:262
void destroy()
SUBROUTINE DESTROYFS(fs)
Definition ComMod.cpp:184
Definition ComMod.h:1320
Vector< int > nG
Num traces (Gauss points) local to each process.
Definition ComMod.h:1329
Vector< int > n
Num traces (nodes) local to each process.
Definition ComMod.h:1323
Vector< int > gE
Pointer to global trace (Gauss point) stacked contiguously.
Definition ComMod.h:1332
Vector< int > gN
Pointer to global trace (node num) stacked contiguously.
Definition ComMod.h:1326
Immersed Boundary (IB) data type.
Definition ComMod.h:1339
Array< double > x
IB position coordinates.
Definition ComMod.h:1383
Array< double > Aun
Time derivative of displacement (new)
Definition ComMod.h:1392
int cpld
IB coupling.
Definition ComMod.h:1351
Array< double > Ku
LHS tangent matrix for displacement.
Definition ComMod.h:1422
int tnNo
Total number of IB nodes.
Definition ComMod.h:1365
Array< double > Un
Displacement (projected on background mesh, new, n+af)
Definition ComMod.h:1410
int cEq
Current equation.
Definition ComMod.h:1362
Array< double > R
Residual (FSI force)
Definition ComMod.h:1413
int intrp
IB interpolation method.
Definition ComMod.h:1355
Array< double > Uo
Displacement (projected on background mesh, old)
Definition ComMod.h:1407
Array< double > Yb
Velocity (new)
Definition ComMod.h:1386
Array< double > Ubn
Displacement (new)
Definition ComMod.h:1401
int cDmn
Current IB domain ID.
Definition ComMod.h:1359
double callD[4]
IB call duration (1: total time; 2: update; 3,4: communication)
Definition ComMod.h:1371
ibCommType cm
IB communicator.
Definition ComMod.h:1428
Vector< int > rowPtr
Row pointer (for sparse LHS matrix storage)
Definition ComMod.h:1377
Array< double > Rub
Residual (displacement, IB mesh)
Definition ComMod.h:1419
bool savedOnce
Whether any file being saved.
Definition ComMod.h:1343
Vector< int > dmnID
IB Domain ID.
Definition ComMod.h:1374
Array< double > Auo
Time derivative of displacement (old)
Definition ComMod.h:1389
Array< double > Ubk
Displacement (n+af)
Definition ComMod.h:1404
int nMsh
Number of IB meshes.
Definition ComMod.h:1368
int mthd
IB method.
Definition ComMod.h:1347
std::vector< mshType > msh
DERIVED class VARIABLES IB meshes;.
Definition ComMod.h:1425
Array< double > Ubo
Displacement (old)
Definition ComMod.h:1398
Vector< int > colPtr
Column pointer (for sparse LHS matrix storage)
Definition ComMod.h:1380
Array< double > Ru
Residual (displacement, background mesh)
Definition ComMod.h:1416
Array< double > Auk
Time derivative of displacement (n+am)
Definition ComMod.h:1395
Only to group four channels, in case I rather have them as one variable.
Definition ChnlMod.h:77
Linear system of equations solver type.
Definition ComMod.h:681
double absTol
Absolute tolerance (IN)
Definition ComMod.h:712
int cN
Number of |x| norms (OUT)
Definition ComMod.h:703
int cD
Number of <x.y> dot products (OUT)
Definition ComMod.h:706
double fNorm
Final norm of residual (OUT)
Definition ComMod.h:721
double callD
Calling duration (OUT)
Definition ComMod.h:727
int reserve
Only for data alignment (-)
Definition ComMod.h:709
bool suc
Successful solving (OUT)
Definition ComMod.h:688
int mItr
Maximum iterations (IN)
Definition ComMod.h:691
consts::SolverType LS_type
LS solver (IN)
Definition ComMod.h:685
int itr
Number of iteration (OUT)
Definition ComMod.h:697
double relTol
Relative tolerance (IN)
Definition ComMod.h:715
double dB
Res. rduction in last itr. (OUT)
Definition ComMod.h:724
int sD
Space dimension (IN)
Definition ComMod.h:694
int cM
Number of Ax multiple (OUT)
Definition ComMod.h:700
double iNorm
Initial norm of residual (OUT)
Definition ComMod.h:718
This is the container for a mesh or NURBS patch, those specific to NURBS are noted.
Definition ComMod.h:892
int nNo
Number of nodes (control points) for 2D elements?
Definition ComMod.h:953
Vector< double > w
Gauss weights.
Definition ComMod.h:1022
std::vector< std::vector< int > > ordering
@breif ordering: node ordering for boundaries
Definition ComMod.h:980
Array< double > N
Parent shape function.
Definition ComMod.h:1034
traceType trc
IB: tracers.
Definition ComMod.h:1077
Array3< double > Ys
Solution field (displacement, velocity, pressure, etc.) for a known, potentially time-varying,...
Definition ComMod.h:1056
Vector< int > eDist
Element distribution between processors.
Definition ComMod.h:983
Vector< int > iGC
IB: Whether a cell is a ghost cell or not.
Definition ComMod.h:1016
adjType nAdj
Mesh nodal adjacency.
Definition ComMod.h:1062
Array< double > xib
Bounds on parameteric coordinates.
Definition ComMod.h:1028
adjType eAdj
Mesh element adjacency.
Definition ComMod.h:1065
int nG
Number of Gauss points for integration.
Definition ComMod.h:950
int nFa
Number of faces.
Definition ComMod.h:944
Array< double > x
Position coordinates (not always, however, as they get overwritten by read_vtu_pdata())
Definition ComMod.h:1031
std::vector< fsType > fs
Function spaces (basis)
Definition ComMod.h:1068
Array3< double > Nxx
Second derivatives of shape functions - used for shells & IGA davep double Nxx(:,:,...
Definition ComMod.h:1052
int gnNo
Global number of nodes (control points) on a single mesh.
Definition ComMod.h:935
double dx
IB: Mesh size parameter.
Definition ComMod.h:968
bool lShpF
Whether the shape function is linear.
Definition ComMod.h:916
Vector< int > lN
Global to local maping tnNo --> nNo.
Definition ComMod.h:1007
Vector< int > otnIEN
gIEN mapper from old to new
Definition ComMod.h:1001
int nFn
Number of fiber directions.
Definition ComMod.h:962
Vector< int > eRIS
RIS: flags of whether elemets are adjacent to RIS projections.
Definition ComMod.h:1081
Array< int > eIEN
Shells: extended IEN array with neighboring nodes.
Definition ComMod.h:1010
Vector< int > gN
Global nodes maping nNo --> tnNo.
Definition ComMod.h:989
bool lFib
Whether the mesh is fibers (Purkinje)
Definition ComMod.h:922
double v
The volume of this mesh.
Definition ComMod.h:977
int eNoN
Number of nodes (control points) in a single element.
Definition ComMod.h:929
double scF
Mesh scale factor.
Definition ComMod.h:965
Vector< int > eId
Element domain ID number.
Definition ComMod.h:986
int gnEl
Global number of elements (knot spans)
Definition ComMod.h:932
double res
RIS resistance value.
Definition ComMod.h:971
Vector< int > partRIS
RIS: processor ids to change element partitions to.
Definition ComMod.h:1084
int nSl
Number of elements sample points to be outputs (NURBS)
Definition ComMod.h:956
Array< double > xi
Gauss integration points in parametric space.
Definition ComMod.h:1025
Array< double > fN
Fiber orientations stored at the element level - used for electrophysiology and solid mechanics.
Definition ComMod.h:1044
int nFs
Number of function spaces.
Definition ComMod.h:947
Array< int > sbc
Shells: boundary condition variable.
Definition ComMod.h:1013
bool lShl
Whether the mesh is shell.
Definition ComMod.h:919
Array< double > Nb
Shape function bounds.
Definition ComMod.h:1037
Array< double > nV
Normal vector to each nodal point (for Shells)
Definition ComMod.h:1040
Vector< double > nW
Control points weights (NURBS)
Definition ComMod.h:1019
Array3< double > Nx
Parent shape functions gradient double Nx(:,:,:)
Definition ComMod.h:1048
std::vector< faceType > fa
Faces are stored in this variable.
Definition ComMod.h:1074
Vector< int > gpN
GLobal projected nodes mapping projected -> unprojected mapping.
Definition ComMod.h:992
Array< int > gIEN
Global connectivity array mappig eNoN,nEl --> gnNo.
Definition ComMod.h:995
int vtkType
The element type recognized by VTK format.
Definition ComMod.h:959
int nEl
Number of elements (knot spans)
Definition ComMod.h:941
consts::ElementType eType
Element type.
Definition ComMod.h:925
int nEf
Number of element face. Used for reading Gambit mesh files.
Definition ComMod.h:938
std::string name
Mesh Name.
Definition ComMod.h:1059
std::vector< bsType > bs
BSpline in different directions (NURBS)
Definition ComMod.h:1071
double tol
RIS projection tolerance.
Definition ComMod.h:974
Array< int > IEN
The connectivity array mapping eNoN,nEl --> nNo.
Definition ComMod.h:998
double qmTET4
TET4 quadrature modifier.
Definition ComMod.h:1087
Array< int > INN
Local knot pointer (NURBS)
Definition ComMod.h:1004
Declared type for outputed variables.
Definition ComMod.h:659
Definition ComMod.h:129
Data type for Resistive Immersed Surface.
Definition ComMod.h:1434
Array3< int > lst
List of meshes, and faces connected. The first face is the.
Definition ComMod.h:1445
std::vector< bool > status
Status RIS interface.
Definition ComMod.h:1460
Vector< double > Res
Resistance value.
Definition ComMod.h:1448
Vector< int > nbrIter
Count time steps where no check is needed.
Definition ComMod.h:1441
Array< double > meanP
Mean distal and proximal pressure (1: distal, 2: proximal)
Definition ComMod.h:1454
int nbrRIS
Number of RIS surface.
Definition ComMod.h:1438
Vector< double > meanFl
Mean flux on the RIS surface.
Definition ComMod.h:1457
std::vector< bool > clsFlg
Flag closed surface active, the valve is considerd open initially.
Definition ComMod.h:1451
Definition ComMod.h:1271
Vector< double > iNorm
Initial norm of an equation.
Definition ComMod.h:1308
int rTS
Time step from which remeshing is done.
Definition ComMod.h:1286
int freq
Time step frequency for forced remeshing.
Definition ComMod.h:1295
int cpVar
Time step freq for saving data.
Definition ComMod.h:1289
Array< double > A0
Copy of solution variables where remeshing starts.
Definition ComMod.h:1311
int cntr
Counter to track number of remesh done.
Definition ComMod.h:1283
std::vector< bool > flag
Flag is set if remeshing is required for each mesh.
Definition ComMod.h:1316
double time
Time where remeshing starts.
Definition ComMod.h:1298
consts::MeshGeneratorType method
Method for remeshing: 1-TetGen, 2-MeshSim.
Definition ComMod.h:1280
double minDihedAng
Mesh quality parameters.
Definition ComMod.h:1301
int fTS
Time step at which forced remeshing is done.
Definition ComMod.h:1292
Vector< double > maxEdgeSize
Edge size of mesh.
Definition ComMod.h:1305
bool isReqd
Whether remesh is required for problem or not.
Definition ComMod.h:1277
Fluid viscosity model type.
Definition ComMod.h:437
Structural domain type.
Definition ComMod.h:359
Definition Parameters.h:684
Definition ComMod.h:799
Tracer type used for immersed boundaries. Identifies traces of nodes and integration points on backgr...
Definition ComMod.h:505
Unfitted Resistive Immersed surface data type.
Definition ComMod.h:1466
TODO: for now, better to organize these within a class
Definition ComMod.h:1763
Store options for output types.
Definition ComMod.h:635