Merge pull request #17 from ulgltas/adrien

CUPyDO 1.2

Author: acrovato

README.md

@@ -4,170 +4,30 @@ FSI tools for partinioned coupling between generic solid and fluid solvers.
 [![Apache License Version 2.0](https://img.shields.io/badge/license-Apache_2.0-green.svg)](LICENSE)
 
 ## Features
-As of December 2018, interfaces for the following solvers are implemented:
-
+CUPyDO currently features interfaces for the following solvers:
 - Solid:
   - Metafor --> A Nonlinear Finite Element solid solver developed at the University of Liège (http://metafor.ltas.ulg.ac.be/dokuwiki/)
   - RBM --> A dynamic 2dof pitch/plunge solid solver developed at the University of Liège (https://github.com/ulgltas/NativeSolid)
   - modali -> A static/dynamic modal solver developed at the University of Liège (https://github.com/ulgltas/modali)
   - GetDP --> A free finite element software and a general environment for the treatment of discrete problems, developed at University of Liège (http://getdp.info/)
 - Fluid:
-  - PFEM --> Particle Finite Element Method fluid solver developed at the University of Liège (https://github.com/ulgltas/PFEM)
-  - SU2 --> Open-source CFD code developed at Stanford University (http://su2.stanford.edu/)
-  - Flow --> A Full Potential Finite Element fluid solver, part of the waves project, developed at the University of Liège (https://github.com/ulgltas/waves)
-
-## CUPyDO Compilation (linux - gcc)
-Required packages
-```bash
-sudo apt-get install build-essential
-sudo apt-get install cmake
-sudo apt-get install python2.7 python2.7-dev libpython2.7-dev
-sudo apt-get install swig
-sudo apt-get install python-numpy python-scipy
-```
-Optional packages (parallel build, required for SU2+MPI)
-```bash
-sudo apt-get install libopenblas-dev liblapack-dev
-sudo apt-get install openmpi-bin openmpi-common libopenmpi-dev
-sudo apt-get install petsc-dev
-sudo apt-get install python-mpi4py
-sudo apt-get install python-petsc4py
-```
-Compilation
-```bash
-mkdir build && cd build
-[export INCLUDE=${INCLUDE}:/path/to/petsc/include]
-cmake [-DWITH_MPI=ON] [-DCMAKE_BUILD_TYPE=Debug] ..
-make -j4
-make install
-```
-Notes:
-* MPI should be enabled if you want to use the MPI version of SU2. Keep this option disabled otherwise. 
-* `path/to/petsc/include` is usually `/usr/lib/petscdir/version/` on Ubuntu/Debian
-* The "install" step is mandatory. It copies the binaries in `CUPyDO/ccupydo`.
-
-
-Run test battery
-```bash
-ctest [-R include_pattern] [-E exclude_pattern] -j4
-```
-
-Run test file
-```bash
-python run.py path/to/testfile_fsi.py -n4
-```
-
-## Interfaced solvers compilation (linux - gcc)
-Brief instructions to compile interfaced solvers. The full documentation is available on the aforementioned websites.
-The directories containing the external solvers must be placed at the same level as CUPyDO directory.
-
-### Common packages
-```bash
-sudo apt-get install gmsh
-sudo apt-get install libtbb-dev
-sudo apt-get install libvtk6.3 libvtk6-dev libvtk6-qt-dev python-vtk6 python-pyqt5
-```
-
-### Metafor
-[Linux, Windows, macOS]
-
-Required packages
-```bash
-sudo apt install subversion
-sudo apt install bison flex 
-mkdir Metafor && cd Metafor
-git clone [email protected]:ulgltas/linuxbin.git
-```
-Compilation
-```bash
-svn co svn+ssh://[email protected]/home/metafor/SVN/oo_meta/trunk oo_meta
-mkdir oo_metaB && cd oo_metaB
-cmake -C ../oo_meta/CMake/configMachine-CUPyDO.cmake [-DCMAKE_INSTALL_PREFIX=/path/to/Metafor/install/folder] [-DCMAKE_BUILD_TYPE=Debug] ../oo_meta
-make -j4
-```
-Notes: 
-* Metafor cannot be built with the "parasolid" interface which uses the same class names as `waves/fwk`
-* A "sutdent" configuration can be used but some tests will not pass due to license restrictions.
-
-### RBM [NativeSolid]
-[Linux]
-
-Required packages
-```bash
-sudo apt-get install liblapacke-dev
-sudo apt-get install libatlas-base-dev
-```
-Compilation
-```bash
-git clone [email protected]:ulgltas/NativeSolid.git
-cd NativeSolid
-mkdir build && cd build
-cmake ..
-make -j4
-```
-Windows: FIX LAPACKE
-
-### modali
-[Linux]
-
-Get the code
-```bash
-git clone [email protected]:ulgltas/modali.git
-```
-
-### SU2
-[Linux]
-```bash
-sudo apt-get install autoconf
-git clone [email protected]:su2code/SU2.git
-cd SU2
-git checkout tags/v6.2.0
-unset MKLROOT   # <= MKL should be disabled
-./bootstrap
-./configure --prefix=/path/to/SU2/install/folder CXXFLAGS="-O3" [--enable-mpi --with-cc=/path/to/mpicc --with-cxx=/path/to/mpicxx] --enable-PY_WRAPPER [--enable-tecio]
-make -j4
-make install
-```
-Notes:
-* The INSTALL step is mandatory!
-* MPI should be enabled/disabled in both CUPyDO and SU2.
-
-
-### Waves/flow
-[Linux, Windows, macOS]
-
-Required packages
-```bash
-sudo apt-get install libgmm++-dev libeigen3-dev
-sudo apt-get install libmumps-seq-dev libopenblas-dev
-```
-Optionnal packages
-```bash
-sudo apt-get install python-matplotlib
-```
-Compilation
-```bash
-git clone [email protected]:ulgltas/waves.git
-cd waves
-mkdir build && cd build
-cmake -C disable-trilinos.cmake ..
-make -j4
-```
-Note:
-* `disable-trilinos.cmake` is not mandatory but it helps save much build time.
-
-### PFEM
-[Linux, Windows, macOS]
-```bash
-git clone [email protected]:ulgltas/waves.git 
-[build waves as above]
-[email protected]:am-dept/PFEM.git
-cd PFEM
-mkdir build && cd build
-cmake ..
-make -j4
-```
-
+  - PFEM --> Particle Finite Element Method fluid solver developed at the University of Liège (https://gitlab.uliege.be/am-dept/PFEM)
+  - SU2 --> Open-source CFD code developed at Stanford University (https://su2code.github.io/)
+  - Flow --> A Full Potential Finite Element fluid solver, part of the waves project, developed at the University of Liège (https://gitlab.uliege.be/am-dept/waves)
+  - VLM --> A Vortex Lattice Method, developed at the University of Liège (https://github.com/ulgltas/VLM)
+
+Furthermore, CUPyDO features two interpolation alogrithms:
+- Radial Basis Functions (RBF)
+- Thin Plate Spline (TPS)
+
+Finally, CUPyDO features two main couplers:
+- Block-Gauss-Seidel (BGS) with
+  - constant (static) relaxation
+  - Aitken relaxation
+- Interface Quasi-Newton with Inverse Least-Square (IQN_ILS)
+
+## Compilation
+Detailed build instructions can be found in the [wiki](https://github.com/ulgltas/CUPyDO/wiki/Installation).
 
 ## Examples
 Examples of simulations are available in [CUPyDO/tests](https://github.com/ulgltas/CUPyDO/tree/master/tests) and [CUPyDO/cases](https://github.com/ulgltas/CUPyDO/tree/master/cases).

cupydo/interfaces/Cupydo.py

@@ -109,6 +109,9 @@ def __initFluid(self, p, withMPI, comm):
         elif p['fluidSolver'] == 'Flow':
             import cupydo.interfaces.Flow as fItf
             fluidSolver = fItf.Flow(p['cfdFile'], args.n)
+        elif p['fluidSolver'] == 'VLM':
+            import cupydo.interfaces.VLM as fItf
+            fluidSolver = fItf.VLMSolver(p['cfdFile'])
         else:
             raise RuntimeError('Interface for', p['fluidSolver'], 'not found!\n')
         return fluidSolver
@@ -139,7 +142,7 @@ def __initSolid(self, p, myId):
 # Sample parameters list
 
 # Solvers
-# - p['fluidSolver'], fluid solvers available: SU2, Pfem, Flow
+# - p['fluidSolver'], fluid solvers available: SU2, Pfem, Flow, VLM
 # - p['solidSolver'], solid solvers available: Metafor, RBMI, Modal, GetDP
 # Configuration files
 # - p['cfdFile'], path to fluid cfg file 

cupydo/interfaces/Flow.py

@@ -77,35 +77,48 @@ def __initFlow(self, p, _nthreads):
 
         # mesh the geometry
         self.msh = gmsh.MeshLoader(p['File'],__file__).execute(**p['Pars'])
-        gmshWriter = tbox.GmshExport(self.msh)
         if p['Dim'] == 2:
             mshCrck = tbox.MshCrack(self.msh, p['Dim'])
-            mshCrck.addCrack(p['Wake'])
-            mshCrck.addBoundaries([p['Fluid'], p['Farfield'][-1], p['Body']])
-            mshCrck.run(gmshWriter)
+            mshCrck.setCrack(p['Wake'])
+            mshCrck.addBoundaries([p['Fluid'], p['Farfield'][-1], p['Wing']])
+            mshCrck.run()
         else:
-            mshCrck = tbox.MshCrack(self.msh, p['Dim'])
-            mshCrck.addCrack(p['Wake'])
-            mshCrck.addBoundaries([p['Fluid'], p['Symmetry'], p['Farfield'][-1]] + p['Body'])
-            mshCrck.addExcluded(p['WakeTip'])
-            mshCrck.run(gmshWriter)
-        del gmshWriter
+            for i in range(0, len(p['Wakes'])):
+                mshCrck = tbox.MshCrack(self.msh, p['Dim'])
+                mshCrck.setCrack(p['Wakes'][i])
+                if 'Fuselage' in p:
+                    mshCrck.addBoundaries([p['Fluid'], p['Symmetry'], p['Farfield'][-1], p['Fuselage'], p['Wings'][i]])
+                else:
+                    mshCrck.addBoundaries([p['Fluid'], p['Symmetry'], p['Farfield'][-1], p['Wings'][i]])
+                mshCrck.setExcluded(p['WakeTips'][i])
+                mshCrck.run()
+        tbox.GmshExport(self.msh).save(self.msh.name)
         del mshCrck
         self.mshWriter = Writer(self.msh)
 
         # initialize mesh deformation handler
         self.mshDef = tbox.MshDeform(self.msh, p['Dim'])
         self.mshDef.nthreads = _nthreads
         self.mshDef.setField(p['Fluid'])
-        self.mshDef.setFixed(p['Farfield'])
-        self.mshDef.setMoving([p['Fsi']])
-        if p['Dim'] == 3:
-            self.mshDef.setSymmetry([p['Symmetry']], 1)
-        self.mshDef.setInternal([p['Wake'], p['Wake']+'_'])
+        self.mshDef.addFixed(p['Farfield'])
+        if p['Dim'] == 2:
+            self.mshDef.addMoving([p['Wing']])
+            self.mshDef.addInternal([p['Wake'], p['Wake']+'_'])
+        else:
+            if 'Fuselage' in p:
+                self.mshDef.addFixed(p['Fuselage'])
+            self.mshDef.setSymmetry(p['Symmetry'], 1)
+            for i in range(0, len(p['Wings'])):
+                if p['Wings'][i] == p['Fsi']:
+                    self.mshDef.addMoving([p['Wings'][i]])
+                else:
+                    self.mshDef.addFixed([p['Wings'][i]])
+                self.mshDef.addInternal([p['Wakes'][i], p['Wakes'][i]+'_'])
+        self.mshDef.initialize()
 
         # initialize the problem
         p['AoA'] = p['AoA']*np.pi/180 # convert to radians
-        phiInfFun = flow.Fun0PosPhiInf(p['Dim'], p['AoA'])
+        phiInfFun = flow.F0PsPhiInf(p['Dim'], p['AoA'])
         if p['Dim'] == 2:
             velInfFun = tbox.Fct1C(-np.cos(p['AoA']), -np.sin(p['AoA']), 0.)
         else:
@@ -115,32 +128,34 @@ def __initFlow(self, p, _nthreads):
 
         # add medium
         if p['M_inf'] == 0:
-            self.fCp = flow.Fun0EleCpL()
-            pbl.set(flow.Medium(self.msh, p['Fluid'], flow.Fun0EleRhoL(), flow.Fun0EleMachL(), self.fCp, phiInfFun))
+            pbl.set(flow.Medium(self.msh, p['Fluid'], flow.F0ElRhoL(), flow.F0ElMachL(), flow.F0ElCpL(), phiInfFun))
         else:
-            self.fCp = flow.Fun0EleCp(p['M_inf'])
-            pbl.set(flow.Medium(self.msh, p['Fluid'], flow.Fun0EleRho(p['M_inf'], p['M_crit']), flow.Fun0EleMach(p['M_inf']), self.fCp, phiInfFun))
+            pbl.set(flow.Medium(self.msh, p['Fluid'], flow.F0ElRho(p['M_inf'], p['M_crit']), flow.F0ElMach(p['M_inf']), flow.F0ElCp(p['M_inf']), phiInfFun))
         # add initial condition
         pbl.add(flow.Initial(self.msh, p['Fluid'], phiInfFun))
-        # add farfield and symmetry boundary conditions
-        for bd in p['Farfield']:
-            pbl.add(flow.Freestream(self.msh, bd, velInfFun))
+        # add farfield boundary conditions
+        pbl.add(flow.Dirichlet(self.msh, p['Farfield'][0], phiInfFun))
+        for i in range (1, len(p['Farfield'])):
+            pbl.add(flow.Freestream(self.msh, p['Farfield'][i], velInfFun))
         # add solid boundaries and identify f/s boundary
         if p['Dim'] == 2:
-            self.boundary = flow.Boundary(self.msh, [p['Body'], p['Fluid']])
+            self.boundary = flow.Boundary(self.msh, [p['Wing'], p['Fluid']])
             pbl.add(self.boundary)
         else:
-            for bd in p['Body']:
+            for bd in p['Wings']:
                 bnd = flow.Boundary(self.msh, [bd, p['Fluid']])
                 pbl.add(bnd)
                 if bd == p['Fsi']:
                     self.boundary = bnd
+            if 'Fuselage' in p:
+                pbl.add(flow.Boundary(self.msh, [p['Fuselage'], p['Fluid']]))
         # add wake/kutta condition
         if p['Dim'] == 2:
             pbl.add(flow.Wake(self.msh, [p['Wake'], p['Wake']+'_', p['Fluid']]))
-            pbl.add(flow.Kutta(self.msh, [p['Te'], p['Wake']+'_', p['Body'], p['Fluid']]))
+            pbl.add(flow.Kutta(self.msh, [p['Te'], p['Wake']+'_', p['Wing'], p['Fluid']]))
         else:
-            pbl.add(flow.Wake(self.msh, [p['Wake'], p['Wake']+'_', p['Fluid'], p['TeTip']]))
+            for i in range(0, len(p['Wakes'])):
+                pbl.add(flow.Wake(self.msh, [p['Wakes'][i], p['Wakes'][i]+'_', p['Fluid'], p['TeTips'][i]]))
 
         # initialize the solver
         if p['NSolver'] == 'Picard':
@@ -173,18 +188,14 @@ def run(self, t1, t2):
         self.__setCurrentState()
 
     def __setCurrentState(self):
-        """Compute nodal forces from nodal Pressure coefficient
+        """Compute nodal forces from nodal normalized forces
         Adrien Crovato
         """
-        # integrate Cp at element
-        cpiE = self.boundary.integrate(self.solver.phi, self.fCp)
-        # transfer integrated Cp from elements to nodes
-        cfN = self.boundary.transfer(cpiE)
         i = 0
         for n in self.boundary.nodes:
-            self.nodalLoad_X[i] = -self.dynP * cfN[i][0]
-            self.nodalLoad_Y[i] = -self.dynP * cfN[i][1]
-            self.nodalLoad_Z[i] = -self.dynP * cfN[i][2]
+            self.nodalLoad_X[i] = -self.dynP * self.boundary.cLoadX[i]
+            self.nodalLoad_Y[i] = -self.dynP * self.boundary.cLoadY[i]
+            self.nodalLoad_Z[i] = -self.dynP * self.boundary.cLoadZ[i]
             i += 1
 
     def getNodalInitialPositions(self):
@@ -263,7 +274,6 @@ def exit(self):
         """
         Exit the Flow solver
         """
-        del self.fCp
         del self.solver
         del self.mshDef
         del self.msh