def J_BlockF(dotdU,dU,dP,U,dotD_F,v,dotv,q,D_F,rho,mu,N_F,dxFlist,dsDNlist,dsF,g_F=None): """Fluid Diagonal Block, Fluid Domain """ Id = I(U) forms = [] for dxF in dxFlist: #DT (without ALE term) J_FF = inner(dotv, rho*J(D_F)*dotdU)*dxF J_FF += inner(v, rho*J(D_F)*dot(dot(grad(dU), inv(F(D_F))), U - dotD_F))*dxF J_FF += inner(v, rho*J(D_F)*dot(grad(U), dot(inv(F(D_F)), dU)))*dxF #div Sigma_F J_FF += inner(grad(v), J(D_F)*mu*dot(grad(dU), dot(inv(F(D_F)), inv(F(D_F)).T)))*dxF J_FF += inner(grad(v), J(D_F)*mu*dot(inv(F(D_F)).T, dot(grad(dU).T, inv(F(D_F)).T)))*dxF J_FF += -inner(grad(v), J(D_F)*dP*inv(F(D_F)).T)*dxF #div U_F (incompressibility) J_FF += inner(q, div(J(D_F)*dot(inv(F(D_F)), dU)))*dxF forms.append(J_FF) #Do nothing BC for dsDN in dsDNlist: DN_FF = -inner(v, dot(J(D_F)*mu*dot(inv(F(D_F)).T, dot(grad(dU).T, inv(F(D_F)).T)), N_F))*dsDN DN_FF += inner(v, J(D_F)*dP*dot(Id, dot(inv(F(D_F)).T, N_F)))*dsDN forms.append(DN_FF) return sum(forms)
def J_BlockFFD(U, dotU, P, D_F, dD_F,dotD_F, dotdD_F, v_F,dotv, q, rho, mu,N_F, dxFlist,dsDNlist,dFSIlist,ds_F,g_F = None,F_F = None): """Fluid-Fluid Domain coupling""" Id = I(D_F) forms = [] for dxF in dxFlist: #If a fluid body force has been specified, it will end up here. if F_F is not None and F_F != []: B_F = -inner(v_F,J(D_F)*tr(dot(grad(dD_F),inv(F(D_F))))*F_F)*dxF forms.append(B_F) #Simplify the remaining terms if an FSI interface measure provided if dFSIlist is not None: dxFlist = dFSIlist for dxF in dxFlist: #DT J_FM = inner(v_F, rho*J(D_F)*tr(dot(grad(dD_F), inv(F(D_F))))*dotU) J_FM += inner(v_F, rho*J(D_F)*tr(dot(grad(dD_F), inv(F(D_F))))*dot(grad(U), dot(inv(F(D_F)), U - dotD_F))) J_FM += -inner(v_F,rho*J(D_F)*dot((dot(grad(U), dot(inv(F(D_F)), \ dot(grad(dD_F), inv(F(D_F)))))), U - dotD_F )) J_FM += -inner(v_F, rho*J(D_F)*dot(grad(U), dot(inv(F(D_F)),dotdD_F))) #SigmaF J_FM += inner(grad(v_F),dD_FSigmaF(D_F,dD_F,U,P,mu)) #Div U_F (incompressibility) J_FM += inner(q, div(J(D_F)*tr(dot(grad(dD_F), inv(F(D_F))))*dot(inv(F(D_F)), U))) J_FM += -inner(q, div(J(D_F)*dot(dot(inv(F(D_F)), grad(dD_F)), dot(inv(F(D_F)), U)))) if dFSIlist is None: J_FM = J_FM*dxF else: J_FM = J_FM('+')*dxF forms.append(J_FM) return sum(forms) ##Add the terms for the Do nothing boundary if necessary for dsDN in dsDNlist: #Derivative of do nothing tensor with J factored out dSigma = tr(grad(dD_F)*inv(F(D_F)))*(mu*inv(F(D_F)).T*grad(U).T - P*Id)*inv(F(D_F)).T dSigma += -mu*inv(F(D_F)).T*grad(dD_F).T*inv(F(D_F)).T*grad(U).T*inv(F(D_F)).T dSigma += -(mu*inv(F(D_F)).T*grad(U).T - P*Id)*inv(F(D_F)).T*grad(dD_F).T*inv(F(D_F)).T #J added dSigma = J(D_F)*dSigma DN_FM = -inner(v_F,dot(dSigma,N_F))*dsDN forms.append(DN_FM) return sum(forms)
def J_FSI(dU_F,dU_Fmid,dP_Fmid,dD_Fmid,U_Fmid,P_Fmid,D_Fmid,c_S,mu_F,N_F,dFSIlist): """Derivative of the Interface Residual""" forms = [] Sigma_F = PiolaTransform(_Sigma_F(dU_Fmid, dP_Fmid, D_Fmid, mu_F), D_Fmid) for dFSI in dFSIlist: J_FSI = -(inner(c_S('-'),dot(Sigma_F('+'),N_F('-'))))*dFSI J_FSI += -inner(c_S('-'),dot(dD_FSigmaF(D_Fmid,dD_Fmid,U_Fmid,P_Fmid,mu_F)('+'),N_F('-')))*dFSI forms.append(J_FSI) return sum(forms)
def J_BlockF(dotdU, dU, dP, U, dotD_F, v, dotv, q, D_F, rho, mu, N_F, dxFlist, dsDNlist, dsF, g_F=None): """Fluid Diagonal Block, Fluid Domain """ Id = I(U) forms = [] for dxF in dxFlist: #DT (without ALE term) J_FF = inner(dotv, rho * J(D_F) * dotdU) * dxF J_FF += inner( v, rho * J(D_F) * dot(dot(grad(dU), inv(F(D_F))), U - dotD_F)) * dxF J_FF += inner(v, rho * J(D_F) * dot(grad(U), dot(inv(F(D_F)), dU))) * dxF #div Sigma_F J_FF += inner( grad(v), J(D_F) * mu * dot(grad(dU), dot(inv(F(D_F)), inv(F(D_F)).T))) * dxF J_FF += inner( grad(v), J(D_F) * mu * dot(inv(F(D_F)).T, dot(grad(dU).T, inv(F(D_F)).T))) * dxF J_FF += -inner(grad(v), J(D_F) * dP * inv(F(D_F)).T) * dxF #div U_F (incompressibility) J_FF += inner(q, div(J(D_F) * dot(inv(F(D_F)), dU))) * dxF forms.append(J_FF) #Do nothing BC for dsDN in dsDNlist: DN_FF = -inner( v, dot( J(D_F) * mu * dot(inv(F(D_F)).T, dot(grad(dU).T, inv(F(D_F)).T)), N_F)) * dsDN DN_FF += inner(v, J(D_F) * dP * dot(Id, dot(inv(F(D_F)).T, N_F))) * dsDN forms.append(DN_FF) return sum(forms)
def J_BlockS(dD_S, D_S, c_S, mu_S, lmbda_S, rho_S, dxSlist): "Structure diagonal block" Id = I(D_S) F_S = grad(D_S) + I(D_S) #I + grad U_s E_S = 0.5*(F_S.T*F_S - Id) #Es in the book dE_S = 0.5*(grad(dD_S).T*F_S + F_S.T*grad(dD_S))#Derivative of Es wrt to US in the book dUsSigma_S = grad(dD_S)*(2*mu_S*E_S + lmbda_S*tr(E_S)*Id) + F_S*(2*mu_S*dE_S + lmbda_S*tr(dE_S)*Id) forms = [] for dxS in dxSlist: forms.append(inner(grad(c_S), dUsSigma_S)*dxS) return sum(forms)
def J_FSI(dU_F, dU_Fmid, dP_Fmid, dD_Fmid, U_Fmid, P_Fmid, D_Fmid, c_S, mu_F, N_F, dFSIlist): """Derivative of the Interface Residual""" forms = [] Sigma_F = PiolaTransform(_Sigma_F(dU_Fmid, dP_Fmid, D_Fmid, mu_F), D_Fmid) for dFSI in dFSIlist: J_FSI = -(inner(c_S('-'), dot(Sigma_F('+'), N_F('-')))) * dFSI J_FSI += -inner( c_S('-'), dot( dD_FSigmaF(D_Fmid, dD_Fmid, U_Fmid, P_Fmid, mu_F) ('+'), N_F('-'))) * dFSI forms.append(J_FSI) return sum(forms)
def J_BlockS(dD_S, D_S, c_S, mu_S, lmbda_S, rho_S, dxSlist): "Structure diagonal block" Id = I(D_S) F_S = grad(D_S) + I(D_S) #I + grad U_s E_S = 0.5 * (F_S.T * F_S - Id) #Es in the book dE_S = 0.5 * (grad(dD_S).T * F_S + F_S.T * grad(dD_S) ) #Derivative of Es wrt to US in the book dUsSigma_S = grad(dD_S) * (2 * mu_S * E_S + lmbda_S * tr(E_S) * Id) + F_S * ( 2 * mu_S * dE_S + lmbda_S * tr(dE_S) * Id) forms = [] for dxS in dxSlist: forms.append(inner(grad(c_S), dUsSigma_S) * dxS) return sum(forms)
def J_Bufferable(dU_F,dotdD_S,dD_S, dotdU_S,dU_S,dU_Smid,dD_Fdot,dD_F,dD_Fmid,dL_U,dL_D,v_F,dotv_S, dotc_S,dotc_F,c_F,m_D,m_U,rho_S,mu_FD,lmbda_FD,dx_Flist,dFSIlist,dxSlist): """Linear forms that only need to be assembled once""" #Fluid Domain diagonal block forms = [] Sigma_FD = _Sigma_M(dD_Fmid, mu_FD, lmbda_FD) for dx_F in dx_Flist: J_FD = inner(dotc_F, dD_Fdot)*dx_F + inner(sym(grad(c_F)), Sigma_FD)*dx_F forms.append(J_FD) #Lagrange Multiplier conditions for dFSI in dFSIlist: J_FSI = inner(m_D, dD_F - dD_S)('+')*dFSI J_FSI += inner(c_F, dL_D)('+')*dFSI #Lagrange Multiplier J_FSI += inner(m_U, dU_F - dU_S)('+')*dFSI J_FSI += inner(v_F, dL_U)('+')*dFSI #Lagrange Multiplier forms.append(J_FSI) #Structure Dt terms for dxS in dxSlist: J_S = inner(dotc_S, rho_S*dotdU_S)*dxS + inner(dotv_S, dotdD_S - dU_Smid)*dxS forms.append(J_S) return sum(forms)
def J_Bufferable(dU_F, dotdD_S, dD_S, dotdU_S, dU_S, dU_Smid, dD_Fdot, dD_F, dD_Fmid, dL_U, dL_D, v_F, dotv_S, dotc_S, dotc_F, c_F, m_D, m_U, rho_S, mu_FD, lmbda_FD, dx_Flist, dFSIlist, dxSlist): """Linear forms that only need to be assembled once""" #Fluid Domain diagonal block forms = [] Sigma_FD = _Sigma_M(dD_Fmid, mu_FD, lmbda_FD) for dx_F in dx_Flist: J_FD = inner(dotc_F, dD_Fdot) * dx_F + inner(sym(grad(c_F)), Sigma_FD) * dx_F forms.append(J_FD) #Lagrange Multiplier conditions for dFSI in dFSIlist: J_FSI = inner(m_D, dD_F - dD_S)('+') * dFSI J_FSI += inner(c_F, dL_D)('+') * dFSI #Lagrange Multiplier J_FSI += inner(m_U, dU_F - dU_S)('+') * dFSI J_FSI += inner(v_F, dL_U)('+') * dFSI #Lagrange Multiplier forms.append(J_FSI) #Structure Dt terms for dxS in dxSlist: J_S = inner(dotc_S, rho_S * dotdU_S) * dxS + inner( dotv_S, dotdD_S - dU_Smid) * dxS forms.append(J_S) return sum(forms)
def J_BlockFFD(U, dotU, P, D_F, dD_F, dotD_F, dotdD_F, v_F, dotv, q, rho, mu, N_F, dxFlist, dsDNlist, dFSIlist, ds_F, g_F=None, F_F=None): """Fluid-Fluid Domain coupling""" Id = I(D_F) forms = [] for dxF in dxFlist: #If a fluid body force has been specified, it will end up here. if F_F is not None and F_F != []: B_F = -inner(v_F, J(D_F) * tr(dot(grad(dD_F), inv(F(D_F)))) * F_F) * dxF forms.append(B_F) #Simplify the remaining terms if an FSI interface measure provided if dFSIlist is not None: dxFlist = dFSIlist for dxF in dxFlist: #DT J_FM = inner(v_F, rho * J(D_F) * tr(dot(grad(dD_F), inv(F(D_F)))) * dotU) J_FM += inner( v_F, rho * J(D_F) * tr(dot(grad(dD_F), inv(F(D_F)))) * dot(grad(U), dot(inv(F(D_F)), U - dotD_F))) J_FM += -inner(v_F,rho*J(D_F)*dot((dot(grad(U), dot(inv(F(D_F)), \ dot(grad(dD_F), inv(F(D_F)))))), U - dotD_F )) J_FM += -inner(v_F, rho * J(D_F) * dot(grad(U), dot(inv(F(D_F)), dotdD_F))) #SigmaF J_FM += inner(grad(v_F), dD_FSigmaF(D_F, dD_F, U, P, mu)) #Div U_F (incompressibility) J_FM += inner( q, div( J(D_F) * tr(dot(grad(dD_F), inv(F(D_F)))) * dot(inv(F(D_F)), U))) J_FM += -inner( q, div( J(D_F) * dot(dot(inv(F(D_F)), grad(dD_F)), dot(inv(F(D_F)), U)))) if dFSIlist is None: J_FM = J_FM * dxF else: J_FM = J_FM('+') * dxF forms.append(J_FM) return sum(forms) ##Add the terms for the Do nothing boundary if necessary for dsDN in dsDNlist: #Derivative of do nothing tensor with J factored out dSigma = tr(grad(dD_F) * inv(F(D_F))) * ( mu * inv(F(D_F)).T * grad(U).T - P * Id) * inv(F(D_F)).T dSigma += -mu * inv(F(D_F)).T * grad(dD_F).T * inv( F(D_F)).T * grad(U).T * inv(F(D_F)).T dSigma += -(mu * inv(F(D_F)).T * grad(U).T - P * Id) * inv( F(D_F)).T * grad(dD_F).T * inv(F(D_F)).T #J added dSigma = J(D_F) * dSigma DN_FM = -inner(v_F, dot(dSigma, N_F)) * dsDN forms.append(DN_FM) return sum(forms)