Exemplo n.º 1
0
def goal_functional_solid(
    displacement_solid_array,
    velocity_solid_array,
    solid,
    solid_timeline,
    param,
):

    global_result = 0.0
    macrotimestep = solid_timeline.head
    global_size = solid_timeline.size
    m = 1
    for n in range(global_size):

        microtimestep = macrotimestep.head.after
        local_size = macrotimestep.size - 1
        for k in range(local_size):

            print(f"Current contribution: {m}")
            result = 0.0
            time_step = microtimestep.before.dt
            gauss_1, gauss_2 = gauss(microtimestep)
            result += (
                0.5 * time_step * param.ZETA *
                characteristic_function_solid(param) * dot(
                    grad(
                        linear_extrapolation(displacement_solid_array, m,
                                             gauss_1, microtimestep)),
                    grad(
                        linear_extrapolation(displacement_solid_array, m,
                                             gauss_1, microtimestep)),
                ) * solid.dx)
            result += (
                0.5 * time_step * param.ZETA *
                characteristic_function_solid(param) * dot(
                    grad(
                        linear_extrapolation(displacement_solid_array, m,
                                             gauss_2, microtimestep)),
                    grad(
                        linear_extrapolation(displacement_solid_array, m,
                                             gauss_2, microtimestep)),
                ) * solid.dx)

            m += 1
            microtimestep = microtimestep.after
            global_result += assemble(result)

        macrotimestep = macrotimestep.after

    return global_result
Exemplo n.º 2
0
def adjoint_residual_solid(
    displacement_solid,
    velocity_solid,
    displacement_solid_adjoint,
    velocity_solid_adjoint,
    displacement_fluid_adjoint,
    velocity_fluid_adjoint,
    solid: Space,
    solid_timeline: TimeLine,
    param: Parameters,
):
    residuals = []
    left = True
    macrotimestep = solid_timeline.head
    glocal_size = solid_timeline.size
    m = 1
    for n in range(glocal_size):

        microtimestep = macrotimestep.head.after
        local_size = macrotimestep.size - 1
        for k in range(local_size):

            print(f"Current contribution: {m}")
            lhs = 0.0
            rhs = 0.0
            time_step = microtimestep.before.dt
            gauss_1, gauss_2 = gauss(microtimestep)
            if left:

                l = m
                microtimestep_adjust = microtimestep
                left = False

            else:

                l = m - 1
                if microtimestep.before.before is None:

                    microtimestep_adjust = (
                        macrotimestep.microtimestep_before.after)

                else:

                    microtimestep_adjust = microtimestep.before
                left = True

            lhs += (0.5 * time_step * (
                (primal_derivative(velocity_solid, l, gauss_1,
                                   microtimestep_adjust) -
                 (velocity_solid[m] - velocity_solid[m - 1]) / time_step) *
                displacement_solid_adjoint[m]) * solid.dx)
            lhs += (0.5 * time_step * (
                (primal_derivative(velocity_solid, l, gauss_2,
                                   microtimestep_adjust) -
                 (velocity_solid[m] - velocity_solid[m - 1]) / time_step) *
                displacement_solid_adjoint[m]) * solid.dx)
            lhs += (0.5 * time_step *
                    ((primal_derivative(
                        displacement_solid,
                        l,
                        gauss_1,
                        microtimestep_adjust,
                    ) - (displacement_solid[m] - displacement_solid[m - 1]) /
                      time_step) * velocity_solid_adjoint[m]) * solid.dx)
            lhs += (0.5 * time_step *
                    ((primal_derivative(
                        displacement_solid,
                        l,
                        gauss_2,
                        microtimestep_adjust,
                    ) - (displacement_solid[m] - displacement_solid[m - 1]) /
                      time_step) * velocity_solid_adjoint[m]) * solid.dx)
            lhs += (0.5 * time_step * form_solid_adjoint(
                displacement_solid_adjoint[m],
                velocity_solid_adjoint[m],
                primal_reconstruction(displacement_solid, l, gauss_1,
                                      microtimestep_adjust) -
                linear_extrapolation(displacement_solid, m, gauss_1,
                                     microtimestep),
                primal_reconstruction(velocity_solid, l, gauss_1,
                                      microtimestep_adjust) -
                linear_extrapolation(velocity_solid, m, gauss_1,
                                     microtimestep),
                solid,
                param,
            ))
            lhs += (0.5 * time_step * form_solid_adjoint(
                displacement_solid_adjoint[m],
                velocity_solid_adjoint[m],
                primal_reconstruction(displacement_solid, l, gauss_2,
                                      microtimestep_adjust) -
                linear_extrapolation(displacement_solid, m, gauss_2,
                                     microtimestep),
                primal_reconstruction(velocity_solid, l, gauss_2,
                                      microtimestep_adjust) -
                linear_extrapolation(velocity_solid, m, gauss_2,
                                     microtimestep),
                solid,
                param,
            ))
            lhs -= (0.5 * time_step * param.GAMMA / solid.cell_size *
                    (primal_reconstruction(displacement_solid, l, gauss_1,
                                           microtimestep_adjust) -
                     linear_extrapolation(displacement_solid, m, gauss_1,
                                          microtimestep)) *
                    velocity_fluid_adjoint[m] * solid.ds(1))
            lhs -= (0.5 * time_step * param.GAMMA / solid.cell_size *
                    (primal_reconstruction(displacement_solid, l, gauss_2,
                                           microtimestep_adjust) -
                     linear_extrapolation(displacement_solid, m, gauss_2,
                                          microtimestep)) *
                    velocity_fluid_adjoint[m] * solid.ds(1))
            lhs -= (0.5 * time_step * param.GAMMA / solid.cell_size *
                    (primal_reconstruction(velocity_solid, l, gauss_1,
                                           microtimestep_adjust) -
                     linear_extrapolation(velocity_solid, m, gauss_1,
                                          microtimestep)) *
                    displacement_fluid_adjoint[m] * solid.ds(1))
            lhs -= (0.5 * time_step * param.GAMMA / solid.cell_size *
                    (primal_reconstruction(velocity_solid, l, gauss_2,
                                           microtimestep_adjust) -
                     linear_extrapolation(velocity_solid, m, gauss_2,
                                          microtimestep)) *
                    displacement_fluid_adjoint[m] * solid.ds(1))
            rhs += (0.5 * time_step * 2.0 * param.ZETA *
                    characteristic_function_solid(param) * dot(
                        grad(
                            linear_extrapolation(displacement_solid, m,
                                                 gauss_1, microtimestep)),
                        grad(
                            primal_reconstruction(
                                displacement_solid,
                                l,
                                gauss_1,
                                microtimestep_adjust,
                            ) - linear_extrapolation(displacement_solid, m,
                                                     gauss_1, microtimestep)),
                    ) * solid.dx)
            rhs += (0.5 * time_step * 2.0 * param.ZETA *
                    characteristic_function_solid(param) * dot(
                        grad(
                            linear_extrapolation(displacement_solid, m,
                                                 gauss_2, microtimestep)),
                        grad(
                            primal_reconstruction(
                                displacement_solid,
                                l,
                                gauss_2,
                                microtimestep_adjust,
                            ) - linear_extrapolation(displacement_solid, m,
                                                     gauss_2, microtimestep)),
                    ) * solid.dx)

            m += 1
            microtimestep = microtimestep.after
            residuals.append(assemble(0.5 * rhs - 0.5 * lhs))

        macrotimestep = macrotimestep.after

    return residuals
Exemplo n.º 3
0
def primal_residual_solid(
    displacement_solid_array,
    velocity_solid_array,
    displacement_fluid_array,
    velocity_fluid_array,
    displacement_solid_adjoint_array,
    velocity_solid_adjoint_array,
    solid: Space,
    solid_timeline: TimeLine,
    param: Parameters,
):

    residuals = []
    macrotimestep = solid_timeline.head
    global_size = solid_timeline.size
    m = 1
    for n in range(global_size):

        microtimestep = macrotimestep.head.after
        local_size = macrotimestep.size - 1
        for k in range(local_size):

            print(f"Current contribution: {m}")
            lhs = 0.0
            rhs = 0.0
            time_step = microtimestep.before.dt
            gauss_1, gauss_2 = gauss(microtimestep)
            lhs += (0.5 * time_step *
                    ((velocity_solid_array[m] - velocity_solid_array[m - 1]) /
                     time_step * (adjoint_reconstruction(
                         displacement_solid_adjoint_array,
                         m,
                         gauss_1,
                         microtimestep,
                         macrotimestep,
                     ) - displacement_solid_adjoint_array[m])) * solid.dx)
            lhs += (0.5 * time_step *
                    ((velocity_solid_array[m] - velocity_solid_array[m - 1]) /
                     time_step * (adjoint_reconstruction(
                         displacement_solid_adjoint_array,
                         m,
                         gauss_2,
                         microtimestep,
                         macrotimestep,
                     ) - displacement_solid_adjoint_array[m])) * solid.dx)
            lhs += (0.5 * time_step *
                    ((displacement_solid_array[m] -
                      displacement_solid_array[m - 1]) / time_step *
                     (adjoint_reconstruction(
                         velocity_solid_adjoint_array,
                         m,
                         gauss_1,
                         microtimestep,
                         macrotimestep,
                     ) - velocity_solid_adjoint_array[m])) * solid.dx)
            lhs += (0.5 * time_step *
                    ((displacement_solid_array[m] -
                      displacement_solid_array[m - 1]) / time_step *
                     (adjoint_reconstruction(
                         velocity_solid_adjoint_array,
                         m,
                         gauss_2,
                         microtimestep,
                         macrotimestep,
                     ) - velocity_solid_adjoint_array[m])) * solid.dx)
            lhs += (0.5 * time_step * form_solid(
                linear_extrapolation(displacement_solid_array, m, gauss_1,
                                     microtimestep),
                linear_extrapolation(velocity_solid_array, m, gauss_1,
                                     microtimestep),
                adjoint_reconstruction(
                    displacement_solid_adjoint_array,
                    m,
                    gauss_1,
                    microtimestep,
                    macrotimestep,
                ) - displacement_solid_adjoint_array[m],
                adjoint_reconstruction(
                    velocity_solid_adjoint_array,
                    m,
                    gauss_1,
                    microtimestep,
                    macrotimestep,
                ) - velocity_solid_adjoint_array[m],
                solid,
                param,
            ))
            lhs += (0.5 * time_step * form_solid(
                linear_extrapolation(displacement_solid_array, m, gauss_2,
                                     microtimestep),
                linear_extrapolation(velocity_solid_array, m, gauss_2,
                                     microtimestep),
                adjoint_reconstruction(
                    displacement_solid_adjoint_array,
                    m,
                    gauss_2,
                    microtimestep,
                    macrotimestep,
                ) - displacement_solid_adjoint_array[m],
                adjoint_reconstruction(
                    velocity_solid_adjoint_array,
                    m,
                    gauss_2,
                    microtimestep,
                    macrotimestep,
                ) - velocity_solid_adjoint_array[m],
                solid,
                param,
            ))
            lhs += (0.5 * time_step * param.NU * dot(
                grad(
                    linear_extrapolation(velocity_fluid_array, m, gauss_1,
                                         microtimestep)),
                solid.normal_vector,
            ) * (adjoint_reconstruction(
                displacement_solid_adjoint_array,
                m,
                gauss_1,
                microtimestep,
                macrotimestep,
            ) - displacement_solid_adjoint_array[m]) * solid.ds(1))
            lhs += (0.5 * time_step * param.NU * dot(
                grad(
                    linear_extrapolation(velocity_fluid_array, m, gauss_2,
                                         microtimestep)),
                solid.normal_vector,
            ) * (adjoint_reconstruction(
                displacement_solid_adjoint_array,
                m,
                gauss_2,
                microtimestep,
                macrotimestep,
            ) - displacement_solid_adjoint_array[m]) * solid.ds(1))

            m += 1
            microtimestep = microtimestep.after
            residuals.append(assemble(0.5 * rhs - 0.5 * lhs))

        macrotimestep = macrotimestep.after

    return residuals