コード例 #1
0
    def compute_fluid_stress(self, u_F0, u_F1, p_F0, p_F1, U_M0, U_M1):

        # Map u and p back to reference domain
        self.U_F0.vector()[:] = u_F0.vector()[:]
        self.U_F1.vector()[:] = u_F1.vector()[:]
        self.P_F0.vector()[:] = p_F0.vector()[:]
        self.P_F1.vector()[:] = p_F1.vector()[:]

        # Get variables
        mu_F = self.viscosity()
        U_F = self.U_F
        P_F = self.P_F
        U_M = 0.5 * (U_M0 + U_M1)

        # Compute physical stress
        Sigma_F = PiolaTransform(_Sigma_F(U_F, P_F, U_M, mu_F), U_M)

        # Test this averaging instead:
        #info_red("Debugging with converge averaging")
        #Sigma_F0 = PiolaTransform(_Sigma_F(self.U_F0, self.P_F0, U_M0, mu_F),
        #                          U_M0)
        #Sigma_F1 = PiolaTransform(_Sigma_F(self.U_F1, self.P_F1, U_M1, mu_F),
        #                          U_M1)
        #Sigma_F = 0.5*(Sigma_F0 + Sigma_F1)

        return Sigma_F
コード例 #2
0
ファイル: subproblems.py プロジェクト: BijanZarif/CBC.Solve
    def compute_fluid_stress(self, u_F0, u_F1, p_F0, p_F1, U_M0, U_M1):

        # Map u and p back to reference domain
        self.U_F0.vector()[:] = u_F0.vector()[:]
        self.U_F1.vector()[:] = u_F1.vector()[:]
        self.P_F0.vector()[:] = p_F0.vector()[:]
        self.P_F1.vector()[:] = p_F1.vector()[:]

        # Get variables
        mu_F = self.viscosity()
        U_F  = self.U_F
        P_F  = self.P_F
        U_M = 0.5 * (U_M0 + U_M1)

        # Compute physical stress
        Sigma_F = PiolaTransform(_Sigma_F(U_F, P_F, U_M, mu_F), U_M)

        # Test this averaging instead:
        #info_red("Debugging with converge averaging")
        #Sigma_F0 = PiolaTransform(_Sigma_F(self.U_F0, self.P_F0, U_M0, mu_F),
        #                          U_M0)
        #Sigma_F1 = PiolaTransform(_Sigma_F(self.U_F1, self.P_F1, U_M1, mu_F),
        #                          U_M1)
        #Sigma_F = 0.5*(Sigma_F0 + Sigma_F1)

        return Sigma_F
コード例 #3
0
ファイル: subproblems.py プロジェクト: BijanZarif/CBC.Solve
    def compute_fluid_stress(self, u_F0, u_F1, p_F0, p_F1, U_M0, U_M1):

        # Map u and p back to reference domain
        self.U_F0.vector()[:] = u_F0.vector()[:]
        self.U_F1.vector()[:] = u_F1.vector()[:]
        self.P_F0.vector()[:] = p_F0.vector()[:]
        self.P_F1.vector()[:] = p_F1.vector()[:]

        # Get variables
        mu_F = self.viscosity()
        U_F  = self.U_F
        P_F  = self.P_F
        U_M = 0.5 * (U_M0 + U_M1)

        # Compute physical stress
        Sigma_F = PiolaTransform(_Sigma_F(U_F, P_F, U_M, mu_F), U_M)

        return Sigma_F
コード例 #4
0
    def compute_fluid_stress(self, u_F0, u_F1, p_F0, p_F1, U_M0, U_M1):

        # Map u and p back to reference domain
        self.U_F0.vector()[:] = u_F0.vector()[:]
        self.U_F1.vector()[:] = u_F1.vector()[:]
        self.P_F0.vector()[:] = p_F0.vector()[:]
        self.P_F1.vector()[:] = p_F1.vector()[:]

        # Get variables
        mu_F = self.viscosity()
        U_F = self.U_F
        P_F = self.P_F
        U_M = 0.5 * (U_M0 + U_M1)

        # Compute physical stress
        Sigma_F = PiolaTransform(_Sigma_F(U_F, P_F, U_M, mu_F), U_M)

        return Sigma_F
コード例 #5
0
ファイル: residuals.py プロジェクト: bonh/CBC.Solve
def weak_residuals(U0, U1, U, w, kn, problem):
    "Return weak residuals"

    # Extract variables
    U_F0, P_F0, U_S0, P_S0, U_M0 = U0
    U_F1, P_F1, U_S1, P_S1, U_M1 = U1
    U_F,  P_F,  U_S,  P_S,  U_M  = U
    v_F, q_F, s_F, v_S, q_S, v_M, q_M = w

    # Get problem parameters
    Omega   = problem.mesh()
    rho_F   = problem.fluid_density()
    mu_F    = problem.fluid_viscosity()
    rho_S   = problem.structure_density()
    mu_S    = problem.structure_mu()
    lmbda_S = problem.structure_lmbda()
    alpha_M = problem.mesh_alpha()
    mu_M    = problem.mesh_mu()
    lmbda_M = problem.mesh_lmbda()

    # MER: added these
    B       = problem.structure_body_force()
    G_0     = problem.structure_boundary_traction_extra()
    F_M     = problem.mesh_right_hand_side()

    # Define normals
    N = FacetNormal(Omega)
    N_F = N
    N_S = -N

    # Define cell integrals
    dx_F = dx(0)
    dx_S = dx(1)

    # Define facet integrals
    dS_F  = dS(0)
    dS_S  = dS(1)
    d_FSI = dS(2)

    # Define time derivatives
    dt_U_F = (1/kn) * (U_F1 - U_F0)
    dt_U_M = (1/kn) * (U_M1 - U_M0)
    
    Dt_U_F = rho_F * J(U_M) * (dt_U_F + dot(grad(U_F), dot(inv(F(U_M)), U_F - dt_U_M)))
    Dt_U_S = (1/kn) * (U_S1 - U_S0)
    Dt_P_S = rho_S * (1/kn) * (P_S1 - P_S0)
    Dt_U_M = alpha_M * (1/kn) * (U_M1 - U_M0)

    # Define stresses
    Sigma_F = PiolaTransform(_Sigma_F(U_F, P_F, U_M, mu_F), U_M)
    Sigma_S = _Sigma_S(U_S, mu_S, lmbda_S)
    Sigma_M = _Sigma_M(U_M, mu_M, lmbda_M)

    # Fluid residual
    Id = I(U_F)
    
    R_F = inner(v_F, Dt_U_F)*dx_F + inner(grad(v_F), Sigma_F)*dx_F \
        - inner(v_F, mu_F*J(U_M)*dot(dot(inv(F(U_M)).T, grad(U_F).T), dot(inv(F(U_M)).T, N_F)))*ds \
        + inner(v_F, J(U_M)*P_F*dot(Id, dot(inv(F(U_M)).T, N_F)))*ds \
        + inner(q_F, div(J(U_M)*dot(inv(F(U_M)), U_F)))*dx_F

    # Structure residual
    # MER: What about the body force? (Added, makes a difference, good)
    # MER And the extra stress? (Added, sign dubious, b/c evaluates to
    # zero since it is orthogonal to test case dual solution)
    R_S = inner(v_S, Dt_P_S)*dx_S + inner(grad(v_S), Sigma_S)*dx_S \
        - inner(v_S('-'), dot(Sigma_F('+'), N_S('+')))*d_FSI \
        + inner(q_S, Dt_U_S - P_S)*dx_S \
        - inner(v_S, B)*dx_S \
        + inner(v_S('-'), G_0('-'))*d_FSI \

    # Mesh residual contributions
    R_M = inner(v_M, Dt_U_M)*dx_F + inner(sym(grad(v_M)), Sigma_M)*dx_F \
        + inner(q_M, U_M - U_S)('+')*d_FSI \
        - inner(v_M, F_M)*dx_F

    return R_F, R_S, R_M
コード例 #6
0
ファイル: residuals.py プロジェクト: bonh/CBC.Solve
def strong_residuals(U0, U1, U, Z, EZ, w, kn, problem):
    "Return strong residuals (integrated by parts)"

    # Extract variables
    U_F0, P_F0, U_S0, P_S0, U_M0        = U0
    U_F1, P_F1, U_S1, P_S1, U_M1        = U1
    U_F,  P_F,  U_S,  P_S,  U_M         = U
    Z_F,  Y_F, X_F, Z_S, Y_S, Z_M, Y_M  = Z
    EZ_F, EY_F, EX_F ,EZ_S, EY_S, EZ_M, EY_M  = EZ

    # Get problem parameters
    Omega   = problem.mesh()
    Omega_F = problem.fluid_mesh()
    Omega_S = problem.structure_mesh()
    rho_F   = problem.fluid_density()
    mu_F    = problem.fluid_viscosity()
    rho_S   = problem.structure_density()
    mu_S    = problem.structure_mu()
    lmbda_S = problem.structure_lmbda()
    alpha_M = problem.mesh_alpha()
    mu_M    = problem.mesh_mu()
    lmbda_M = problem.mesh_lmbda()

    # Define normals
    N = FacetNormal(Omega)
    N_F = N
    N_S = N

    # FIXME: Check sign of N_S, should it be -N?

    # Define inner products
    dx_F = dx(0)
    dx_S = dx(1)

    # Define "facet" products
    dS_F  = dS(0)
    dS_S  = dS(1)
    d_FSI = dS(2)

    # Define midpoint values
    U_F = 0.5 * (U_F0 + U_F1)
    P_F = 0.5 * (P_F0 + P_F1)
    U_S = 0.5 * (U_S0 + U_S1)
    P_S = 0.5 * (P_S0 + P_S1)
    U_M = 0.5 * (U_M0 + U_M1)

    # Define time derivatives
    dt_U_F = (1/kn) * (U_F1 - U_F0)
    dt_U_M = (1/kn) * (U_M1 - U_M0)
    Dt_U_F = rho_F * J(U_M) * (dt_U_F + dot(grad(U_F), dot(inv(F(U_M)), U_F - dt_U_M)))
    Dt_U_S = (1/kn) * (U_S1 - U_S0)
    Dt_P_S = rho_S * (1/kn) * (P_S1 - P_S0)
    Dt_U_M = alpha_M * (1/kn) * (U_M1 - U_M0)

    # Define stresses
    Sigma_F = PiolaTransform(_Sigma_F(U_F, P_F, U_M, mu_F), U_M)
    Sigma_S = _Sigma_S(U_S, mu_S, lmbda_S)
    Sigma_M = _Sigma_M(U_M, mu_M, lmbda_M)

    # Fluid residual contributions
    # FIXME: Add dual Lagrange multiplier EX_F for the fluid
    R_F0 = w*inner(EZ_F - Z_F, Dt_U_F - div(Sigma_F))*dx_F
    R_F1 = avg(w)*inner(EZ_F('+') - Z_F('+'), jump(Sigma_F, N_F))*dS_F
    R_F2 = w*inner(EZ_F - Z_F, dot(Sigma_F, N_F))*ds
    R_F3 = w*inner(EY_F - Y_F, div(J(U_M)*dot(inv(F(U_M)), U_F)))*dx_F

    # Structure residual contributions (note the minus sign on N_F('+'))
    R_S0 = w*inner(EZ_S - Z_S, Dt_P_S - div(Sigma_S))*dx_S
    R_S1 = avg(w)*inner(EZ_S('-') - Z_S('-'), jump(Sigma_S, N_S))*dS_S
    R_S2 = w('-')*inner(EZ_S('-') - Z_S('-'), dot(Sigma_S('-') - Sigma_F('+'), -N_F('+')))*d_FSI
    R_S3 = w*inner(EY_S - Y_S, Dt_U_S - P_S)*dx_S

    # Mesh residual contributions
    R_M0 = w*inner(EZ_M - Z_M, Dt_U_M - div(Sigma_M))*dx_F
    R_M1 = avg(w)*inner(EZ_M('+') - Z_M('+'), jump(Sigma_M, N_F))*dS_F
    R_M2 = w('+')*inner(EY_M - Y_M, U_M - U_S)('+')*d_FSI # this should be zero

    return (R_F0, R_F1, R_F2, R_F3), (R_S0, R_S1, R_S2, R_S3), (R_M0, R_M1, R_M2)
コード例 #7
0
ファイル: residuals.py プロジェクト: bonh/CBC.Solve
def weak_residuals(U0, U1, U, w, kn, problem):
    "Return weak residuals"

    # Extract variables
    U_F0, P_F0, U_S0, P_S0, U_M0 = U0
    U_F1, P_F1, U_S1, P_S1, U_M1 = U1
    U_F, P_F, U_S, P_S, U_M = U
    v_F, q_F, v_S, q_S, v_M, q_M = w

    # Get problem parameters
    Omega = problem.mesh()
    rho_F = problem.fluid_density()
    mu_F = problem.fluid_viscosity()
    rho_S = problem.structure_density()
    mu_S = problem.structure_mu()
    lmbda_S = problem.structure_lmbda()
    alpha_M = problem.mesh_alpha()
    mu_M = problem.mesh_mu()
    lmbda_M = problem.mesh_lmbda()

    # Define normals
    N = FacetNormal(Omega)
    N_F = N
    N_S = -N

    # Define cell integrals
    dx_F = dx(0)
    dx_S = dx(1)

    # Define facet integrals
    dS_F = dS(0)
    dS_S = dS(1)
    d_FSI = dS(2)

    # Define time derivatives
    dt_U_F = (1 / kn) * (U_F1 - U_F0)
    dt_U_M = (1 / kn) * (U_M1 - U_M0)
    Dt_U_F = rho_F * J(U_M) * (dt_U_F +
                               dot(grad(U_F), dot(inv(F(U_M)), U_F - dt_U_M)))
    Dt_U_S = (1 / kn) * (U_S1 - U_S0)
    Dt_P_S = rho_S * (1 / kn) * (P_S1 - P_S0)
    Dt_U_M = alpha_M * (1 / kn) * (U_M1 - U_M0)

    # Define stresses
    Sigma_F = PiolaTransform(_Sigma_F(U_F, P_F, U_M, mu_F), U_M)
    Sigma_S = _Sigma_S(U_S, mu_S, lmbda_S)
    Sigma_M = _Sigma_M(U_M, mu_M, lmbda_M)

    # Fluid residual
    R_F = inner(v_F, Dt_U_F)*dx_F + inner(grad(v_F), Sigma_F)*dx_F \
        - inner(v_F, mu_F*J(U_M)*dot(dot(inv(F(U_M)).T, grad(U_F).T), dot(inv(F(U_M)).T, N_F)))*ds \
        + inner(v_F, J(U_M)*P_F*dot(I, dot(inv(F(U_M)).T, N_F)))*ds \
        + inner(q_F, div(J(U_M)*dot(inv(F(U_M)), U_F)))*dx_F

    # Structure residual
    R_S = inner(v_S, Dt_P_S)*dx_S + inner(grad(v_S), Sigma_S)*dx_S \
        - inner(v_S('-'), dot(Sigma_F('+'), N_S('+')))*d_FSI \
        + inner(q_S, Dt_U_S - P_S)*dx_S

    # Mesh residual contributions
    R_M = inner(v_M, Dt_U_M)*dx_F + inner(sym(grad(v_M)), Sigma_M)*dx_F \
        + inner(q_M, U_M - U_S)('+')*d_FSI

    return R_F, R_S, R_M
コード例 #8
0
ファイル: residuals.py プロジェクト: BijanZarif/CBC.Solve
def weak_residuals(U0, U1, U, w, kn, problem):
    "Return weak residuals"

    # Extract variables
    U_F0, P_F0, U_S0, P_S0, U_M0 = U0
    U_F1, P_F1, U_S1, P_S1, U_M1 = U1
    U_F,  P_F,  U_S,  P_S,  U_M  = U
    v_F, q_F, v_S, q_S, v_M, q_M = w

    # Get problem parameters
    Omega   = problem.mesh()
    rho_F   = problem.fluid_density()
    mu_F    = problem.fluid_viscosity()
    rho_S   = problem.structure_density()
    mu_S    = problem.structure_mu()
    lmbda_S = problem.structure_lmbda()
    alpha_M = problem.mesh_alpha()
    mu_M    = problem.mesh_mu()
    lmbda_M = problem.mesh_lmbda()

    # Define normals
    N = FacetNormal(Omega)
    N_F = N
    N_S = -N

    # Define cell integrals
    dx_F = dx(0)
    dx_S = dx(1)

    # Define facet integrals
    dS_F  = dS(0)
    dS_S  = dS(1)
    d_FSI = dS(2)

    # Define time derivatives
    dt_U_F = (1/kn) * (U_F1 - U_F0)
    dt_U_M = (1/kn) * (U_M1 - U_M0)
    Dt_U_F = rho_F * J(U_M) * (dt_U_F + dot(grad(U_F), dot(inv(F(U_M)), U_F - dt_U_M)))
    Dt_U_S = (1/kn) * (U_S1 - U_S0)
    Dt_P_S = rho_S * (1/kn) * (P_S1 - P_S0)
    Dt_U_M = alpha_M * (1/kn) * (U_M1 - U_M0)

    # Define stresses
    Sigma_F = PiolaTransform(_Sigma_F(U_F, P_F, U_M, mu_F), U_M)
    Sigma_S = _Sigma_S(U_S, mu_S, lmbda_S)
    Sigma_M = _Sigma_M(U_M, mu_M, lmbda_M)

    # Fluid residual
    R_F = inner(v_F, Dt_U_F)*dx_F + inner(grad(v_F), Sigma_F)*dx_F \
        - inner(v_F, mu_F*J(U_M)*dot(dot(inv(F(U_M)).T, grad(U_F).T), dot(inv(F(U_M)).T, N_F)))*ds \
        + inner(v_F, J(U_M)*P_F*dot(I, dot(inv(F(U_M)).T, N_F)))*ds \
        + inner(q_F, div(J(U_M)*dot(inv(F(U_M)), U_F)))*dx_F

    # Structure residual
    R_S = inner(v_S, Dt_P_S)*dx_S + inner(grad(v_S), Sigma_S)*dx_S \
        - inner(v_S('-'), dot(Sigma_F('+'), N_S('+')))*d_FSI \
        + inner(q_S, Dt_U_S - P_S)*dx_S

    # Mesh residual contributions
    R_M = inner(v_M, Dt_U_M)*dx_F + inner(sym(grad(v_M)), Sigma_M)*dx_F \
        + inner(q_M, U_M - U_S)('+')*d_FSI

    return R_F, R_S, R_M