Von-Mises Plasticity for 2D plates

[PrashanthSudeendran]

Hi Members,

I am doing a small project in von-mises plasticity for 2D plates.
One of the sample is dumbbell shaped and other is a square plate with a circular hole in middle.
I am unable to proceed on with simulation and it always shows an error.
The error goes like

MethodError: no method matching generate_grid(::Type{Quadrilateral}, ::Tuple{Int64, Int64}, ::Tuple{Float64, Float64}, ::Tuple{Float64, Float64}, ::Tuple{Float64, Float64}, ::Tuple{Float64, Float64})
Closest candidates are:
generate_grid(::Type{Quadrilateral}, ::Tuple{Int64, Int64}, ::Vec{2, T}, ::Vec{2, T}, ::Vec{2, T}, ::Vec{2, T}) where T at C:\Users\prash.julia\packages\Ferrite\Ck78N\src\Grid\grid_generators.jl:120
generate_grid(::Type{Cell{2, M, N}}, ::Tuple{Int64, Int64}) where {M, N} at C:\Users\prash.julia\packages\Ferrite\Ck78N\src\Grid\grid_generators.jl:111
generate_grid(::Type{Cell{2, M, N}}, ::Tuple{Int64, Int64}, ::Array{Vec{2, T}, 1}) where {M, N, T} at C:\Users\prash.julia\packages\Ferrite\Ck78N\src\Grid\grid_generators.jl:106
...

Stacktrace:
[1] solve()
@ Main .\In[25]:22
[2] top-level scope
@ In[26]:1
[3] eval
@ .\boot.jl:368 [inlined]
[4] include_string(mapexpr::typeof(REPL.softscope), mod::Module, code::String, filename::String)
@ Base .\loading.jl:1428

this is the error I am getting
and the code i used in that section is:

function solve()
# Define material parameters
E = 200.0e9 # [Pa]
H = E/20 # [Pa]
ν = 0.3 # [-]
σ₀ = 200e6 # [Pa]
material = J2Plasticity(E, ν, σ₀, H)

L = 10.0 # beam length [m]
w = 10.0  # beam width [m]
n_timesteps = 10
u_max = zeros(n_timesteps)
traction_magnitude = 1.e7 * range(0.5, 1.0, length=n_timesteps)

# Create geometry, dofs and boundary conditions
n = 2
nels = (10n, 10n) # number of elements in each spatial direction
P1 = (0.0, 0.0)  # start point for geometry
P2 = (0.0, 4.0)
P3 = (3.0, 4.0)
P4 = (3.0, 0.0)  # end point for geometry
grid = generate_grid(Quadrilateral, nels, P1, P2, P3, P4)
interpolation = Lagrange{2, RefCube, 1}() # Linear tet with 2 unknowns/node

dh = create_dofhandler(grid, interpolation) # JuaFEM helper function
dbcs = create_bc(dh, grid) # create Dirichlet boundary-conditions

cellvalues, facevalues = create_values(interpolation)

# Pre-allocate solution vectors, etc.
n_dofs = ndofs(dh)  # total number of dofs
u  = zeros(n_dofs)  # solution vector
Δu = zeros(n_dofs)  # displacement correction
r = zeros(n_dofs)   # residual
K = create_sparsity_pattern(dh); # tangent stiffness matrix

# Create material states. One array for each cell, where each element is an array of material-
# states - one for each integration point
nqp = getnquadpoints(cellvalues)
states = [MaterialState() for _ in 1:nqp, _ in 1:getncells(grid)]
states_old = [MaterialState() for _ in 1:nqp, _ in 1:getncells(grid)]

# Newton-Raphson loop
NEWTON_TOL = 1 # 1 N
print("\n Starting Netwon iterations:\n")

for timestep in 1:n_timesteps
    t = timestep # actual time (used for evaluating d-bndc)
    traction = Vec((0.0, traction_magnitude[timestep]))
    newton_itr = -1
    print("\n Time step @time = $timestep:\n")
    update!(dbcs, t) # evaluates the D-bndc at time t
    apply!(u, dbcs)  # set the prescribed values in the solution vector

    while true; newton_itr += 1

        if newton_itr > 8
            error("Reached maximum Newton iterations, aborting")
            break
        end
        K, r = doassemble(cellvalues, facevalues, K, grid, dh, material, u,
                         states, states_old, traction);
        norm_r = norm(r[Ferrite.free_dofs(dbcs)])

        print("Iteration: $newton_itr \tresidual: $(@sprintf("%.8f", norm_r))\n")
        if norm_r < NEWTON_TOL
            break
        end

        apply_zero!(K, r, dbcs)
        Δu = Symmetric(K) \ r
        u -= Δu
    end

    # Update the old states with the converged values for next timestep
    states_old .= states

    u_max[timestep] = maximum(abs.(u)) # maximum displacement in current timestep
end

# ## Postprocessing
# Only a vtu-file corrsponding to the last time-step is exported.
#
# The following is a quick (and dirty) way of extracting average cell data for export.
mises_values = zeros(getncells(grid))
κ_values = zeros(getncells(grid))
for (el, cell_states) in enumerate(eachcol(states))
    for state in cell_states
        mises_values[el] += vonMises(state.σ)
        κ_values[el] += state.k*material.H
    end
    mises_values[el] /= length(cell_states) # average von Mises stress
    κ_values[el] /= length(cell_states)     # average drag stress
end
vtk_grid("plasticity", dh) do vtkfile
    vtk_point_data(vtkfile, dh, u) # displacement field
    vtk_cell_data(vtkfile, mises_values, "von Mises [Pa]")
    vtk_cell_data(vtkfile, κ_values, "Drag stress [Pa]")
end

return u_max, traction_magnitude

end

it would be of great help if one could tell me how to correct this.

[koehlerson]

The error you see currently is trying to tell you that there is no method in generating the grid as you tried. One possible solution to this is e.g.

julia> grid = generate_grid(Quadrilateral, nels, [Vec{2}(P1), Vec{2}(P2), Vec{2}(P3), Vec{2}(P4)])