apsis-analysis / perigee Goto Github PK

In Math_Tools, there are several functions that are developed to assist FE routines. Also, the Matrix_double_3by3_Array and Matrix_double_6by6_Array classes are constructed for the same purposes.

We can collect these functions together as FE_Tools, so that the purpose of these functions is clearer.

Dear all
I have tried to build the examples/tet4_vascular/FSI with cmake, but followed errors occur.

`CMake Error at CMakeLists.txt:149 (ADD_LIBRARY):
Cannot find source file:

/home/shuoxing/software/PERIGEE/src/Mesh/IElemBC.cpp

Tried extensions .c .C .c++ .cc .cpp .cxx .cu .mpp .m .M .mm .ixx .cppm .h
.hh .h++ .hm .hpp .hxx .in .txx .f .F .for .f77 .f90 .f95 .f03 .hip .ispc

CMake Error at CMakeLists.txt:149 (ADD_LIBRARY):
No SOURCES given to target: perigee_preprocess
`
I think the source file is missed.

Best

use std::array<double,9> for dxi_dx;

use SymmMatrix_3x3 for the G metric tensor in the definition of taus.

• 1. We will get rid of the get_normal_out old fashinoned implementation, instead use the one with Vector_3 as input.
• 2. The build basis function needs a way to get std::array<std::vector,3> as the input of the control points.
• 3. Same for the get_h funciton.
• 4. We rarely use get_d2R_dxx in our code, so this kind of get function, perhaps, can be removed.
• 5. It can be convenient to return std::array<std::vector,4> for get_R_gradR and such type of access functions.

we need a mechanism to prevent singularity in the power law model as there are share rate term at the denominator in the expression.

It can be helpful if we also record the flow inlet outlet data, so we may know the setting of the ps solver at a later time.

we need to enable a combination of isochoric and volumetric energies. Each of the two can be instantined by derived classes. This shall enable more flexible ways of generating new material models.

We will need a few additional functions in the Tensor4 class:

1. add_SymmOutProduct : += val * (A_ij B_kl + B_ij A_kl).

This has been planned for a while. We do need the matrix-free technique to reduce the memory burden on our solver.

there could be erronous vtk files generated from gmsh converter. we need to have an error handler when loading these files. Otherwise, the code crashes without a sign.

It is stupid to let the programmer decide which exit function to call. We should unify the way for aborting the program.

Petsc has a compiler directive that tells the code if PETSc is used or not. We could use it in the print_fatal funciton.

https://charlesreid1.com/wiki/Petsc

We had an old implementation of ALE-CFD. We need to enable this capability in the PERIGEE code, for the study of, say, blood pumps.

We may have a separate example folder for it, or, merge it with the NS code.

we need to print the nonzero info from the assembly routine, which is already done. We multiply 4 in the assembly with the given nonzero estimate. Perhaps this is a bit confusing. Need to unify in the future.

1. Gmsh_FileIO private: void read_periodic(), std::vector periodic_slave, std::vector periodic_master (node indices)

2. write_vtp or write_quadratic_vtu( ..., bool is_periodic), if yes: DataVecStr{ {...}, "PeriodicMasterID", "Node"} written

3. class NodalBC_periodic : public INodalBC, otherwise we just modified NodalBC

It will be better to have this code installed and run on a Windows system. We need to document the steps for the deployment in the README file.

In at least two parts, the procedure can be accelerated by an OpenMP type parallelization:

1. In the convection from gmsh to vtu, the loop over element can be parallelized;
2. In the partition of the mesh file, the generation of part file can be parallelized.

We should not make it a derived class of Matrix_Dense as it does not need the permutation vector pp at all. Logically, making it an independent class will make things easier and cleaner.

we may need a inflow function that approaches steady state by a smooth function, using cos, or tanh functions. This may help the code behavior in nonlinear solver.

ALocal_NodalBC ---> ALocal_NBC.

This makes its name follow the style of EBC.

better name

we will need to recrod the solver at the end of prestress solver, together with the record of PS_DATA

We just need a single NodalBC_3D class that loads a vtp/vtu file from disk.

1. We need to rename the member data m and n as gm and gn;
2. We need to extract the actual memory allocation and use it for the actual, finally-assembled matrices.

need a new way of setting material model parameters in wall solver. Currently, it reads from hdf5 file. Need to add a way to alter the parameters from, say command line.

These are outdated functions in MATH_T.

If one use them, one shall resort to fun in Vector_3.

PetscAssume is added in PETSc 3.18 (https://petsc.org/release/changes/318/)

Our ASSERT function is PetscAssume. Thus it is not backward compatible.

We need to call an alternate function when PetscAssume is not supported in older releases.

checking the mesh quality can be slow and we may have a flag in preprocessor to choose whether we want to do it.

new C++ allows a to_string function that does the same thing. So we do not need to have the same function in our sys_tools class. To do the replacement, we need to carefully replace all SYS_T::to_string by to_string and testing.

We need a helper function that truely empty a std vector with its size and capacity to zero.

For example, Solid_Prestress needs this function to free the memory in a fluid element.

we shall be able to identiy the physical domain index range in the Gmsh_FileIO code.

There are certain cases that we want to apply dirichelt only or neumann only boundary conditions for the pipe system. In the PERIGEE code, we need to allow the users to do so.

We, in the long run, need to be able to use full Hex mesh for all calculations.

ALocal_inflow_NodalBC ---> ALocal_inflow_Data

This class does not hold NodalBC data, meaning it is not used to enforce BC on the matrix problem. Thus we change its name to avoid misunderstanding.

We will need a class to load hex mesh's boundary file for surface integral (Neuman BC).

In particular, we need to discuss a rule for the outward normal vector definition, and implement a reset IEN function for hex-quad mesh.

we could invoke vector tools to get max min entries of a vector. This may simplify the writing of preprocessor.

Oftentimes, we need to work on symmetric matrices. We need a dedicated class that holds the six matrix entries.

Since 3.19, PETSc invokes PETSC_NULLPTR.

see https://petsc.org/release/changes/319/

currently, we use #define PETSC_SILENCE_DEPRECATION_WARNINGS_3_19_0
in SYS_Tools to blind this warning message. We will have to update our call of related PETSc functions and remove the above marco.

We need to enforce that the physical group is numbered from 0. Otherwise, we will throw a fatal error message in our Gmsh_FileIO.

Is there any additional checkers that we want to add?

The code can essentially enable full Neumann for cap surfaces. There are a few minor things to take into account.

1. The inflow file shall allow num_nbc to be zero;
2. The backflow stabilization term shall be turned off, at least for the `inflow' caps;

With the above two, one can enable the full Neumann cap bc by setting num_inlet to zero, and prepare all caps meshes with the name starting by outflow_vol_.

Vec3:: for Vector_3

Ten2:: for Tensor2_

Ten4:: for Tensor4_

STen2:: for SymmTensor2

STen4:: for SymmTensor4

namespace

/Users/juliu/PERIGEE/examples/cmm/src/PNonlinear_CMM_Solver.cpp:504:32: warning: declaration shadows
a field of 'PNonlinear_CMM_Solver' [-Wshadow]
const PDNSolution * const &dot_step,
^
/Users/juliu/PERIGEE/examples/cmm/./include/PNonlinear_CMM_Solver.hpp:122:19: note: previous
declaration is here
PDNSolution * dot_step;
^
/Users/juliu/PERIGEE/examples/cmm/src/PNonlinear_CMM_Solver.cpp:552:26: warning: declaration shadows
a field of 'PNonlinear_CMM_Solver' [-Wshadow]
PDNSolution * const &dot_step) const
^
/Users/juliu/PERIGEE/examples/cmm/./include/PNonlinear_CMM_Solver.hpp:122:19: note: previous
declaration is here
PDNSolution * dot_step;
^
2 warnings generated.

We need to at least conver the data structure from [6][6] to a oneD array of [36].

And we do not need to store the inverse of diagonal entries in the member data.

we do not need specific mesh IEN classes for different elements. They could be implemented in a more unified manner.

there are cases when the flow is not for cardiovascular simulations. The inlet is not a circular plane. We need to enable this in the code.

I implemented a reset IEN function to ensure that the inflow surface is organzied to know its orientation.

1. needs some testing;
2. need to add it to cmm, ns, and tet4_vascular.

For education purposes, we need to enable a linear elasticity example, preferably in the linearPDE folder.

From PETSc 3.15, we may pass all petsc argument in a single YAML file, which allows us to make comments. This is more user friendly as we may have very long nested arguments for our solver control.

The member data std::vector< std::vector > local_pt_xyz; shall be written as std::vector< std::vector<Vector_3> >.

Elasticity tensor typically has major and minor symmetries. We will need a class that leverage this symmetry property.

ALocal_Ring_NodalBC ---> ALocal_RingBC.