FSIOperator::solidBchandlerPtr_Type BCh_monolithicSolid (FSIOperator& _oper)
{
if (! _oper.isSolid() )
{
return FSIOperator::solidBchandlerPtr_Type();
}
// Boundary conditions for the solid displacement
debugStream ( 10000 ) << "Boundary condition for the solid\n";
FSIOperator::solidBchandlerPtr_Type BCh_solid ( new FSIOperator::solidBchandler_Type );
BCFunctionBase bcf (fZero);
BCh_solid->addBC ("Top", RING, Essential, Full, bcf, 3);
BCh_solid->addBC ("Base", RING2, Essential, Full, bcf, 3);
aortaVelIn::S_timestep = _oper.dataFluid()->dataTime()->timeStep();
BCFunctionBase hyd (fZero);
BCFunctionBase young (E);
//robin condition on the outer wall
_oper.setRobinOuterWall (hyd, young);
BCh_solid->addBC ("OuterWall", OUTERWALL, Robin, Normal, _oper.bcfRobinOuterWall() );
return BCh_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 );
BCh_he->addBC ("Edges", INOUTEDGE, Essential, Full, bcf, 3);
BCh_he->addBC ("Edges", INEDGE, Essential, Full, bcf, 3);
BCh_he->addBC ("Base", INLET, Essential, Full, bcf, 3);
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);
}
else if (_oper.data().method() == "monolithicGI")
{
}
return BCh_he;
}
FSIOperator::fluidBchandlerPtr_Type BCh_fluid (FSIOperator& _oper)
{
// Boundary conditions for the fluid velocity
debugStream ( 10000 ) << "Boundary condition for the fluid\n";
if (! _oper.isFluid() )
{
return FSIOperator::fluidBchandlerPtr_Type();
}
FSIOperator::fluidBchandlerPtr_Type BCh_fluid ( new FSIOperator::fluidBchandler_Type );
BCFunctionBase bcf (fZero);
BCFunctionBase in_flow (u2);
// BCFunctionBase in_flow_flux (PhysFlux);
BCFunctionBase out_flow (fZero);
#ifdef FLUX
BCh_fluid->addBC ("InFlow" , 2, Flux, Normal, in_flow, 3);
#else
BCh_fluid->addBC ("InFlow" , 2, Natural, Full, in_flow, 3);
#endif
BCh_fluid->addBC ("OutFlow", 3, Natural, Full, out_flow, 3);
//BCh_fluid->addBC("EdgesIn", 20, EssentialVertices, Full, bcf, 3);
// BCh_fluid->showMe();
_oper.setStructureToFluid (_oper.veloFluidMesh() );
// _oper.setHarmonicExtensionVelToFluid(_oper.veloFluidMesh());
if (_oper.data().algorithm() == "RobinNeumann")
{
// _oper.setAlphafbcf(alpha); // if alpha is bcFunction define in ud_function.cpp
// assert(false);
_oper.setSolidLoadToStructure ( _oper.minusSigmaFluidRepeated() );
_oper.setStructureToFluidParameters();
BCh_fluid->addBC ("Interface", FLUIDINTERFACE, Robin, Full,
*_oper.bcvStructureToFluid(), 3);
BCh_fluid->addBC ("Interface", FLUIDINTERFACE, Natural, Full,
*_oper.bcvSolidLoadToStructure(), 3);
}
else
{
BCh_fluid->addBC ("Interface", FLUIDINTERFACE, Essential, Full,
*_oper.bcvStructureToFluid(), 3);
}
return BCh_fluid;
}
FSIOperator::fluidBchandlerPtr_Type BCh_monolithicFluid (FSIOperator& _oper, bool const& isOpen = true)
{
// Boundary conditions for the fluid velocity
debugStream ( 10000 ) << "Boundary condition for the fluid\n";
if (! _oper.isFluid() )
{
return FSIOperator::fluidBchandlerPtr_Type();
}
FSIOperator::fluidBchandlerPtr_Type BCh_fluid ( new FSIOperator::fluidBchandler_Type );
BCFunctionBase bcf (fZero);
BCFunctionBase in_flow (/*uInterpolated*/u2normal/*aortaPhisPress*/);
// BCFunctionBase out_flow (fZero);
//BCFunctionBase in_flow (LumpedHeart::outPressure);
BCFunctionBase out_press (FlowConditions::outPressure0);
BCFunctionBase bcfw0 (w0);
// if(!isOpen)
// BCh_fluid->addBC("InFlow" , INLET, Natural, Full, bcf,3);
BCh_fluid->addBC ("OutFlow", OUTLET, Natural, Normal, out_press);
//BCh_fluid->addBC("OutFlow", INOUTEDGE, EssentialEdges, Full, bcf,3);
return BCh_fluid;
}
FSIOperator::solidBchandlerPtr_Type BCh_solidInvLin (FSIOperator& _oper)
{
if (! _oper.isSolid() )
{
return FSIOperator::solidBchandlerPtr_Type();
}
// Boundary conditions for the solid displacement
debugStream ( 10000 ) << "Boundary condition for the inverse linear solid\n";
FSIOperator::solidBchandlerPtr_Type BCh_solidLinInv ( new FSIOperator::solidBchandler_Type );
BCFunctionBase bcf (fZero);
BCh_solidLinInv->addBC ("Base", 2, Essential, Full, bcf, 3);
BCh_solidLinInv->addBC ("EdgesIn", 20, EssentialVertices, Full, bcf, 3);
// if (_oper.method() == "steklovPoincare")
// {
// steklovPoincare *SPOper = dynamic_cast<steklovPoincare *>(&_oper);
// SPOper->setSolidInvLinInterfaceStress((LifeV::Vector&) _oper.residual());
// BCh_solidLinInv->addBC("Interface", 100, Natural, Full,
// *SPOper->bcvSolidInvLinInterfaceStress(), 3);
// }
// else
// {
// exactJacobian *EJOper = dynamic_cast<exactJacobian *>(&_oper);
// EJOper->setDerFluidLoadToStructure(_oper.fluid().residual());
// BCh_solidLinInv->addBC("Interface", 1, Natural, Full,
// *EJOper->bcvDerFluidLoadToStructure(), 3);
// }
return BCh_solidLinInv;
}
FSIOperator::fluidBchandlerPtr_Type BCh_monolithicFluid (FSIOperator& _oper, bool const& /*isOpen=true*/)
{
// Boundary conditions for the fluid velocity
debugStream ( 10000 ) << "Boundary condition for the fluid\n";
if (! _oper.isFluid() )
{
return FSIOperator::fluidBchandlerPtr_Type();
}
FSIOperator::fluidBchandlerPtr_Type BCh_fluid ( new FSIOperator::fluidBchandler_Type );
BCFunctionBase bcf (fZero);
BCFunctionBase in_flow (uInterpolated);
// BCFunctionBase out_flow (fZero);
BCFunctionBase out_press3 (FlowConditions::outPressure0);
BCFunctionBase InletVect (aneurismFluxInVectorial);
//BCFunctionBase bcfw0 (w0);
//Inlets
BCh_fluid->addBC ("InFlow" , INLET, EssentialVertices, Full, InletVect, 3);
//Outlets
//Absorbing BC seemed not to work
//Absorbing BC on outlet 2and3 caused instabilities
BCh_fluid->addBC ("out3", OUTLET, Natural, Normal, out_press3);
//BCh_fluid->addBC("out3", OUTLET, Natural, Normal, bcf);
return BCh_fluid;
}
FSIOperator::fluidBchandlerPtr_Type BCh_fluidLin (FSIOperator& _oper)
{
if (! _oper.isFluid() )
{
return FSIOperator::fluidBchandlerPtr_Type();
}
// Boundary conditions for the fluid velocity
debugStream ( 10000 ) << "Boundary condition for the linearized fluid\n";
FSIOperator::fluidBchandlerPtr_Type BCh_fluidLin ( new FSIOperator::fluidBchandler_Type );
BCFunctionBase bcf (fZero);
BCFunctionBase in_flow (u2);
#ifdef FLUX
BCh_fluidLin->addBC ("InFlow", 2, Flux, Normal, bcf, 3);
#else
//BCh_fluidLin->addBC("InFlow", 2, Natural, Full, bcf, 3);
#endif
BCh_fluidLin->addBC ("outFlow", 3, Natural, Full, bcf, 3);
//BCh_fluidLin->addBC("Edges", 20, EssentialVertices, Full, bcf, 3);//this condition must be equal to the one
//BCh_fluidLin->addBC("ainterface", 1, Essential, Full, bcf, 3);
if (_oper.data().method() == "steklovPoincare")
{
// steklovPoincare *SPOper = dynamic_cast<steklovPoincare *>(&_oper);
// SPOper->setDerHarmonicExtensionVelToFluid(_oper.dw());
// BCh_fluidLin->addBC("Wall" , 1, Essential , Full,
// *SPOper->bcvDerHarmonicExtensionVelToFluid(), 3);
}
if (_oper.data().method() == "exactJacobian")
{
FSIExactJacobian* EJOper = dynamic_cast<FSIExactJacobian*> (&_oper);
EJOper->setDerHarmonicExtensionVelToFluid (_oper.derVeloFluidMesh() );
BCh_fluidLin->addBC ("Interface", FLUIDINTERFACE, Essential , Full,
*_oper.bcvDerHarmonicExtensionVelToFluid(), 3);
}
return BCh_fluidLin;
}
FSIOperator::solidBchandlerPtr_Type BCh_monolithicSolid (FSIOperator& _oper)
{
if (! _oper.isSolid() )
{
return FSIOperator::solidBchandlerPtr_Type();
}
// Boundary conditions for the solid displacement
debugStream ( 10000 ) << "Boundary condition for the solid\n";
FSIOperator::solidBchandlerPtr_Type BCh_solid ( new FSIOperator::solidBchandler_Type );
BCFunctionBase bcf (fZero);
//Inlets & Outlets
BCh_solid->addBC ("BORDERS", INLETWALL, Essential, Full, bcf, 3);
BCh_solid->addBC ("BORDERS-RIN", INLETWALL_INTRING, Essential, Full, bcf, 3);
BCh_solid->addBC ("BORDERS-ROUT", INLETWALL_OUTRING, Essential, Full, bcf, 3);
BCh_solid->addBC ("BORDERS", OUTLETWALL, Essential, Full, bcf, 3);
BCh_solid->addBC ("BORDERS-rin", OUTLETWALL_INTRING, Essential, Full, bcf, 3);
BCh_solid->addBC ("BORDERS-rout", OUTLETWALL_OUTRING, Essential, Full, bcf, 3);
//aortaVelIn::S_timestep = _oper.dataFluid()->dataTime()->timeStep();
//Robin BC
BCFunctionBase hyd (fZero);
BCFunctionBase young (E);
//robin condition on the outer wall
_oper.setRobinOuterWall (hyd, young);
//BCh_solid->addBC("OuterWall", OUTERWALL, Robin, Normal, _oper.bcfRobinOuterWall());
//First try: Homogeneous Neumann
BCh_solid->addBC ("OuterWall", OUTERWALL, Natural, Normal, bcf);
return BCh_solid;
}
FSIOperator::solidBchandlerPtr_Type BCh_solidLin (FSIOperator& _oper)
{
if (! _oper.isSolid() )
{
return FSIOperator::solidBchandlerPtr_Type();
}
// Boundary conditions for the solid displacement
debugStream ( 10000 ) << "Boundary condition for the linear solid\n";
FSIOperator::solidBchandlerPtr_Type BCh_solidLin ( new FSIOperator::solidBchandler_Type );
BCFunctionBase bcf (fZero);
BCh_solidLin->addBC ("Top", 3, Essential, Full, bcf, 3);
BCh_solidLin->addBC ("Base", 2, Essential, Full, bcf, 3);
//BCh_solidLin->addBC("EdgesIn", 20, EssentialVertices, Full, bcf, 3);
std::vector<ID> zComp (1);
zComp[0] = 3;
if (_oper.data().method() == "steklovPoincare")
{
// steklovPoincare *SPOper = dynamic_cast<steklovPoincare *>(&_oper);
// SPOper->setSolidLinInterfaceDisp((LifeV::Vector&) _oper.displacement());
// BCh_solidLin->addBC("Interface", 1, Essential, Full,
// *SPOper->bcvSolidLinInterfaceDisp(), 3);
}
else if (_oper.data().method() == "exactJacobian")
{
FSIExactJacobian* EJOper = dynamic_cast<FSIExactJacobian*> (&_oper);
EJOper->setDerFluidLoadToStructure (_oper.sigmaSolidRepeated() );
BCh_solidLin->addBC ("Interface", SOLIDINTERFACE, Natural, Full,
*EJOper->bcvDerFluidLoadToStructure(), 3);
}
return BCh_solidLin;
}
FSIOperator::fluidBchandlerPtr_Type BCh_fluidInv (FSIOperator& _oper)
{
if (! _oper.isFluid() )
{
return FSIOperator::fluidBchandlerPtr_Type();
}
// Boundary conditions for the fluid velocity
debugStream ( 10000 ) << "Boundary condition for the inverse fluid\n";
FSIOperator::fluidBchandlerPtr_Type BCh_fluidInv ( new FSIOperator::fluidBchandler_Type );
BCFunctionBase bcf (fZero);
BCFunctionBase in_flow (u2);
BCh_fluidInv->addBC ("InFlow", 2, Natural, Full, in_flow, 3);
BCh_fluidInv->addBC ("EdgesIn", 20, EssentialVertices, Full, bcf, 3);
return BCh_fluidInv;
}
FSIOperator::fluidBchandlerPtr_Type BCh_harmonicExtension (FSIOperator& _oper)
{
// debugStream(10000) << "SP harmonic extension\n";
// fixedPoint *FPOper = dynamic_cast<fixedPoint *>(&_oper);
// FPOper->setStructureDispToHarmonicExtension(_oper.lambdaFluid());
if (! _oper.isFluid() )
{
return FSIOperator::fluidBchandlerPtr_Type();
}
// FPOper->bcvStructureDispToHarmonicExtension()->showMe(true,std::cout);
// 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 );
BCh_he->addBC ("Edges", INOUTEDGE, Essential, Full, bcf, 3);
BCh_he->addBC ("Edges", INEDGE, Essential, Full, bcf, 3);
BCh_he->addBC ("Base", INLET, Essential, Full, bcf, 3);
// BCh_he->addBC("Top", 3, Essential, Full, bcf, 3);
// BCh_he->addBC("Base", 2, Essential, Full, bcf, 3);
if (_oper.data().method() == "steklovPoincare")
{
// debugStream(10000) << "SP harmonic extension\n";
// steklovPoincare *SPOper = dynamic_cast<steklovPoincare *>(&_oper);
// SPOper->setFluidInterfaceDisp((LifeV::Vector&) _oper.lambdaFluidRepeated());
// BCh_he->addBC("Interface", 1, Essential, Full,
// *SPOper->bcvFluidInterfaceDisp(), 3);
}
else if (_oper.data().method() == "exactJacobian")
{
debugStream (10000) << "EJ harmonic extension\n";
FSIExactJacobian* EJOper = dynamic_cast<FSIExactJacobian*> (&_oper);
EJOper->setStructureDispToHarmonicExtension (_oper.lambdaFluidRepeated() );
BCh_he->addBC ("Interface", FLUIDINTERFACE, Essential, Full,
*EJOper->bcvStructureDispToHarmonicExtension(), 3);
}
else if (_oper.data().method() == "fixedPoint")
{
debugStream (10000) << "FP harmonic extension\n";
FSIFixedPoint* FPOper = dynamic_cast<FSIFixedPoint*> (&_oper);
FPOper->setStructureDispToHarmonicExtension (_oper.lambdaFluidRepeated() );
BCh_he->addBC ("Interface", FLUIDINTERFACE, Essential, Full,
*FPOper->bcvStructureDispToHarmonicExtension(), 3);
}
return BCh_he;
}
void FlowConditions::initParameters ( FSIOperator& Oper,
const int& outflowFlag)
{
UInt flag = 1;
Epetra_SerialDenseVector fluidQuantities (1); // M_area0
Epetra_SerialDenseVector solidQuantities (2); // M_beta and M_rhos
if (Oper.isFluid() )
{
fluidQuantities (0) = Oper.fluid().area (outflowFlag);
}
M_area0 = fluidQuantities (0);
M_outRadius0 = std::sqrt (M_area0 / pi);
M_inRadius0 = M_outRadius0;
Oper.displayer().leaderPrint ( " Outflow BC : area0 = ", M_area0 );
Oper.displayer().leaderPrint ( " Outflow BC : radius = ", M_outRadius0 );
if (Oper.isSolid() )
{
solidQuantities (0) = ( ( Oper.solid().thickness() * Oper.solid().young ( flag ) ) / ( 1 - Oper.solid().poisson ( flag ) * Oper.solid().poisson ( flag ) ) * pi / M_area0 );
solidQuantities (1) = Oper.solid().rho( );
Oper.displayer().leaderPrint ( " Outflow BC : thickness = " , Oper.solid().thickness() );
Oper.displayer().leaderPrint ( " Outflow BC : young = " , Oper.solid().young ( flag ) );
Oper.displayer().leaderPrint ( " Outflow BC : poisson = " , Oper.solid().poisson ( flag ) );
}
//Oper.worldComm().Broadcast( solidQuantities.Values(), solidQuantities.Length(),
//Oper.getSolidLeaderId() );
M_beta = solidQuantities (0);
M_rhos = solidQuantities (1);
Oper.displayer().leaderPrint ( " Outflow BC : beta = " , M_beta );
Oper.displayer().leaderPrint ( " Outflow BC : rho = " , M_rhos );
}
void FlowConditions::renewParameters ( FSISolver& oper_,
const int& outflowFlag,
const FSIOperator::vector_Type& fluidSolution)
{
Epetra_SerialDenseVector fluidQuantities (2); // Flux and Area
//Epetra_SerialDenseVector solidQuantities(0); // M_beta and M_rhos
FSIOperator* Oper (oper_.FSIOper().get() );
if (Oper->isFluid() )
{
fluidQuantities (0) = Oper->fluid().flux (outflowFlag, fluidSolution );
fluidQuantities (1) = Oper->fluid().area (outflowFlag);
}
Oper->worldComm()->Broadcast ( fluidQuantities.Values(), fluidQuantities.Length(),
Oper->getFluidLeaderId() );
Real qn;
Real area;
Real area0;
qn = fluidQuantities (0);
area = fluidQuantities (1);
area0 = 0.0034212;
// Fluid density
// Real density = 1.0;
UInt flag = 1;
// Setting parameters for our simulation:
// if imposing the absorbing boundary condition through the pressure:
if (bcOnFluid)
{
// Moura et al.
//Alexandra's Abc
Real exp = 5 / 4;
Real beta = ( std::sqrt (PI) * Oper->solid().thickness() * Oper->solid().young ( flag ) ) / (1 - Oper->solid().poisson ( flag ) * Oper->solid().poisson ( flag ) );
Real R = ( std::sqrt (Oper->solid().rho( ) * beta ) ) / ( std::sqrt (2.0) * std::pow (area0, exp) );
M_outP = R * qn;
// Nobile & Vergara
// M_outP = pow((sqrt(density)/(2.*sqrt(2))*qn/area + sqrt(M_beta*sqrt(M_area0))),2)
// - M_beta*sqrt(M_area0);
FlowConditions::outputVector[conditionNumber] = M_outP;
Oper->displayer().leaderPrint ( " Flow rate = " , qn );
Oper->displayer().leaderPrint ( " outflow pressure = " , M_outP );
M_outDeltaRadius = 0;
}
else
{
// if imposing the absorbing boundary condition through change in radius: --> Not ready
#ifdef TESTING
M_outP = Pout;
area = qn * std::sqrt (M_rhos) / ( (2.*std::sqrt (2) ) *
std::sqrt ( M_outP + M_beta * sqrt (M_area0) ) - std::sqrt ( M_beta * sqrt (M_area0) ) );
assert (area >= 0 );
if (area < 1e-8 * M_area0)
{
area = M_area0;
}
M_outDeltaRadius = std::sqrt ( area / pi ) - M_outRadius0;
Oper->displayer().leaderPrint ( " outflow A = " , area );
Oper->displayer().leaderPrint ( " outflow dr = " , M_outDeltaRadius );
Oper->displayer().leaderPrint ( " Flow rate = " , qn );
Oper->displayer().leaderPrint ( " outflow pressure = " , M_outP );
#endif
}
// for now applying absBC only at outflow
M_inDeltaRadius = 0;
// M_inP = Pin;
}