Commit 78c4305f authored by Paolo Tricerri's avatar Paolo Tricerri
Browse files

Merge branch 'TimeAdvanceFSI'

parents 23a0f806 49707e8a
......@@ -50,6 +50,9 @@ INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/cmake/tribits/package_arch/TribitsProject.cm
# CMake requires this be in the top file and not in an include file :-(
CMAKE_MINIMUM_REQUIRED(VERSION ${TRIBITS_CMAKE_MINIMUM_REQUIRED})
# Add documentation
ADD_SUBDIRECTORY(doc)
# Do all of the processing for this Tribits project
TRIBITS_PROJECT()
......@@ -76,9 +79,6 @@ if (HDF5_IS_IN_TRILINOS AND NOT EpetraExt_FOUND)
endif()
endif()
# Add documentation
ADD_SUBDIRECTORY(doc)
# Adding a new CMake variable for each of the enabled packages
STRING(REPLACE " " ";" PACKAGE_LIST ${LifeV_ENABLED_PACKAGES})
......
......@@ -95,6 +95,7 @@ $(top_srcdir)/acinclude.m4:
@echo 'm4_include([admin/lifev_default_paths.m4])'>>acinclude.m4
@echo 'm4_include([admin/ax_create_pkgconfig_info.m4])'>>acinclude.m4
@echo 'm4_include([admin/lifev_create_subdirlist.m4])'>>acinclude.m4
@echo 'm4_include([admin/ac_check_hypre.m4])'>>acinclude.m4
$(top_srcdir)/Makefile.headers:
......
#
# DO NOT EDIT : generated automatically by update-headers
#
LIFECORE_HDRS=life/lifecore/StringData.hpp life/lifecore/Parser.hpp life/lifecore/CBlas.hpp life/lifecore/EncoderBase64.hpp life/lifecore/LifeV.hpp life/lifecore/FortranWrapper.hpp life/lifecore/FactoryTypeInfo.hpp life/lifecore/LifeAssert.hpp life/lifecore/StringUtility.hpp life/lifecore/LifeVersion.hpp life/lifecore/ParserDefinitions.hpp life/lifecore/FactorySingleton.hpp life/lifecore/Switch.hpp life/lifecore/Factory.hpp life/lifecore/CLapack.hpp life/lifecore/ParserSpiritGrammar.hpp life/lifecore/LifeChrono.hpp life/lifecore/LifeAssertSmart.hpp life/lifecore/LifeDebug.hpp life/lifecore/FactoryPolicy.hpp life/lifecore/Displayer.hpp
LIFEARRAY_HDRS=life/lifearray/MatrixEpetraStructured.hpp life/lifearray/MatrixContainer.hpp life/lifearray/MapEpetra.hpp life/lifearray/MatrixEpetraStructuredView.hpp life/lifearray/VectorContainer.hpp life/lifearray/MeshEntityContainer.hpp life/lifearray/MatrixElemental.hpp life/lifearray/RNMOperatorConstant.hpp life/lifearray/VectorEpetra.hpp life/lifearray/RNMTemplate.hpp life/lifearray/VectorEpetraStructuredView.hpp life/lifearray/VectorSmall.hpp life/lifearray/VectorEpetraStructured.hpp life/lifearray/VectorElemental.hpp life/lifearray/MatrixEpetra.hpp life/lifearray/ArraySimple.hpp life/lifearray/RNM.hpp life/lifearray/MatrixEpetraStructuredUtility.hpp life/lifearray/RNMOperator.hpp life/lifearray/MapVector.hpp
LIFEALG_HDRS=life/lifealg/LinearEpetraOperator.hpp life/lifealg/NonLinearLineSearch.hpp life/lifealg/EigenSolver.hpp life/lifealg/NonLinearAitken.hpp life/lifealg/PreconditionerIfpack.hpp life/lifealg/PreconditionerComposed.hpp life/lifealg/PreconditionerML.hpp life/lifealg/SolverAmesos.hpp life/lifealg/NonLinearBrent.hpp life/lifealg/LinearEpetraOperatorBlock.hpp life/lifealg/SolverAztecOO.hpp life/lifealg/NonLinearRichardson.hpp life/lifealg/Preconditioner.hpp life/lifealg/ComposedOperator.hpp life/lifealg/PreconditionerAztecOO.hpp
LIFEMESH_HDRS=life/lifemesh/Marker.hpp life/lifemesh/MarkerDefinitions.hpp life/lifemesh/MeshVertex.hpp life/lifemesh/MeshChecks.hpp life/lifemesh/InternalEntitySelector.hpp life/lifemesh/MeshEntity.hpp life/lifemesh/MeshData.hpp life/lifemesh/MeshElementBare.hpp life/lifemesh/MeshUtility.hpp life/lifemesh/RegionMesh3DStructured.hpp life/lifemesh/BareMesh.hpp life/lifemesh/MeshPartitionerOfflineFSI.hpp life/lifemesh/MeshElementMarked.hpp life/lifemesh/RegionMesh1DBuilders.hpp life/lifemesh/MeshElement.hpp life/lifemesh/MeshPartitioner.hpp life/lifemesh/RegionMesh.hpp life/lifemesh/ElementShapes.hpp
LIFEFEM_HDRS=life/lifefem/TimeAdvanceBDF.hpp life/lifefem/BCInterface.hpp life/lifefem/HyperbolicFluxNumerical.hpp life/lifefem/Assembly.hpp life/lifefem/BCManageNormal.hpp life/lifefem/BCInterfaceDefinitions.hpp life/lifefem/DOFInterface3Dto2D.hpp life/lifefem/AssemblyElementalStructure.hpp life/lifefem/OneDFSIBCHandler.hpp life/lifefem/ReferenceFEScalar.hpp life/lifefem/DOFInterface3Dto3D.hpp life/lifefem/QuadraturePoint.hpp life/lifefem/TimeData.hpp life/lifefem/GeometricMap.hpp life/lifefem/BCVector.hpp life/lifefem/QuadratureRule.hpp life/lifefem/AssemblyElemental.hpp life/lifefem/DOFLocalPattern.hpp life/lifefem/TimeAdvanceNewmark.hpp life/lifefem/FEFunction.hpp life/lifefem/TimeAdvanceRythmos.hpp life/lifefem/CurrentFE.hpp life/lifefem/ReferenceElement.hpp life/lifefem/SobolevNorms.hpp life/lifefem/PostProcessingBoundary.hpp life/lifefem/FEField.hpp life/lifefem/ReferenceFEHdiv.hpp life/lifefem/CurrentBoundaryFEBase.hpp life/lifefem/BCInterface1D.hpp life/lifefem/BCInterface3D.hpp life/lifefem/QuadratureRuleProvider.hpp life/lifefem/ReferenceFEHybrid.hpp life/lifefem/CurrentBoundaryFE.hpp life/lifefem/BCInterfaceData3D.hpp life/lifefem/TimeAdvanceBDFVariableStep.hpp life/lifefem/BCInterfaceData.hpp life/lifefem/FESpace.hpp life/lifefem/DOFInterface.hpp life/lifefem/ReferenceFE.hpp life/lifefem/BCManage.hpp life/lifefem/BCFunction.hpp life/lifefem/BCBase.hpp life/lifefem/BCDataInterpolator.hpp life/lifefem/TimeAdvanceBDFNavierStokes.hpp life/lifefem/BCInterfaceData1D.hpp life/lifefem/BCHandler.hpp life/lifefem/DOF.hpp life/lifefem/OneDFSIBC.hpp life/lifefem/TimeAdvance.hpp life/lifefem/BCIdentifier.hpp
LIFESOLVER_HDRS=life/lifesolver/FSISolver.hpp life/lifesolver/VenantKirchhoffMaterialNonLinear.hpp life/lifesolver/OneDFSISourceLinear.hpp life/lifesolver/DarcySolverTransient.hpp life/lifesolver/FSIMonolithicGE.hpp life/lifesolver/OneDFSIFluxNonLinear.hpp life/lifesolver/StabilizationIP.hpp life/lifesolver/StabilizationSD.hpp life/lifesolver/StructuralMaterial.hpp life/lifesolver/OneDFSIData.hpp life/lifesolver/MonolithicBlockComposedDNND.hpp life/lifesolver/StructuralSolver.hpp life/lifesolver/OneDFSISolver.hpp life/lifesolver/FSIFixedPoint.hpp life/lifesolver/MonolithicBlockComposedNN.hpp life/lifesolver/HyperbolicSolver.hpp life/lifesolver/HeartMonodomainSolver.hpp life/lifesolver/VenantKirchhoffViscoelasticSolver.hpp life/lifesolver/OneDFSIPhysics.hpp life/lifesolver/OneDFSIPhysicsNonLinear.hpp life/lifesolver/MonolithicBlockComposedDN.hpp life/lifesolver/HeartIonicSolver.hpp life/lifesolver/FSIData.hpp life/lifesolver/MonolithicBlockMatrix.hpp life/lifesolver/ADRData.hpp life/lifesolver/HeartIonicData.hpp life/lifesolver/ADRAssembler.hpp life/lifesolver/HeartBidomainData.hpp life/lifesolver/OseenSolverShapeDerivative.hpp life/lifesolver/OneDFSIFlux.hpp life/lifesolver/VenantKirchhoffSolverLinear.hpp life/lifesolver/FSIMonolithic.hpp life/lifesolver/OneDFSISourceNonLinear.hpp life/lifesolver/MonolithicBlockComposedDND.hpp life/lifesolver/DarcyData.hpp life/lifesolver/OseenAssembler.hpp life/lifesolver/DarcySolverTransientNonLinear.hpp life/lifesolver/HeartBidomainSolver.hpp life/lifesolver/VenantKirchhoffMaterialLinear.hpp life/lifesolver/FSIMonolithicGI.hpp life/lifesolver/MonolithicBlockMatrixRN.hpp life/lifesolver/VenantKirchhoffElasticData.hpp life/lifesolver/HarmonicExtensionSolver.hpp life/lifesolver/DarcySolver.hpp life/lifesolver/DarcySolverNonLinear.hpp life/lifesolver/OneDFSISource.hpp life/lifesolver/FSIExactJacobian.hpp life/lifesolver/LevelSetSolver.hpp life/lifesolver/ExponentialMaterialNonLinear.hpp life/lifesolver/MonolithicRobinInterface.hpp life/lifesolver/VenantKirchhoffElasticHandler.hpp life/lifesolver/HeartStiffnessFibers.hpp life/lifesolver/FSIOperator.hpp life/lifesolver/VenantKirchhoffSolver.hpp life/lifesolver/MonolithicBlockComposed.hpp life/lifesolver/VenantKirchhoffViscoelasticData.hpp life/lifesolver/OneDFSIDefinitions.hpp life/lifesolver/NeoHookeanMaterialNonLinear.hpp life/lifesolver/HeartFunctors.hpp life/lifesolver/OneDFSIFluxLinear.hpp life/lifesolver/LevelSetData.hpp life/lifesolver/OseenSolver.hpp life/lifesolver/OseenData.hpp life/lifesolver/ADRAssemblerIP.hpp life/lifesolver/MonolithicBlock.hpp life/lifesolver/HeartMonodomainData.hpp life/lifesolver/HyperbolicData.hpp life/lifesolver/OneDFSIPhysicsLinear.hpp
LIFEFILTERS_HDRS=life/lifefilters/ExporterVTK.hpp life/lifefilters/ImporterMesh3D.hpp life/lifefilters/ExporterHDF5Mesh3D.hpp life/lifefilters/ExporterEnsight.hpp life/lifefilters/Exporter.hpp life/lifefilters/ExporterHDF5.hpp life/lifefilters/Importer.hpp life/lifefilters/MeshWriter.hpp life/lifefilters/GetPot.hpp life/lifefilters/ExporterEmpty.hpp life/lifefilters/ImporterMesh2D.hpp
LIFEFUNCTIONS_HDRS=life/lifefunctions/BCInterfaceFunctionUserDefined.hpp life/lifefunctions/BCInterfaceFunctionParserFile.hpp life/lifefunctions/BCInterfaceFunctionParserSolver.hpp life/lifefunctions/bessel/bessel.hpp life/lifefunctions/BCInterfaceFunctionParserFileSolver.hpp life/lifefunctions/KimMoin.hpp life/lifefunctions/Womersley.hpp life/lifefunctions/OneDFSIFunctionSolverDefined.hpp life/lifefunctions/OneDFSIFunction.hpp life/lifefunctions/BCInterfaceFactory.hpp life/lifefunctions/RossEthierSteinmanDec.hpp life/lifefunctions/RossEthierSteinmanInc.hpp life/lifefunctions/BCInterfaceFunction.hpp life/lifefunctions/BCInterfaceFunctionParser.hpp life/lifefunctions/BCInterfaceFunctionSolverDefined.hpp
nobase_include_HEADERS=lifeconfig.h\
$(LIFECORE_HDRS)\
$(LIFEARRAY_HDRS)\
$(LIFEALG_HDRS)\
$(LIFEMESH_HDRS)\
$(LIFEFEM_HDRS)\
$(LIFESOLVER_HDRS)\
$(LIFEFILTERS_HDRS)\
$(LIFEFUNCTIONS_HDRS)
/*!
\page BlockAlgebraPage Block algebra structures
Having block structures can be very useful in many situations, for example when assembling a system or devising a preconditionner.
Blocks are very intuitive structures that help the code the match closer numerical analysis concepts.
There are two ways of implementing block structures
<ol>
<li> The <b> monolithic </b> approach, which consists in building structures that are aware of the blocks but stores
a monolithic structure. For example, with such an approach, a block matrix is a structure storing the positions of the
blocks while keeping a unique matrix to represent the global matrix (all the blocks together).
<li> The <b> composite </b> approach, which consists in effectively storing the blocks as different structures. For example, with
this approach, a block matrix is a structure storing many matrices, each of them representing one of the blocks.
</ol>
As the choice for the most suitable approach depends strongly on the problem at hand, the user is responsible for it.
\image html linear_algebra_monolithic_vs_split.png "The two possible approaches"
\section BlockAlgebraPage_blockMonolithicStructures Monolithic approach
Structures following this approach are:
<ul>
<li> LifeV::MatrixBlockMonolithicEpetra for the matrices
<li> LifeV::VectorBlockMonolithicEpetra for the vectors
</ul>
As these structures derive from their basic counterparts (LifeV::MatrixEpetra and LifeV::VectorEpetra), any functionality working
for the basic structures will work with these block structures (solvers, preconditionners,...).
Moreover, the block structures can be changed at any time without large computation.
<b> First Example </b>
The following example shows the preferred syntax for defining these structures. We will use a Stokes problem to illustrate the use
of these structures. We suppose that the LifeV::FESpace structures have already been defined. We will define a matrix and a vector,
so the corresponding declaration files have to be included:
\code
#include <life/lifearray/MatrixBlockMonolithicEpetra.hpp>
#include <life/lifearray/VectorBlockMonolithicEpetra.hpp>
\endcode
We define then the types that we will use (this is a good practice as it allows to change quickly the approach used):
\code
typedef MatrixBlockMonolithicEpetra<Real> matrix_type;
typedef VectorBlockMonolithicEpetra vector_type;
\endcode
We suppose now that the maps (LifeV::MapEpetra) for the velocity and the pressure space are defined, using e.g. the map
of the corresponding LifeV::FESpace:
\code
MapEpetra uMap(...);
MapEpetra pMap(...);
\endcode
To define the matrix and the vector, the syntax is very simple:
\code
matrix_type systemMatrix( uMap | pMap );
vector_type rightHandSide( uMap | pMap );
\endcode
Note here the usage of <b> the "|" operator that separates the blocks</b> (the number of blocks that can be used is unlimited).
Now, we can access the blocks:
\code
systemMatrix.block(0,0) ...
systemMatrix.block(1,0) ...
rightHandSide.block(1) ...
\endcode
<b> Second Example </b>
For this second example, we suppose that instead of the map (LifeV::MapEpetra) that contained
all the components of the velocity, we have three different maps, one for each component (the velocity is supposed to be 3D):
\code
MapEpetra uxMap(...);
MapEpetra uyMap(...);
MapEpetra uzMap(...);
MapEpetra pMap(...);
\endcode
We can then define the system using the same syntax as before:
\code
matrix_type componentMatrix( uxMap | uyMap | uzMap | pMap );
vector_type componentRHS( uxMap | uyMap | uzMap | pMap );
\endcode
The matrix will now contain 4x4 blocks and the vector 4 blocks. This might be useful if some blocks
are exactly the same (e.g. the ux-ux, uy-uy and uz-uz blocks). One can then compute one of the blocks and copy it into the other blocks (using utilities defined in LifeV::MatrixBlockUtils).
However, if for some reason, one wants to define the system as in the first example, one can use the "+" operator, that has the effect of fusioning the blocks
(actually, it concatenates the maps):
\code
matrix_type fusionMatrix( (uxMap + uyMap + uzMap) | pMap );
vector_type fusionRHS( (uxMap + uyMap + uzMap) | pMap );
\endcode
Now, the matrix has again a 2x2 block structure while the vector has 2 blocks. The usage of parentheses around the blocks to be fusioned is warmly recommended in order not to have to deal with operator priorities. Some compilers might even rise a warning if parentheses are not used.
Remark that it is possible to change the block structure for a low computational cost at any time using the setBlockStructure methods:
\code
componentMatrix.setBlockStructure( (uxMap + uyMap + uzMap) | pMap );
componentRHS.setBlockStructure( (uxMap + uyMap + uzMap) | pMap );
\endcode
\section BlockAlgebraPage_blockCompositeStructures Composite approach
These structures have not been implemented yet in LifeV.
*/
This diff is collapsed.
......@@ -319,8 +319,9 @@ int main(int argc, char** argv)
iterChrono.start();
double alpha = bdf.bdfVelocity().coefficientFirstDerivative( 0 ) / oseenData->dataTime()->timeStep();
beta = bdf.bdfVelocity().extrapolation(); // Extrapolation for the convective term
//Matteo
// beta =bdf.bdfVelocity().extrapolation();
bdf.bdfVelocity().extrapolation( beta ); // Extrapolation for the convective term
bdf.bdfVelocity().updateRHSContribution(oseenData->dataTime()->timeStep() );
rhs = fluid.matrixMass()*bdf.bdfVelocity().rhsContributionFirstDerivative();
......
# -*- makefile -*-
###################################################################################################
#
# This file is part of the LifeV Applications
# Copyright (C) 2001-2011 EPFL, Politecnico di Milano, INRIA
#
# Author(s): Gwenol Grandperrin <gwenol.grandperrin@epfl.ch>
# Date: 28-10-2010
# License Terms: GNU GPL
#
###################################################################################################
include $(top_srcdir)/testsuite/Makefile.testsuite
SUFFIXES = .cpp .hpp .idl .c .h .f .F .o .moc
check_HEADERS = # List of all the hpp files
check_PROGRAMS = benchmark_GreenshieldsWeller
benchmark_GreenshieldsWeller_SOURCES = main.cpp
link:
test -a data || ln -s $(top_srcdir)/examples/benchmark_GreenshieldsWeller/data data
test -a fluid_GreenshieldsWeller_20-10-2.mesh || ln -s $(top_srcdir)/examples/benchmark_GreenshieldsWeller/fluid_GreenshieldWeller_20-10-2.mesh; ln -s $(top_srcdir)/examples/benchmark_GreenshieldsWeller/solid_GreenshieldWeller_20-10-2.mesh
recheck: clean_PROGRAMS check
clean_PROGRAMS:
-rm $(check_PROGRAMS)
clean-results:
-rm *.vct *.scl *.case *.geo *.xmf *.h5
//@HEADER
/*
*******************************************************************************
Copyright (C) 2004, 2005, 2007 EPFL, Politecnico di Milano, INRIA
Copyright (C) 2010 EPFL, Politecnico di Milano, Emory University
This file is part of LifeV.
LifeV is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
LifeV is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with LifeV. If not, see <http://www.gnu.org/licenses/>.
*******************************************************************************
*/
//@HEADER
/*!
* @file
* @brief File containing the boundary conditions for the Monolithic Test
*
* @date 2009-04-09
* @author Paolo Crosetto <crosetto@iacspc70.epfl.ch>
*
* @contributor Cristiano Malossi <cristiano.malossi@epfl.ch>
* @maintainer Paolo Crosetto <crosetto@iacspc70.epfl.ch>
*
* Contains the functions to be assigned as boundary conditions, in the file boundaryConditions.hpp . The functions
* can depend on time and space, while they can take in input an ID specifying one of the three principal axis
* if the functions to assign is vectorial and the boundary condition is of type \c Full \c.
*/
#ifndef BC_HPP
#define BC_HPP
// LifeV includes
#include "life/lifecore/LifeV.hpp"
#include "life/lifefem/BCHandler.hpp"
// Mathcard includes
#include "life/lifesolver/FSIMonolithicGE.hpp"
#include "life/lifesolver/FSIMonolithicGI.hpp"
#define OUTLET 3
#define INLET 2
#define FLUIDINTERFACE 1
#define SOLIDINTERFACE 1
#define OUTERWALL 10
#define RING 2
#define RING2 3
#define INOUTEDGE 20
#define INEDGE 30
namespace LifeV
{
Real fZero(const Real& /*t*/, const Real& /*x*/, const Real& /*y*/, const Real& /*z*/, const ID& /*i*/)
{
return 0.0;
}
Real u2normal(const Real& /*t*/, const Real& /*x*/, const Real& /*y*/, const Real& /*z*/, const ID& /*i*/)
{
return -5.e4;
}
typedef FSIOperator::fluid_Type fluid;
typedef FSIOperator::solid_Type solid;
FSIOperator::fluidBchandlerPtr_Type BCh_harmonicExtension(FSIOperator &_oper)
{
// Boundary condition for the mesh
debugStream( 10000 ) << "Boundary condition for the harmonic extension\n";
BCFunctionBase bcf(fZero);
FSISolver::fluidBchandlerPtr_Type BCh_he(new FSIOperator::fluidBchandler_Type );
std::vector<ID> componentsVector(0);
componentsVector.push_back(2);
BCh_he->addBC("Base", INLET, Essential, Component, bcf, componentsVector);
BCh_he->addBC("Top", OUTLET, Essential, Component, bcf, componentsVector);
if (_oper.data().method() == "monolithicGE")
{
debugStream(10000) << "FSIMonolithic GCE harmonic extension\n";
FSIMonolithicGE *MOper = dynamic_cast<FSIMonolithicGE *>(&_oper);
MOper->setStructureDispToHarmonicExtension(_oper.lambdaFluidRepeated());
BCh_he->addBC("Interface", SOLIDINTERFACE, Essential, Full,
*MOper->bcvStructureDispToHarmonicExtension(), 3);
}
return BCh_he;
}
FSIOperator::fluidBchandlerPtr_Type BCh_monolithicFluid(FSIOperator &_oper)
{
// Boundary conditions for the fluid velocity
if (! _oper.isFluid() )
return FSIOperator::fluidBchandlerPtr_Type();
FSIOperator::fluidBchandlerPtr_Type BCh_fluid( new FSIOperator::fluidBchandler_Type );
BCFunctionBase bcf (fZero);
BCFunctionBase in_flow (u2normal);
BCh_fluid->addBC("InFlow" , INLET, Natural, Normal, in_flow);
return BCh_fluid;
}
FSIOperator::solidBchandlerPtr_Type BCh_monolithicSolid(FSIOperator &_oper)
{
// Boundary conditions for the solid displacement
if (! _oper.isSolid() )
return FSIOperator::solidBchandlerPtr_Type();
FSIOperator::solidBchandlerPtr_Type BCh_solid( new FSIOperator::solidBchandler_Type );
BCFunctionBase bcf(fZero);
std::vector<ID> componentsVector(0);
componentsVector.push_back(2);
BCh_solid->addBC("Base", INLET, Essential, Component, bcf, componentsVector);
BCh_solid->addBC("Top", OUTLET, Essential, Component, bcf, componentsVector);
return BCh_solid;
}
FSIOperator::fluidBchandlerPtr_Type BCh_monolithicFlux(bool /*isOpen=true*/)
{
FSIOperator::fluidBchandlerPtr_Type BCh_fluid( new FSIOperator::fluidBchandler_Type );
return BCh_fluid;
}
}
#endif
# -*- getpot -*- (GetPot mode activation for emacs)
#-------------------------------------------------
# Data file for CE FSI Solver
#-------------------------------------------------
[problem]
method = monolithicGI # monolithicGE, monolithicGI
blockOper = AdditiveSchwarzGI
# OPTIONS:
#AdditiveSchwarz
#AdditiveSchwarzRN
#AdditiveSchwarzGI
#AdditiveSchwarzRNGI
DDBlockPrec = ComposedDN2GI
# OPTIONS:
#AdditiveSchwarz: monolithic A-S preconditioner,
#AdditiveSchwarzGI: monolithic A-S preconditioner,
#ComposedDN: modular Dirichlet-Neumann preconditioner
#ComposedDN2: modular Dirichlet-Neumann preconditioner
#ComposedNN: modular Neumann-Neumann + Dirichlet-Dirichlet preconditioner
#ComposedDNND: modular Dirichlet-Neumann + Neumann-Dirichlet preconditioner
#ComposedDNGI: modular preconditioner for the geometric implicit, split in 3 factors
#ComposedDN2GI: modular preconditioner for the geometric implicit, split in 3 factors
#ComposedDNDGI: under testing, do not use
#ComposedDND2GI: under testing, do not use
reducedFluid = 0 # 0 = exact, 1 = inexact
defOmega = 0.01 # usually 0.01 for precond = 0 or 1; -1 for precond = 2
defOmegaS = 0.01 # matters only with precond = 2
defOmegaF = 0.01 # matters only with precond = 2
# only for fixed point and exactJacobian:
# if updateEvery == 1, normal fixedPoint algorithm
# if updateEvery > 1, recompute computational domain every M_updateEvery iterations (transpiration)
# if updateEvery <= 0, recompute computational domain and matrices only at first subiteration (semi-implicit).
# Deprecated when using exactJacobian (better to set ifSemiImplicit=1)
updateEvery = 1
linesearch = 0
# NonLinearRichardson: stop_tol = abstol + reltol*normRes;
abstol = 0. # tolerance in nonLinearRichardson
reltol = 1.e-5 # tolerance in nonLinearRichardson
restart = 0
maxSubIter = 20
fluidMeshPartitioned = none
solidMeshPartitioned = none
[exporter]
multimesh = false # actually we export also the displacement
start = 0
save = 1
saveEvery = 1
type = hdf5
nRestart = 0
[./fluid]
filename = fluid
[../solid]
filename = solid
[../] # solid
[../] # exporter
[importer]
##restartType=restartFSI
initSol=00005
initSolFD=00006
##restart_timestep=0.005
type = hdf5
##restart_timestep = 0.0001
[./fluid]
filename = fluid
[../solid]
filename = solid
[../] # solid
# [../] # importer
[fluid]
useShapeDerivatives = false
semiImplicit = false # tells if we advance in time after the first nonlinear iteration or not
domainVelImplicit = true # tells if the domain vel is to be considered implicitly in the convective term
convectiveImplicit = false # tells if the velocity is to be considered implicitly in the convective term
[./physics]
density = 1.0 # density
viscosity = 0.04 # viscosity
[../time_discretization]
method = BDF
initialtime = 0.
endtime = 0.01
timestep = 0.0001
BDF_order = 1
theta = 0.5
gamma = 0.5
rhoInf = 1
typeOfGeneralizedAlpha = HHT
[../space_discretization]
mesh_dir = ./
mesh_file = fluid_GreenshieldWeller_20-10-2.mesh # bypass_fluid_coarse_BL_2vols.mesh
vel_order = P1 # P1, P1Bubble, P2
mesh_order = P1
press_order = P1 # P1, P2
stiff_strain = true
[../miscellaneous]
verbose = 1
velname = vel
pressname = press
steady = 0
factor = 1
[../ipstab]
use = 1
gammaBeta = 0.1
gammaDiv = 0.
gammaPress = 0.0005
reuse = true
[../] # physics
[../] # fluid
[interface]
fluid_flag = 1 # default: 1
tolerance = 0 # how far points are to be considered the same on the interface
[../] # interface
[solid]
useExactJacobian = true # always false for linear structure model. Otherwise it allows to chose beween an exact-inexact
# Newton scheme
rescaleFactor = 1.
[./physics]
solidType = exponential
# either linearVenantKirchhoff, nonLinearVenantKirchhoff, exponential...
material_flag = 1
density = 1. # density
young = 1.e7
poisson = 0.3
bulk = 1e7
alpha = 2.5e6
gamma = 1
[../time_discretization]
method = BDF # Newmark or BDF
initialtime = 0.
endtime = 0.01
timestep = 0.001
BDF_order = 1
theta = 0.25
gamma = 0.5
rhoInf = 1
typeOfGeneralizedAlpha = HHT
[../space_discretization]
mesh_dir = ./ #test_tubes/ # the directory where the mesh file is
mesh_file = solid_GreenshieldWeller_20-10-2.mesh #bypass_solid_coarse_BL_2vols.mesh # mesh file
order = P1
mesh_faces = all # update all faces elements
mesh_edges = all # update all faces elements
[../miscellaneous]
verbose = 1
depname = dep
[../newton]
maxiter = 1
abstol = 1.e-8
linesearch = 0
[linear_system]
[./solver]
output = all # none
max_iter = 200
poly_ord = 5
kspace = 200
precond = dom_decomp
drop = 1.00e-4
ilut_fill = 2
tol = 1.e-6
[./aztecoo]
reordering = 1 # rcm
precond = dom_decomp
subdomain_solve = ilut
ilut_fill = 4.e+0
drop = 1.e-5
athresh = 1.e-3
rthresh = 1.e-3
reuse = 1
displayList = false
[../] # aztecoo
[../prec]
reuse = false
prectype = Composed
displayList = false
entry = 0.
[./robin]
alphaf = 0.
alphas = 0.5 # parameters for Robin-Robin DDBlock preconditioner
[../Composed] #structure, fluid, mesh
list = 'Ifpack Ifpack Ifpack'
sections = 'Ifpack1 Ifpack1 Ifpack2'
[../PCD1]
pressure_boundary_conditions = neumann_to_dirichlet
set_Ap_boundary_conditions = true
set_Fp_boundary_conditions = true
pressure_laplacian_operator = standard
use_lumped_pressure_mass = true
[./subprecs]
pressure_laplacian_prec = Ifpack
pressure_laplacian_prec_data_section = Ifpack
fluid_prec = Ifpack
fluid_prec_data_section = Ifpack
pressure_mass_prec = Ifpack
pressure_mass_prec_data_section = Ifpack