mirror of
https://github.com/JuliaFEM/JuliaFEM.jl.git
synced 2026-09-19 17:58:53 +00:00
2d mortar
This commit is contained in:
Jukka Aho
@@ -34,6 +34,7 @@ export @debug, set_debug_on!, set_debug_off!
|
||||
|
||||
using ForwardDiff
|
||||
autodiffcache = ForwardDiffCache()
|
||||
export derivative, jacobian, hessian
|
||||
|
||||
""" Simple linspace extension to arrays.
|
||||
|
||||
@@ -60,6 +61,7 @@ include("types.jl") # type definitions
|
||||
include("elements.jl")
|
||||
include("lagrange.jl") # Lagrange elements
|
||||
#include("hierarchical.jl") # P-elements
|
||||
include("mortar_elements.jl") # Mortar elements
|
||||
|
||||
### EQUATIONS ###
|
||||
include("integrate.jl") # default integration points for elements
|
||||
@@ -69,6 +71,7 @@ include("problems.jl")
|
||||
|
||||
### FORMULATIION ###
|
||||
include("dirichlet.jl")
|
||||
include("mortar.jl") # mortar projection
|
||||
include("heat.jl")
|
||||
include("elasticity.jl")
|
||||
|
||||
|
||||
+28
-20
@@ -15,7 +15,7 @@ type DirichletProblem <: BoundaryProblem
|
||||
unknown_field_name :: ASCIIString
|
||||
unknown_field_dimension :: Int
|
||||
equations :: Vector{DirichletEquation}
|
||||
element_mapping :: Dict{Element, Equation}
|
||||
# element_mapping :: Dict{DataType, DataType}
|
||||
field_value :: Function
|
||||
end
|
||||
|
||||
@@ -36,14 +36,15 @@ Create u(X) = 0.0 boundary condition for three-dimensional elasticity problem:
|
||||
>>> u(X) = [0.0, 0.0, 0.0]
|
||||
>>> bc = DirichletProblem(3, u)
|
||||
"""
|
||||
function DirichletProblem(dimension::Int=1, field_value::Function=(X)->[0.0,0.0,0.0])
|
||||
element_mapping = nothing
|
||||
if dimension == 1
|
||||
element_mapping = Dict(
|
||||
Seg2 => DBC2D2
|
||||
)
|
||||
end
|
||||
DirichletProblem("reaction force", dimension, [], element_mapping, field_value)
|
||||
function DirichletProblem(dimension::Int=1, field_value::Function=(X)->[0.0,0.0,0.0], equations=[])
|
||||
# element_mapping = nothing
|
||||
# if dimension == 1
|
||||
# element_mapping = Dict(
|
||||
# Seg2 => DBC2D2
|
||||
# )
|
||||
# end
|
||||
DirichletProblem("reaction force", dimension, equations, field_value)
|
||||
# DirichletProblem("reaction force", dimension, [], element_mapping, field_value)
|
||||
end
|
||||
|
||||
""" Dirichlet boundary condition element for 2 node line segment """
|
||||
@@ -51,17 +52,22 @@ type DBC2D2 <: DirichletEquation
|
||||
element :: Seg2
|
||||
integration_points :: Vector{IntegrationPoint}
|
||||
end
|
||||
function DBC2D2(element::Seg2)
|
||||
integration_points = default_integration_points(element)
|
||||
if !haskey(element, "reaction force")
|
||||
element["reaction force"] = zeros(1, 2)
|
||||
end
|
||||
|
||||
function Base.size(equation::DBC2D2)
|
||||
return (1, 2)
|
||||
end
|
||||
|
||||
#function DBC2D2(element::Seg2)
|
||||
function Base.convert(::Type{DirichletEquation}, element::Seg2)
|
||||
integration_points = line3()
|
||||
haskey(element, "reaction force") || (element["reaction force"] = zeros(1, 2))
|
||||
DBC2D2(element, integration_points)
|
||||
end
|
||||
Base.size(equation::DBC2D2) = (1, 2)
|
||||
|
||||
|
||||
function assemble!(assembly::Assembly, equation::DirichletEquation, time::Number=0.0, problem=nothing)
|
||||
gdofs = get_gdofs(equation)
|
||||
# info("gdofs = $gdofs")
|
||||
element = get_element(equation)
|
||||
basis = get_basis(element)
|
||||
detJ = det(basis)
|
||||
@@ -69,11 +75,13 @@ function assemble!(assembly::Assembly, equation::DirichletEquation, time::Number
|
||||
w = ip.weight * detJ(ip)
|
||||
N = basis(ip, time)
|
||||
add!(assembly.stiffness_matrix, gdofs, gdofs, w*N'*N)
|
||||
if !isa(problem, Void)
|
||||
X = basis("geometry", ip, time)
|
||||
u = problem.field_value(X)
|
||||
add!(assembly.force_vector, gdofs, w*N'*u)
|
||||
end
|
||||
# info("added $(w*N'*N)")
|
||||
# if !isa(problem, Void)
|
||||
# X = basis("geometry", ip, time)
|
||||
# u = problem.field_value(X)[1:length(gdofs)]
|
||||
# add!(assembly.force_vector, gdofs, w*N'*u)
|
||||
# end
|
||||
end
|
||||
# info("assembly done")
|
||||
end
|
||||
|
||||
|
||||
+50
-20
@@ -19,8 +19,7 @@ Saint Venant-Kirchhoff material model, which is simply
|
||||
|
||||
S(E) = λtr(E) + 2μE
|
||||
"""
|
||||
function get_internal_energy(equation::Equation, ip::IntegrationPoint,
|
||||
time::Number, F::Matrix)
|
||||
function get_internal_energy(equation::ElasticityEquation, ip::IntegrationPoint, time::Number, F::Matrix)
|
||||
element = get_element(equation)
|
||||
basis = get_basis(element)
|
||||
dbasis = grad(basis)
|
||||
@@ -72,8 +71,7 @@ https://en.wikipedia.org/wiki/Plane_stress
|
||||
https://en.wikipedia.org/wiki/Hooke's_law
|
||||
|
||||
"""
|
||||
function get_residual_vector(equation::ElasticityEquation, ip::IntegrationPoint,
|
||||
time::Number; variation=nothing)
|
||||
function get_residual_vector(equation::ElasticityEquation, ip::IntegrationPoint, time::Number; variation=nothing)
|
||||
|
||||
element = get_element(equation)
|
||||
basis = get_basis(element)
|
||||
@@ -82,9 +80,10 @@ function get_residual_vector(equation::ElasticityEquation, ip::IntegrationPoint,
|
||||
u = basis("displacement", ip, time, variation)
|
||||
gradu = dbasis("displacement", ip, time, variation)
|
||||
F = I + gradu # deformation gradient
|
||||
|
||||
#info("Deformation gradient: $F")
|
||||
# residual vector - internal energy
|
||||
r = get_internal_energy(equation, ip, time, F)
|
||||
#info("boundary element")
|
||||
|
||||
# external forces - volume load
|
||||
if haskey(element, "displacement load")
|
||||
@@ -94,40 +93,71 @@ function get_residual_vector(equation::ElasticityEquation, ip::IntegrationPoint,
|
||||
|
||||
return vec(r)
|
||||
end
|
||||
has_residual_vector(equation::ElasticityEquation) = true
|
||||
|
||||
### Problem 1 - plane elasticity ###
|
||||
### Plane stress elasticity ###
|
||||
|
||||
abstract PlaneElasticityProblem <: ElasticityProblem
|
||||
abstract PlaneStressElasticityEquation <: ElasticityEquation
|
||||
|
||||
type PlaneStressElasticityProblem <: PlaneElasticityProblem
|
||||
unknown_field_name :: ASCIIString
|
||||
unknown_field_dimension :: Int
|
||||
equations :: Array{ElasticityEquation, 1}
|
||||
element_mapping :: Dict{DataType, DataType}
|
||||
equations :: Vector{PlaneStressElasticityEquation}
|
||||
end
|
||||
|
||||
function PlaneStressElasticityProblem(equations=[])
|
||||
element_mapping = Dict(
|
||||
Quad4 => CPS4)
|
||||
return PlaneStressElasticityProblem("displacement", 2, equations, element_mapping)
|
||||
return PlaneStressElasticityProblem("displacement", 2, equations)
|
||||
end
|
||||
|
||||
### Equations ###
|
||||
|
||||
abstract PlaneElasticityEquation <: ElasticityEquation
|
||||
abstract PlaneStressElasticityEquation <: PlaneElasticityEquation
|
||||
|
||||
""" 4-node plane stress element. """
|
||||
type CPS4 <: PlaneStressElasticityEquation
|
||||
element :: Quad4
|
||||
integration_points :: Array{IntegrationPoint, 1}
|
||||
end
|
||||
function CPS4(element::Quad4)
|
||||
|
||||
function Base.size(equation::CPS4)
|
||||
return (2, 4)
|
||||
end
|
||||
|
||||
function Base.convert(::Type{PlaneStressElasticityEquation}, element::Quad4)
|
||||
integration_points = get_default_integration_points(element)
|
||||
if !haskey(element, "displacement")
|
||||
element["displacement"] = zeros(2, 4)
|
||||
end
|
||||
haskey(element, "displacement") || (element["displacement"] = zeros(2, 4))
|
||||
CPS4(element, integration_points)
|
||||
end
|
||||
Base.size(equation::CPS4) = (2, 4)
|
||||
|
||||
""" Boundary element for plane stress problem for surface loads. """
|
||||
type CPS2 <: PlaneStressElasticityEquation
|
||||
element :: Seg2
|
||||
integration_points :: Vector{IntegrationPoint}
|
||||
end
|
||||
|
||||
function Base.size(equation::CPS2)
|
||||
return (2, 2)
|
||||
end
|
||||
|
||||
function Base.convert(::Type{PlaneStressElasticityEquation}, element::Seg2)
|
||||
integration_points = get_default_integration_points(element)
|
||||
haskey(element, "displacement") || (element["displacement"] = zeros(2, 2))
|
||||
CPS2(element, integration_points)
|
||||
end
|
||||
|
||||
function get_residual_vector(equation::CPS2, ip::IntegrationPoint, time::Number; variation=nothing)
|
||||
|
||||
element = get_element(equation)
|
||||
basis = get_basis(element)
|
||||
|
||||
u = basis("displacement", ip, time, variation)
|
||||
r = zeros(size(equation))
|
||||
|
||||
if haskey(element, "displacement traction force")
|
||||
T = basis("displacement traction force", ip, time)
|
||||
# info("traction force = $T")
|
||||
# info("basis = $(basis(ip, time))")
|
||||
r -= T*basis(ip, time)
|
||||
end
|
||||
|
||||
return vec(r)
|
||||
end
|
||||
|
||||
|
||||
@@ -97,6 +97,12 @@ function get_gdofs(equation::Equation)
|
||||
return gdofs
|
||||
end
|
||||
|
||||
function get_gdofs(element::Element, dim::Int)
|
||||
conn = get_connectivity(element)
|
||||
gdofs = vec(vcat([dim*conn'-i for i=dim-1:-1:0]...))
|
||||
return gdofs
|
||||
end
|
||||
|
||||
""" Assemble element. """
|
||||
function assemble!(assembly::Assembly, equation::Equation, time::Number=0.0, problem=nothing)
|
||||
|
||||
|
||||
+22
-22
@@ -72,46 +72,46 @@ end
|
||||
""" Diffusive heat transfer for 4-node bilinear element. """
|
||||
type DC2D4 <: HeatEquation
|
||||
element :: Quad4
|
||||
integration_points :: Array{IntegrationPoint, 1}
|
||||
integration_points :: Vector{IntegrationPoint}
|
||||
end
|
||||
function DC2D4(element::Quad4)
|
||||
integration_points = get_default_integration_points(element)
|
||||
if !haskey(element, "temperature")
|
||||
element["temperature"] = zeros(4)
|
||||
end
|
||||
DC2D4(element, integration_points)
|
||||
|
||||
function Base.size(equation::DC2D4)
|
||||
return (1, 4)
|
||||
end
|
||||
Base.size(equation::DC2D4) = (1, 4)
|
||||
|
||||
""" Diffusive heat transfer for 2-node linear segment. """
|
||||
type DC2D2 <: HeatEquation
|
||||
element :: Seg2
|
||||
integration_points :: Vector{IntegrationPoint}
|
||||
end
|
||||
function DC2D2(element::Seg2)
|
||||
|
||||
function Base.size(equation::DC2D2)
|
||||
return (1, 2)
|
||||
end
|
||||
|
||||
# Conversions element -> equation
|
||||
|
||||
function Base.convert(::Type{HeatEquation}, element::Quad4)
|
||||
integration_points = get_default_integration_points(element)
|
||||
if !haskey(element, "temperature")
|
||||
element["temperature"] = zeros(2)
|
||||
end
|
||||
haskey(element, "temperature") || (element["temperature"] = zeros(4))
|
||||
DC2D4(element, integration_points)
|
||||
end
|
||||
|
||||
function Base.convert(::Type{HeatEquation}, element::Seg2)
|
||||
integration_points = get_default_integration_points(element)
|
||||
haskey(element, "temperature") || (element["temperature"] = zeros(2))
|
||||
DC2D2(element, integration_points)
|
||||
end
|
||||
Base.size(equation::DC2D2) = (1, 2)
|
||||
|
||||
### Problems ###
|
||||
|
||||
type PlaneHeatProblem <: HeatProblem
|
||||
unknown_field_name :: ASCIIString
|
||||
unknown_field_dimension :: Int
|
||||
equations :: Vector{Equation}
|
||||
#element_mapping :: Dict{Element, Equation}
|
||||
# FIXME: Why is not working ^
|
||||
element_mapping :: Dict{Any, Any}
|
||||
equations :: Vector{HeatEquation}
|
||||
end
|
||||
|
||||
""" Default constructor for problem takes no arguments. """
|
||||
function PlaneHeatProblem()
|
||||
element_mapping = Dict(
|
||||
Quad4 => DC2D4,
|
||||
Seg2 => DC2D2)
|
||||
return PlaneHeatProblem("temperature", 1, [], element_mapping)
|
||||
function PlaneHeatProblem(equations=[])
|
||||
return PlaneHeatProblem("temperature", 1, equations)
|
||||
end
|
||||
|
||||
+24
-26
@@ -11,12 +11,20 @@ function get_default_integration_points(element::Quad4)
|
||||
]
|
||||
end
|
||||
|
||||
function get_default_integration_points(element::Seg2)
|
||||
|
||||
function line1()
|
||||
[
|
||||
IntegrationPoint([0.0], 2.0)
|
||||
]
|
||||
end
|
||||
|
||||
function line2()
|
||||
[
|
||||
IntegrationPoint([-sqrt(1/3)], 1)
|
||||
IntegrationPoint([+sqrt(1/3)], 1)
|
||||
]
|
||||
end
|
||||
|
||||
function line3()
|
||||
[
|
||||
IntegrationPoint([0.0], 8/9),
|
||||
@@ -25,6 +33,15 @@ function line3()
|
||||
]
|
||||
end
|
||||
|
||||
function line4()
|
||||
[
|
||||
IntegrationPoint([+sqrt(3/7 - 2/7*sqrt(6/5))], (18+sqrt(30))/36)
|
||||
IntegrationPoint([-sqrt(3/7 - 2/7*sqrt(6/5))], (18+sqrt(30))/36)
|
||||
IntegrationPoint([+sqrt(3/7 + 2/7*sqrt(6/5))], (18-sqrt(30))/36)
|
||||
IntegrationPoint([-sqrt(3/7 + 2/7*sqrt(6/5))], (18-sqrt(30))/36)
|
||||
]
|
||||
end
|
||||
|
||||
function line5()
|
||||
[
|
||||
IntegrationPoint([-1/3*sqrt(5 + 2*sqrt(10/7))], (322-13*sqrt(70))/900),
|
||||
@@ -35,29 +52,10 @@ function line5()
|
||||
]
|
||||
end
|
||||
|
||||
#integration_points = [
|
||||
# IntegrationPoint([ 0.0000000000000000], 0.5688888888888889),
|
||||
# IntegrationPoint([-0.5384693101056831], 0.4786286704993665),
|
||||
# IntegrationPoint([ 0.5384693101056831], 0.4786286704993665),
|
||||
# IntegrationPoint([-0.9061798459386640], 0.2369268850561891),
|
||||
# IntegrationPoint([ 0.9061798459386640], 0.2369268850561891)
|
||||
#]
|
||||
#integration_points = [
|
||||
# IntegrationPoint([+sqrt(3/7 - 2/7*sqrt(6/5))], (18+sqrt(30))/36)
|
||||
# IntegrationPoint([-sqrt(3/7 - 2/7*sqrt(6/5))], (18+sqrt(30))/36)
|
||||
# IntegrationPoint([+sqrt(3/7 + 2/7*sqrt(6/5))], (18-sqrt(30))/36)
|
||||
# IntegrationPoint([-sqrt(3/7 + 2/7*sqrt(6/5))], (18-sqrt(30))/36)
|
||||
#]
|
||||
#integration_points = [
|
||||
# IntegrationPoint([0.0], 8/9),
|
||||
# IntegrationPoint([-sqrt(3/5)], 5/9),
|
||||
# IntegrationPoint([+sqrt(3/5)], 5/9)
|
||||
#]
|
||||
#integration_points = [
|
||||
# IntegrationPoint([-sqrt(1/3)], 1)
|
||||
# IntegrationPoint([+sqrt(1/3)], 1)
|
||||
#]
|
||||
#integration_points = [
|
||||
# IntegrationPoint([0.0], 2)
|
||||
#]
|
||||
function get_default_integration_points(element::Seg2)
|
||||
return line1()
|
||||
end
|
||||
|
||||
function get_default_integration_points(element::MSeg2)
|
||||
return line3()
|
||||
end
|
||||
|
||||
+58
-50
@@ -1,78 +1,86 @@
|
||||
# This file is a part of JuliaFEM.
|
||||
# License is MIT: see https://github.com/JuliaFEM/JuliaFEM.jl/blob/master/LICENSE.md
|
||||
|
||||
# Mortar projection integration
|
||||
# Mortar equations
|
||||
|
||||
abstract MortarEquation <: Equation
|
||||
|
||||
function get_unknown_field_name(equation::MortarEquation)
|
||||
return "reaction force"
|
||||
end
|
||||
|
||||
""" Mortar boundary condition element for 2-dimensional problem, 2 node line segment. """
|
||||
type MBC2D2 <: MortarEquation
|
||||
element :: MSeg2
|
||||
integration_points :: Vector{IntegrationPoint}
|
||||
end
|
||||
|
||||
function Base.size(equation::MBC2D2)
|
||||
return (1, 2)
|
||||
end
|
||||
|
||||
function Base.convert(::Type{MortarEquation}, element::MSeg2)
|
||||
return MBC2D2(element, get_default_integration_points(element))
|
||||
end
|
||||
|
||||
# Mortar problem
|
||||
|
||||
"""
|
||||
Parameters
|
||||
----------
|
||||
node_csys
|
||||
coordinate system in node, normal + tangent + "binormal"
|
||||
element_pairs
|
||||
m x s matrix of boolean values, indicating elements sharing
|
||||
common surface. s is number of slave elements and m is number
|
||||
of master elements.
|
||||
in 3d 3x3 matrix, in 2d 2x2 matrix, respectively
|
||||
"""
|
||||
type MortarProblem <: BoundaryProblem
|
||||
unknown_field_name :: ASCIIString
|
||||
unknown_field_dimension :: Int
|
||||
equations :: Vector{MortarEquation}
|
||||
element_mapping :: Dict{Element, MortarEquation}
|
||||
master_elements :: Vector{Element} # mortar surface
|
||||
node_csys :: Dict{Int, Matrix{Float64}}
|
||||
element_pairs :: Matrix{Bool}
|
||||
end
|
||||
|
||||
function MortarProblem(dimension::Int=1, equations=[], master_elements=[])
|
||||
element_mapping = Dict(
|
||||
Seg2 => MBC2D2,
|
||||
)
|
||||
MortarProblem("reaction force", dimension, equations, element_mapping, master_elements, Dict(), zeros(0,0))
|
||||
function MortarProblem(dimension::Int=1, equations=[])
|
||||
MortarProblem("reaction force", dimension, equations)
|
||||
end
|
||||
|
||||
""" Mortar boundary condition element for 2-dimensional problem, 2 node line segment. """
|
||||
type MBC2D2 <: MortarEquation
|
||||
element :: Seg2 # == non-mortar surface element
|
||||
integration_points :: Vector{IntegrationPoint}
|
||||
end
|
||||
function MBC2D2(element::Seg2)
|
||||
integration_points = default_integration_points(element)
|
||||
if !haskey(element, "reaction force")
|
||||
element["reaction force"] = zeros(1, 2)
|
||||
end
|
||||
MBC2D2(element, integration_points)
|
||||
end
|
||||
Base.size(equation::MBC2D2) = (1, 2)
|
||||
# Mortar projection calculation
|
||||
|
||||
function find_master_elements(slave_element, problem)
|
||||
# find slave element "position" in element pairs matrix
|
||||
all_elements = map((equation) -> get_element(equation), problem.equations)
|
||||
seid = findfirst(slave_element, all_elements)
|
||||
info("slave element id = $seid")
|
||||
# find master element "positions" in element pairs matrix
|
||||
meids = find(problem.element_pairs[:, seid])
|
||||
info("master element ids = $meids")
|
||||
# master elements
|
||||
master_elements = problem.master_elements[meids]
|
||||
return master_elements
|
||||
""" Find master or "mortar" elements for this slave element. """
|
||||
function get_master_elements(element::MortarElement)
|
||||
return element.master_elements
|
||||
end
|
||||
|
||||
function calculate_local_assembly!(assembly::LocalAssembly, equation::MortarEquation, unknown_field_name::ASCIIString, time::Number=0.0, problem=nothing)
|
||||
# slave element = non-mortar element where integration happens
|
||||
# master element = mortar element projected to non-mortar side
|
||||
isa(problem, Void) && error("Cannot create projection without problem")
|
||||
initialize_local_assembly!(assembly, equation)
|
||||
function assemble!(assembly::Assembly, equation::MortarEquation, time::Number=0.0, problem=nothing)
|
||||
slave_element = get_element(equation)
|
||||
basis = get_basis(slave_element)
|
||||
detJ = det(basis)
|
||||
master_elements = find_master_elements(equation, problem)
|
||||
master_elements = get_master_elements(slave_element)
|
||||
slave_basis = get_basis(slave_element)
|
||||
detJ = det(slave_basis)
|
||||
dim = size(equation, 1) # number of nodes
|
||||
slave_dofs = get_gdofs(slave_element, dim)
|
||||
for master_element in master_elements
|
||||
for ip in get_integration_points(slave_element)
|
||||
mortar_basis = 0 # ...
|
||||
assembly.stiffness_matrix += w*basis'*basis
|
||||
assembly.force_vector += w*N'*gn
|
||||
master_dofs = get_gdofs(master_element, dim)
|
||||
xi1a = project_from_master_to_slave(slave_element, master_element, [-1.0])
|
||||
xi1b = project_from_master_to_slave(slave_element, master_element, [ 1.0])
|
||||
xi1 = clamp([xi1a xi1b], -1.0, 1.0)
|
||||
l = 1/2*(xi1[2]-xi1[1])
|
||||
if abs(l) < 1.0e-6
|
||||
warn("No contribution")
|
||||
continue # no contribution
|
||||
end
|
||||
master_basis = get_basis(master_element)
|
||||
for ip in get_integration_points(equation)
|
||||
w = ip.weight*detJ(ip)*l
|
||||
|
||||
# integration point on slave side segment
|
||||
xi_gauss = 1/2*(1-ip.xi)*xi1[1] + 1/2*(1+ip.xi)*xi1[2]
|
||||
# projected integration point
|
||||
xi_projected = project_from_slave_to_master(slave_element, master_element, xi_gauss)
|
||||
|
||||
# add contribution to left hand side
|
||||
N1 = slave_basis(xi_gauss, time)
|
||||
N2 = master_basis(xi_projected, time)
|
||||
add!(assembly.lhs, slave_dofs, slave_dofs, w*N1'*N1)
|
||||
add!(assembly.lhs, slave_dofs, master_dofs, -w*N1'*N2)
|
||||
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
@@ -0,0 +1,84 @@
|
||||
# This file is a part of JuliaFEM.
|
||||
# License is MIT: see https://github.com/JuliaFEM/JuliaFEM.jl/blob/master/LICENSE.md
|
||||
|
||||
# Mortar elements
|
||||
|
||||
# slave element = non-mortar element where integration happens
|
||||
# master element = mortar element projected to non-mortar side
|
||||
|
||||
abstract MortarElement <: Element
|
||||
|
||||
type MSeg2 <: MortarElement
|
||||
connectivity :: Vector{Int}
|
||||
basis :: Basis
|
||||
fields :: FieldSet
|
||||
master_elements :: Vector{MortarElement}
|
||||
end
|
||||
|
||||
function MSeg2(connectivity, master_elements=[], biorthogonal=false)
|
||||
basis(xi) = [(1-xi[1])/2 (1+xi[1])/2]
|
||||
dbasisdxi(xi) = [-1/2 1/2]
|
||||
return MSeg2(connectivity, Basis(basis, dbasisdxi), FieldSet(), master_elements)
|
||||
end
|
||||
|
||||
""" Find projection from slave nodes to master element, i.e. find xi2 from
|
||||
master element corresponding to the xi1.
|
||||
"""
|
||||
function project_from_slave_to_master(slave::MortarElement, master::MortarElement, xi1::Vector, time::Float64=0.0; max_iterations=5, tol=1.0e-9)
|
||||
slave_basis = get_basis(slave)
|
||||
master_basis = get_basis(master)
|
||||
|
||||
# slave side geometry and normal direction at xi1
|
||||
X1 = slave_basis("geometry", xi1, time)
|
||||
N1 = slave_basis("nodal ntsys", xi1, time)[:,1]
|
||||
|
||||
# master side geometry at xi2
|
||||
X2(xi2) = master_basis("geometry", [xi2], time)
|
||||
# dX2(xi2) = dmaster_basis("geometry", xi2, time)
|
||||
|
||||
# equation to solve
|
||||
R(xi2) = det([X2(xi2)-X1 N1]')
|
||||
# dR(xi2) = det([dX2(xi2) N1]')
|
||||
dR = ForwardDiff.derivative(R)
|
||||
|
||||
# go!
|
||||
xi2 = 0.0
|
||||
for i=1:max_iterations
|
||||
dxi2 = -R(xi2) / dR(xi2)
|
||||
xi2 += dxi2
|
||||
if norm(dxi2) < tol
|
||||
return Float64[xi2]
|
||||
end
|
||||
end
|
||||
error("find projection from slave to master: did not converge")
|
||||
end
|
||||
|
||||
""" Find projection from master surface to slave point, i.e. find xi1 from slave element corresponding to the xi2. """
|
||||
function project_from_master_to_slave(slave::MortarElement, master::MortarElement, xi2::Vector, time::Float64=0.0; max_iterations=5, tol=1.0e-9)
|
||||
slave_basis = get_basis(slave)
|
||||
master_basis = get_basis(master)
|
||||
|
||||
# slave side geometry and normal direction at xi1
|
||||
X1(xi1) = slave_basis("geometry", [xi1], time)
|
||||
N1(xi1) = slave_basis("nodal ntsys", [xi1], time)[:,1]
|
||||
|
||||
# master side geometry at xi2
|
||||
X2 = master_basis("geometry", xi2, time)
|
||||
|
||||
# equation to solve
|
||||
R(xi1) = det([X1(xi1)-X2 N1(xi1)]')
|
||||
# dR(xi1) = det([dX1(xi1) N1(xi1)]') + det([X1(xi1)-X2 dN1(xi1)]')
|
||||
dR = ForwardDiff.derivative(R)
|
||||
|
||||
# go!
|
||||
xi1 = 0.0
|
||||
for i=1:max_iterations
|
||||
dxi1 = -R(xi1) / dR(xi1)
|
||||
xi1 += dxi1
|
||||
if norm(dxi1) < tol
|
||||
return Float64[xi1]
|
||||
end
|
||||
end
|
||||
error("find projection from master to slave: did not converge")
|
||||
end
|
||||
|
||||
+5
-4
@@ -33,10 +33,11 @@ Notes
|
||||
Equation is automatically created during process based on problem
|
||||
element -> equation mapping and element type.
|
||||
"""
|
||||
function Base.push!(problem::Problem, element::Element)
|
||||
element_type = typeof(element)
|
||||
equation_type = problem.element_mapping[element_type]
|
||||
push!(problem.equations, equation_type(element))
|
||||
function Base.push!(problem::Problem, element::Element, args...)
|
||||
# element_type = typeof(element)
|
||||
# equation_type = problem.element_mapping[element_type]
|
||||
# push!(problem.equations, equation_type(element, args...))
|
||||
push!(problem.equations, element)
|
||||
end
|
||||
|
||||
"""
|
||||
|
||||
+22
-21
@@ -111,25 +111,26 @@ common situation, i.e., some main field problem and it's Dirichlet boundary.
|
||||
Cu = g
|
||||
|
||||
"""
|
||||
function call(solver::SimpleSolver, time::Number=Inf)
|
||||
p1, p2 = get_problems(solver)
|
||||
function call(solver::SimpleSolver, time::Number=0.0)
|
||||
problem1, problem2 = get_problems(solver)
|
||||
|
||||
ga1 = initialize_global_assembly(p1)
|
||||
calculate_global_assembly!(ga1, p1)
|
||||
ga2 = initialize_global_assembly(p2)
|
||||
calculate_global_assembly!(ga2, p2)
|
||||
assembly1 = Assembly()
|
||||
assemble!(assembly1, problem1, time)
|
||||
assembly2 = Assembly()
|
||||
assemble!(assembly2, problem2, time)
|
||||
|
||||
A1 = ga1.stiffness_matrix
|
||||
b1 = ga1.force_vector
|
||||
A2 = ga2.stiffness_matrix
|
||||
b2 = ga2.force_vector
|
||||
# info("Creating sparse matrices")
|
||||
A1 = sparse(assembly1.stiffness_matrix)
|
||||
b1 = sparse(assembly1.force_vector, size(A1, 1), 1)
|
||||
A2 = sparse(assembly2.stiffness_matrix)
|
||||
b2 = sparse(assembly2.force_vector, size(A2, 1), 1)
|
||||
|
||||
# create a saddle point problem
|
||||
A = [A1 A2; A2' zeros(A2)]
|
||||
b = [b1; b2]
|
||||
|
||||
# solve problem
|
||||
nz = unique(rowvals(A)) # here we remove any zero rows
|
||||
nz = unique(rowvals(A)) # take only non-zero rows
|
||||
x = zeros(b)
|
||||
x[nz] = lufact(A[nz,nz]) \ full(b[nz])
|
||||
|
||||
@@ -138,23 +139,23 @@ function call(solver::SimpleSolver, time::Number=Inf)
|
||||
x2 = x[length(b1)+1:end]
|
||||
|
||||
# update field for elements in problem 1
|
||||
for equation in get_equations(p1)
|
||||
for equation in get_equations(problem1)
|
||||
element = get_element(equation)
|
||||
field_name = get_unknown_field_name(p1)
|
||||
gdofs = get_gdofs(p1, equation)
|
||||
field_name = get_unknown_field_name(problem1)
|
||||
gdofs = get_gdofs(problem1, equation)
|
||||
element_solution = full(x1[gdofs])
|
||||
field = Field(time, element_solution)
|
||||
push!(element[field_name], field)
|
||||
field = Increment(element_solution)
|
||||
push!(element[field_name], TimeStep(time, field))
|
||||
end
|
||||
|
||||
# update field for elements in problem 2 (Dirichlet boundary)
|
||||
for equation in get_equations(p2)
|
||||
for equation in get_equations(problem2)
|
||||
element = get_element(equation)
|
||||
field_name = get_unknown_field_name(p2)
|
||||
gdofs = get_gdofs(p2, equation)
|
||||
field_name = get_unknown_field_name(problem2)
|
||||
gdofs = get_gdofs(problem2, equation)
|
||||
element_solution = full(x2[gdofs])
|
||||
field = Field(time, element_solution)
|
||||
push!(element[field_name], field)
|
||||
field = Increment(element_solution)
|
||||
push!(element[field_name], TimeStep(time, field))
|
||||
end
|
||||
end
|
||||
|
||||
|
||||
+3
-3
@@ -14,8 +14,8 @@ function SparseMatrixIJV()
|
||||
SparseMatrixIJV([], [], [])
|
||||
end
|
||||
|
||||
function Base.sparse(A::SparseMatrixIJV)
|
||||
return sparse(A.I, A.J, A.V)
|
||||
function Base.sparse(A::SparseMatrixIJV, args...)
|
||||
return sparse(A.I, A.J, A.V, args...)
|
||||
end
|
||||
|
||||
function Base.push!(A::SparseMatrixIJV, I::Int, J::Int, V::Float64)
|
||||
@@ -37,7 +37,7 @@ function Base.append!(A::SparseMatrixIJV, I::Vector{Int}, J::Vector{Int}, V::Vec
|
||||
end
|
||||
|
||||
function Base.full(A::SparseMatrixIJV, args...)
|
||||
return full(sparse(A.I, A.J, A.V), args...)
|
||||
return full(sparse(A.I, A.J, A.V, args...))
|
||||
end
|
||||
|
||||
""" Add local element matrix to sparse matrix. This basically does:
|
||||
|
||||
+25
-5
@@ -4,27 +4,47 @@
|
||||
module ElasticityTests
|
||||
|
||||
using JuliaFEM.Test
|
||||
using JuliaFEM: Quad4, Field, FieldSet, CPS4,
|
||||
using JuliaFEM: Seg2, Quad4, Field, FieldSet, CPS4,
|
||||
get_basis, solve!,
|
||||
PlaneStressElasticityProblem
|
||||
|
||||
|
||||
function test_elasticity_one_element()
|
||||
function test_elasticity_volume_load()
|
||||
element = Quad4([1, 2, 3, 4])
|
||||
element["geometry"] = Vector[[0.0, 0.0], [10.0, 0.0], [10.0, 1.0], [0.0, 1.0]]
|
||||
element["youngs modulus"] = 500.0
|
||||
element["poissons ratio"] = 0.3
|
||||
element["displacement load"] = Vector[[0.0, -10.0], [0.0, -10.0], [0.0, -10.0], [0.0, -10.0]]
|
||||
equation = CPS4(element)
|
||||
free_dofs = [3, 4, 5, 6]
|
||||
problem = PlaneStressElasticityProblem([equation])
|
||||
problem = PlaneStressElasticityProblem()
|
||||
push!(problem, element)
|
||||
solve!(problem, free_dofs; max_iterations=10)
|
||||
#solve!(equation, "displacement", free_dofs; max_iterations=10)
|
||||
disp = get_basis(element)("displacement", [1.0, 1.0])[2]
|
||||
info("displacement at tip: $disp")
|
||||
# verified using Code Aster.
|
||||
@test isapprox(disp, -8.77303119819776)
|
||||
end
|
||||
|
||||
function test_elasticity_surface_load()
|
||||
N = Vector[[0.0, 0.0], [10.0, 0.0], [10.0, 1.0], [0.0, 1.0]]
|
||||
|
||||
element1 = Quad4([1, 2, 3, 4])
|
||||
element1["geometry"] = Vector[N[1], N[2], N[3], N[4]]
|
||||
element1["youngs modulus"] = 500.0
|
||||
element1["poissons ratio"] = 0.3
|
||||
element2 = Seg2([3, 4])
|
||||
element2["geometry"] = Vector[N[3], N[4]]
|
||||
element2["displacement traction force"] = Vector[[0.0, -10.0], [0.0, -10.0]]
|
||||
|
||||
free_dofs = [3, 4, 5, 6]
|
||||
problem = PlaneStressElasticityProblem()
|
||||
push!(problem, element1)
|
||||
push!(problem, element2)
|
||||
solve!(problem, free_dofs; max_iterations=10)
|
||||
disp = get_basis(element1)("displacement", [1.0, 1.0])[2]
|
||||
info("displacement at tip: $disp")
|
||||
# verified using Code Aster.
|
||||
@test isapprox(disp, -9.33106637611714)
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
+4
-2
@@ -6,6 +6,8 @@
|
||||
module HeatTests # always wrap tests to module ending with "Tests"
|
||||
|
||||
using JuliaFEM.Test # always use JuliaFEM.Test, not Base.Test
|
||||
|
||||
using JuliaFEM: HeatEquation
|
||||
using JuliaFEM: Seg2, Quad4, DC2D4, DC2D2, Assembly, assemble!
|
||||
|
||||
function test_one_element() # always start test function with name test_
|
||||
@@ -25,7 +27,7 @@ function test_one_element() # always start test function with name test_
|
||||
|
||||
# Set constant source f=12 with k=6. Accurate solution is
|
||||
# T=1 on free boundary, u(x,y) = -1/6*(1/2*f*x^2 - f*x)
|
||||
equation = DC2D4(element)
|
||||
equation = convert(HeatEquation, element)
|
||||
#la = initialize_local_assembly()
|
||||
#calculate_local_assembly!(la, equation, "temperature")
|
||||
assembly = Assembly()
|
||||
@@ -37,7 +39,7 @@ function test_one_element() # always start test function with name test_
|
||||
|
||||
# Set constant flux g=6 on boundary. Accurate solution is
|
||||
# u(x,y) = x which equals T=1 on boundary.
|
||||
boundary_equation = DC2D2(boundary_element)
|
||||
boundary_equation = convert(HeatEquation, boundary_element)
|
||||
empty!(assembly)
|
||||
|
||||
time = 1.0
|
||||
|
||||
+77
-42
@@ -6,78 +6,113 @@ module MortarTests
|
||||
using JuliaFEM
|
||||
using JuliaFEM.Test
|
||||
|
||||
function test_calc_flat_2d_assembly()
|
||||
# this is hand calculated and given example in my thesis
|
||||
using JuliaFEM: MSeg2, Seg2, MortarProblem, MortarEquation, MortarElement, Assembly, assemble!
|
||||
using JuliaFEM: get_basis, grad, project_from_slave_to_master, project_from_master_to_slave
|
||||
|
||||
function get_test_2d_model()
|
||||
# this is hand calculated and given as an example in my thesis
|
||||
N = Vector[
|
||||
[0.0, 2.0], [1.0, 2.0], [2.0, 2.0],
|
||||
[0.0, 0.0], [1.0, 0.0], [2.0, 0.0],
|
||||
[0.0, 1.0], [5/4, 1.0], [2.0, 1.0],
|
||||
[0.0, 1.0], [3/4, 1.0], [2.0, 1.0]]
|
||||
rotation_matrix(phi) = [cos(phi) -sin(phi); sin(phi) cos(phi)]
|
||||
slave1 = MSeg2([10, 11])
|
||||
slave1["geometry"] = Vector[N[10], N[11]]
|
||||
# should be n = [0 -1]' and t = [1 0]'
|
||||
slave1["nodal ntsys"] = Matrix[rotation_matrix(-pi/2), rotation_matrix(-pi/2)]
|
||||
slave2 = MSeg2([11, 12])
|
||||
slave2["geometry"] = Vector[N[11], N[12]]
|
||||
# should be n = [0 -1]' and t = [1 0]'
|
||||
slave2["nodal ntsys"] = Matrix[rotation_matrix(-pi/2), rotation_matrix(-pi/2)]
|
||||
master1 = MSeg2([7, 8])
|
||||
master1["geometry"] = Vector[N[7], N[8]]
|
||||
master2 = MSeg2([8, 9])
|
||||
master2["geometry"] = Vector[N[8], N[9]]
|
||||
push!(slave1.master_elements, master1)
|
||||
push!(slave1.master_elements, master2)
|
||||
push!(slave2.master_elements, master1)
|
||||
push!(slave2.master_elements, master2)
|
||||
return [slave1, slave2], [master1, master2]
|
||||
end
|
||||
|
||||
slave1 = Seg2([10, 11])
|
||||
slave1["geometry"] = Vector[N10, N11]
|
||||
|
||||
slave2 = Seg2([11, 12])
|
||||
slave2["geometry"] = Vector[N11, N12]
|
||||
function test_calc_flat_2d_projection()
|
||||
slaves, masters = get_test_2d_model()
|
||||
slave1, slave2 = slaves
|
||||
master1, master2 = masters
|
||||
|
||||
master1 = Seg2([7, 8])
|
||||
master1["geometry"] = Vector[N7, N8]
|
||||
xi2a = project_from_slave_to_master(slave1, master1, [-1.0])
|
||||
@test xi2a == [-1.0]
|
||||
|
||||
master2 = Seg2([8, 9])
|
||||
master2["geometry"] = Vector[N8, N9]
|
||||
xi2b = project_from_slave_to_master(slave1, master1, [1.0])
|
||||
@test xi2b == [ 0.2]
|
||||
X2 = get_basis(master1)("geometry", xi2b)
|
||||
@test X2 == [3/4, 1.0]
|
||||
|
||||
xi1a = project_from_master_to_slave(slave1, master1, [-1.0])
|
||||
@test xi1a == [-1.0]
|
||||
xi1b = project_from_master_to_slave(slave1, master1, [1.0])
|
||||
X1 = get_basis(slave1)("geometry", xi1b)
|
||||
@test X1 == [5/4, 1.0]
|
||||
end
|
||||
|
||||
function test_create_flat_2d_assembly()
|
||||
slaves, masters = get_test_2d_model()
|
||||
slave1, slave2 = slaves
|
||||
master1, master2 = masters
|
||||
|
||||
info("creating problem")
|
||||
problem = MortarProblem()
|
||||
info("pushing slave elements to problem")
|
||||
push!(problem, slave1)
|
||||
push!(problem, slave2)
|
||||
push!(problem.master_elements, master1)
|
||||
push!(problem.master_elements, master2)
|
||||
|
||||
rotation_matrix(phi) = [cos(phi) -sin(phi); sin(phi) cos(phi)]
|
||||
# should be n = [0 -1]' and t = [1 0]'
|
||||
@test isapprox(rotation_matrix(-phi/2), [[0 -1]' [1 0]'])
|
||||
|
||||
problem.node_csys = Dict(
|
||||
10 => rotation_matrix(-phi/2),
|
||||
11 => rotation_matrix(-phi/2),
|
||||
12 => rotation_matrix(-phi/2))
|
||||
|
||||
# first index = master element id
|
||||
# second index = slave element id
|
||||
problem.element_pairs = zeros(2, 2)
|
||||
# first slave element connects to master element 1
|
||||
problem.element_pairs[1, 1] = true
|
||||
# second slave element connects to master element 1
|
||||
problem.element_pairs[1, 2] = true
|
||||
# second slave element connects to master element 2
|
||||
problem.element_pairs[2, 2] = true
|
||||
|
||||
B_expected = zeros(12, 9)
|
||||
|
||||
B_expected = zeros(12, 12)
|
||||
S1 = [10, 11]
|
||||
M1 = [7, 8]
|
||||
B_expected[S1,S1] += [1/4 1/8; 1/8 1/4]
|
||||
B_expected[S1,M1] += [3/10 3/40; 9/40 3/20]
|
||||
B_expected[S1,M1] -= [3/10 3/40; 9/40 3/20]
|
||||
|
||||
la = initialize_local_assembly(problem)
|
||||
calculate_local_assembly!(la, problem.equations[1], "reaction force", 0.0, problem=problem)
|
||||
B = full(la.lhs)
|
||||
info("creating assembly")
|
||||
assembly = Assembly()
|
||||
assemble!(assembly, problem.equations[1], 0.0, problem)
|
||||
B = round(full(assembly.lhs, 12, 12), 6)
|
||||
info("size of B = $(size(B))")
|
||||
info("B matrix in first slave element = \n$(B[10:11,:])")
|
||||
info("B matrix expected = \n$(B_expected[10:11,:])")
|
||||
@test isapprox(B, B_expected)
|
||||
|
||||
fill!(B_expected, 0.0)
|
||||
empty!(assembly)
|
||||
|
||||
S2 = [11, 12]
|
||||
M2 = [7, 8]
|
||||
B_expected[S2,S2] += [49/150 11/150; 11/150 2/75]
|
||||
B_expected[S2,M2] += [13/150 47/150; 1/75 13/150]
|
||||
B_expected[S2,M2] -= [13/150 47/150; 1/75 13/150]
|
||||
S3 = [11, 12]
|
||||
M3 = [8, 9]
|
||||
B_expected[S3,S3] += [9/100 27/200; 27/200 39/100]
|
||||
B_expected[S3,M3] += [3/20 3/40; 9/40 3/10]
|
||||
B_expected[S3,M3] -= [3/20 3/40; 9/40 3/10]
|
||||
assemble!(assembly, problem.equations[2], 0.0, problem)
|
||||
B = full(assembly.lhs)
|
||||
info("size of B = $(size(B))")
|
||||
info("B matrix in second slave element = \n$(B[11:12,:])")
|
||||
info("B matrix expected = \n$(B_expected[11:12,:])")
|
||||
|
||||
la = initialize_local_assembly(problem)
|
||||
calculate_local_assembly!(la, problem.equations[1], "reaction force", 0.0, problem=problem)
|
||||
B = full(la.lhs)
|
||||
@test isapprox(B, B_expected)
|
||||
end
|
||||
|
||||
function test_patch_test_heat_2d()
|
||||
|
||||
|
||||
|
||||
slaves, masters = get_test_2d_model()
|
||||
problem2 = MortarProblem()
|
||||
for slave in slaves:
|
||||
push!(problem2, slave)
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
+17
-18
@@ -1,9 +1,11 @@
|
||||
# This file is a part of JuliaFEM.
|
||||
# License is MIT: see https://github.com/JuliaFEM/JuliaFEM.jl/blob/master/LICENSE.md
|
||||
|
||||
# test SimpleSolver
|
||||
module SolverTests
|
||||
|
||||
using JuliaFEM.Test
|
||||
using JuliaFEM
|
||||
|
||||
using FactCheck
|
||||
using JuliaFEM: DirichletProblem, Seg2, PlaneHeatProblem, Quad4, SimpleSolver, get_element, get_basis
|
||||
|
||||
""" Define Problem 1:
|
||||
@@ -13,25 +15,16 @@ using JuliaFEM: DirichletProblem, Seg2, PlaneHeatProblem, Quad4, SimpleSolver, g
|
||||
"""
|
||||
function get_heatproblem()
|
||||
el1 = Quad4([1, 2, 3, 4])
|
||||
# these might look like normal values but believe me, they
|
||||
# are fields with temporal and spatial dimension
|
||||
el1["geometry"] = Vector[[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]]
|
||||
el1["temperature thermal conductivity"] = 6.0
|
||||
el1["density"] = 36.0
|
||||
|
||||
el2 = Seg2([1, 2])
|
||||
el2["geometry"] = Vector[[0.0, 0.0], [1.0, 0.0]]
|
||||
# Boundary load, linear ramp 0 -> 600 at time 0 -> 1
|
||||
# yet another simplification, if field is given as a tuple,
|
||||
# multiple fields are created. there is 1 second time step between
|
||||
# each field. So the following is basically same as
|
||||
# fieldset = FieldSet("temperature flux")
|
||||
# field1 = Field(0.0, 0.0)
|
||||
# field2 = Field(1.0, 600.0)
|
||||
# push!(fieldset, field1)
|
||||
# push!(fieldset, field2)
|
||||
# element["temperature flux"] = fieldset
|
||||
el2["temperature flux"] = (0.0, 600.0)
|
||||
el2["temperature flux"] = (
|
||||
(0.0 => 0.0),
|
||||
(1.0 => 600.0)
|
||||
)
|
||||
|
||||
problem1 = PlaneHeatProblem()
|
||||
push!(problem1, el1)
|
||||
@@ -50,13 +43,17 @@ function get_boundaryproblem()
|
||||
return problem2
|
||||
end
|
||||
|
||||
facts("test simplesolver") do
|
||||
function test_simplesolver()
|
||||
info("construct heat problem")
|
||||
problem1 = get_heatproblem()
|
||||
info("construct boundary problem")
|
||||
problem2 = get_boundaryproblem()
|
||||
# Create a solver for a set of problems
|
||||
info("create SimpleSolver with problems.")
|
||||
solver = SimpleSolver()
|
||||
push!(solver, problem1)
|
||||
push!(solver, problem2)
|
||||
info("solve!")
|
||||
# Solve problem at time t=1.0 and update fields
|
||||
call(solver, 1.0)
|
||||
# Postprocess.
|
||||
@@ -66,6 +63,8 @@ facts("test simplesolver") do
|
||||
basis = get_basis(el2)
|
||||
X = basis("geometry", xi, 1.0)
|
||||
T = basis("temperature", xi, 1.0)
|
||||
Logging.info("Temperature at point X = $X is T = $T")
|
||||
@fact T --> roughly(100.0)
|
||||
info("Temperature at point X = $X is T = $T")
|
||||
@test isapprox(mean(T), 100.0)
|
||||
end
|
||||
|
||||
end
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
DEBUT()
|
||||
|
||||
MAIL = LIRE_MAILLAGE()
|
||||
|
||||
MO = AFFE_MODELE(MAILLAGE = MAIL,
|
||||
AFFE = _F(MAILLE=('E1', 'E2'), PHENOMENE='MECANIQUE', MODELISATION='C_PLAN'))
|
||||
|
||||
MAT = DEFI_MATERIAU(ELAS = _F(E=500.0, NU=0.3))
|
||||
|
||||
CHMAT = AFFE_MATERIAU(
|
||||
MAILLAGE = MAIL,
|
||||
AFFE = _F(MAILLE='E1', MATER=MAT))
|
||||
|
||||
BC = AFFE_CHAR_MECA(
|
||||
MODELE = MO,
|
||||
DDL_IMPO = (_F(NOEUD = ('N1','N4'), DX=0, DY=0)))
|
||||
|
||||
LO = AFFE_CHAR_MECA(
|
||||
MODELE = MO,
|
||||
FORCE_CONTOUR = _F(MAILLE='E2', FY=-10.0))
|
||||
|
||||
LIST = DEFI_LIST_REEL(
|
||||
DEBUT = 0,
|
||||
INTERVALLE = _F(JUSQU_A=1.0, NOMBRE=1))
|
||||
|
||||
STEP = DEFI_FONCTION(
|
||||
NOM_PARA='INST',
|
||||
VALE=(0,0,1,1))
|
||||
|
||||
RESU = STAT_NON_LINE(
|
||||
MODELE=MO,
|
||||
CHAM_MATER=CHMAT,
|
||||
EXCIT=(
|
||||
_F(CHARGE=BC),
|
||||
_F(CHARGE=LO, FONC_MULT=STEP)),
|
||||
NEWTON=_F(REAC_INCR=1, MATRICE='TANGENTE', REAC_ITER=1),
|
||||
COMP_ELAS=_F(DEFORMATION='GROT_GDEP'),
|
||||
INCREMENT=_F(LIST_INST=LIST),
|
||||
CONVERGENCE=_F(RESI_GLOB_RELA=1.0E-12))
|
||||
|
||||
RESU = CALC_CHAMP(
|
||||
reuse=RESU,
|
||||
RESULTAT=RESU,
|
||||
MODELE=MO,
|
||||
DEFORMATION=('EPSI_ELNO', 'EPSG_ELNO', 'EPSI_ELGA', 'EPSG_ELGA'),
|
||||
ENERGIE=('ENEL_ELEM', 'ENEL_NOEU', 'ETOT_ELEM', 'ETOT_NOEU'),
|
||||
FORCE=('FORC_NODA'),
|
||||
CONTRAINTE='SIGM_ELNO')
|
||||
|
||||
IMPR_RESU(
|
||||
MODELE = MO,
|
||||
FORMAT = 'RESULTAT',
|
||||
RESU = _F(RESULTAT = RESU))
|
||||
|
||||
FIN()
|
||||
@@ -0,0 +1,17 @@
|
||||
|
||||
COOR_2D
|
||||
N1 0.0 0.0
|
||||
N2 10.0 0.0
|
||||
N3 10.0 1.0
|
||||
N4 0.0 1.0
|
||||
FINSF
|
||||
|
||||
QUAD4
|
||||
E1 N1 N2 N3 N4
|
||||
FINSF
|
||||
|
||||
SEG2
|
||||
E2 N3 N4
|
||||
FINSF
|
||||
|
||||
FIN
|
||||
@@ -0,0 +1,343 @@
|
||||
|
||||
|
||||
-- CODE_ASTER -- VERSION : EXPLOITATION (stable) --
|
||||
|
||||
Version 11.4.0 du 05/06/2013
|
||||
Copyright EDF R&D 1991 - 2015
|
||||
|
||||
Exécution du : Tue Nov 17 23:07:16 2015
|
||||
Nom de la machine : jukka-desktop
|
||||
Architecture : 64bit
|
||||
Type de processeur : x86_64
|
||||
Système d'exploitation : Linux 3.13.0-68-generic
|
||||
Langue des messages : en (UTF-8)
|
||||
|
||||
|
||||
!------------------------------------------------------------------------------------!
|
||||
! <A> <SUPERVIS2_2> !
|
||||
! !
|
||||
! Vous utilisez une vieille version de Code_Aster. !
|
||||
! !
|
||||
! En mettant à jour votre version, vous bénéficierez des dernières améliorations !
|
||||
! apportées au code depuis 15 mois. !
|
||||
! Si vous avez des développements privés, vous risquez d'avoir un travail !
|
||||
! important de portage si vous ne suivez pas les mises à jour. !
|
||||
! !
|
||||
! !
|
||||
! Ceci est une alarme. Si vous ne comprenez pas le sens de cette !
|
||||
! alarme, vous pouvez obtenir des résultats inattendus ! !
|
||||
!------------------------------------------------------------------------------------!
|
||||
|
||||
Parallélisme MPI : inactif
|
||||
Parallélisme OpenMP : actif
|
||||
Nombre de processus utilisés : 1
|
||||
Version de la librairie HDF5 : 1.8.8
|
||||
Version de la librairie MED : 3.0.6
|
||||
Librairie MUMPS : installée
|
||||
Version de la librairie SCOTCH : 5.1.10
|
||||
Mémoire limite pour l'exécution : 4096.00 Mo
|
||||
consommée par l'initialisation : 197.46 Mo
|
||||
par les objets du jeu de commandes : 1.52 Mo
|
||||
reste pour l'allocation dynamique : 3897.01 Mo
|
||||
Taille limite des fichiers d'échange : 48.00 Go
|
||||
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
ASTER 11.04.00 CONCEPT RESU CALCULE LE 17/11/2015 A 23:07:16 DE TYPE EVOL_NOLI
|
||||
|
||||
|
||||
======>
|
||||
|
||||
------>
|
||||
CHAMP AUX NOEUDS DE NOM SYMBOLIQUE DEPL
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
NOEUD DX DY
|
||||
N1 0.00000000000000E+00 0.00000000000000E+00
|
||||
N2 0.00000000000000E+00 0.00000000000000E+00
|
||||
N3 0.00000000000000E+00 0.00000000000000E+00
|
||||
N4 0.00000000000000E+00 0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX POINTS DE GAUSS DE NOM SYMBOLIQUE EPSI_ELGA
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
E1 EPXX EPYY EPZZ EPXY
|
||||
1 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
2 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
3 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
4 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX NOEUDS DE NOM SYMBOLIQUE EPSI_ELNO
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
E1 EPXX EPYY EPZZ EPXY
|
||||
N1 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
N2 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
N3 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
N4 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX POINTS DE GAUSS DE NOM SYMBOLIQUE SIEF_ELGA
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
E1 SIXX SIYY SIZZ SIXY
|
||||
1 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
2 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
3 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
4 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX NOEUDS DE NOM SYMBOLIQUE SIGM_ELNO
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
E1 SIXX SIYY SIZZ SIXY
|
||||
N1 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
N2 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
N3 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
N4 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CHAMP AUX NOEUDS DE NOM SYMBOLIQUE FORC_NODA
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
NOEUD DX DY
|
||||
N1 0.00000000000000E+00 0.00000000000000E+00
|
||||
N2 0.00000000000000E+00 0.00000000000000E+00
|
||||
N3 0.00000000000000E+00 0.00000000000000E+00
|
||||
N4 0.00000000000000E+00 0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX POINTS DE GAUSS DE NOM SYMBOLIQUE EPSG_ELGA
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
E1 EPXX EPYY EPZZ EPXY
|
||||
1 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
2 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
3 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
4 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX NOEUDS DE NOM SYMBOLIQUE EPSG_ELNO
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
E1 EPXX EPYY EPZZ EPXY
|
||||
N1 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
N2 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
N3 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
N4 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00 0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX POINTS DE GAUSS DE NOM SYMBOLIQUE VARI_ELGA
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
E1 VARI
|
||||
1 0.00000000000000E+00
|
||||
2 0.00000000000000E+00
|
||||
3 0.00000000000000E+00
|
||||
4 0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CARTE DE NOM SYMBOLIQUE COMPORTEMENT
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
|
||||
------>
|
||||
CHAMP AUX NOEUDS DE NOM SYMBOLIQUE ENEL_NOEU
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
NOEUD TOTALE
|
||||
N1 0.00000000000000E+00
|
||||
N2 0.00000000000000E+00
|
||||
N3 0.00000000000000E+00
|
||||
N4 0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT CONSTANT SUR L'ELEMENT DE NOM SYMBOLIQUE ENEL_ELEM
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
E1 TOTALE
|
||||
0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT CONSTANT SUR L'ELEMENT DE NOM SYMBOLIQUE ETOT_ELEM
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
E1 TOTALE
|
||||
0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CHAMP AUX NOEUDS DE NOM SYMBOLIQUE ETOT_NOEU
|
||||
NUMERO D'ORDRE: 0 INST: 0.00000000000000E+00
|
||||
NOEUD TOTALE
|
||||
N1 0.00000000000000E+00
|
||||
N2 0.00000000000000E+00
|
||||
N3 0.00000000000000E+00
|
||||
N4 0.00000000000000E+00
|
||||
|
||||
|
||||
======>
|
||||
|
||||
------>
|
||||
CHAMP AUX NOEUDS DE NOM SYMBOLIQUE DEPL
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
NOEUD DX DY
|
||||
N1 -3.40638811414010E-24 2.68833699079734E-24
|
||||
N2 -5.55894020548543E+00 -8.54389686386317E+00
|
||||
N3 -4.37883078409381E+00 -9.33106637611714E+00
|
||||
N4 8.27180612553028E-25 -4.13590306276514E-25
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX POINTS DE GAUSS DE NOM SYMBOLIQUE EPSI_ELGA
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
E1 EPXX EPYY EPZZ EPXY
|
||||
1 -5.30955374084645E-01 -1.66348491228137E-01 2.98844513705478E-01 -3.10819035435077E-01
|
||||
2 -5.30955374084645E-01 -6.20821021025835E-01 4.93618455047349E-01 2.98492106217561E-02
|
||||
3 -4.62821724873279E-01 -6.20821021025835E-01 4.64418319671049E-01 7.12558413187114E-03
|
||||
4 -4.62821724873279E-01 -1.66348491228137E-01 2.69644378329178E-01 -3.33542661924962E-01
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX NOEUDS DE NOM SYMBOLIQUE EPSI_ELNO
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
E1 EPXX EPYY EPZZ EPXY
|
||||
N1 -5.55894020548543E-01 -8.32667268468867E-17 2.38240294520804E-01 -4.27194843193159E-01
|
||||
N2 -5.55894020548543E-01 -7.87169512253972E-01 5.75598656915364E-01 1.62859867502652E-01
|
||||
N3 -4.37883078409381E-01 -7.87169512253972E-01 5.25022538855723E-01 1.23501391889953E-01
|
||||
N4 -4.37883078409381E-01 -1.11022302462516E-16 1.87664176461163E-01 -4.66553318805857E-01
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX POINTS DE GAUSS DE NOM SYMBOLIQUE SIEF_ELGA
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
E1 SIXX SIYY SIZZ SIXY
|
||||
1 -5.82089453243221E+01 1.60368493608182E+02 0.00000000000000E+00 -3.74379334332994E+01
|
||||
2 1.77623597984452E+01 -1.73298174480217E+01 -2.25162844728429E-16 -1.06236006134150E+01
|
||||
3 5.00553053519043E+01 1.15939930155404E+01 3.26087178768177E-15 -3.13335482197459E+01
|
||||
4 -4.55341108580102E+01 2.29485076835540E+02 0.00000000000000E+00 -6.60541739958280E+01
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX NOEUDS DE NOM SYMBOLIQUE SIGM_ELNO
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
E1 SIXX SIYY SIZZ SIXY
|
||||
N1 -8.80273558499339E+01 1.94727353878533E+02 5.49455403429594E-16 -3.57191470178472E+01
|
||||
N2 3.11214204850306E+01 -8.75739524062778E+01 -2.05059548209250E-15 5.71225091278676E+00
|
||||
N3 9.94918269646633E+01 -6.29576400186074E+01 6.19745101666236E-15 -2.51460416790004E+01
|
||||
N4 -7.85112826317427E+01 3.39921984557592E+02 -1.66060199504612E-15 -9.02963184782274E+01
|
||||
|
||||
|
||||
------>
|
||||
CHAMP AUX NOEUDS DE NOM SYMBOLIQUE FORC_NODA
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
NOEUD DX DY
|
||||
N1 2.68987859445506E+02 -1.67866148841036E+02
|
||||
N2 -4.12787428844766E+00 4.17093399587432E+00
|
||||
N3 5.15024681990101E+00 -5.26887741319058E+01
|
||||
N4 -2.70010231976960E+02 2.16383988977067E+02
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX POINTS DE GAUSS DE NOM SYMBOLIQUE EPSG_ELGA
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
E1 EPXX EPYY EPZZ EPXY
|
||||
1 -1.06566987205140E-02 -1.21415776588635E-01 5.66024894182066E-02 -3.04578768594778E-01
|
||||
2 -1.06566987205140E-02 5.01096016113645E-03 2.41960223973324E-03 5.31382035225386E-02
|
||||
3 6.42405191820819E-02 5.01096016113645E-03 -2.96792054328079E-02 7.62286577556890E-02
|
||||
4 6.42405191820819E-02 -1.21415776588635E-01 2.45036817456655E-02 -3.15026549152951E-01
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX NOEUDS DE NOM SYMBOLIQUE EPSG_ELNO
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
E1 EPXX EPYY EPZZ EPXY
|
||||
N1 -3.80709831456427E-02 -1.67691173956619E-01 8.81837816152549E-02 -4.27194843193159E-01
|
||||
N2 -3.80709831456428E-02 5.12863575291203E-02 -5.66373187863325E-03 1.71126738384121E-01
|
||||
N3 9.16548036072106E-02 5.12863575291203E-02 -6.12604976298561E-02 2.32382967145393E-01
|
||||
N4 9.16548036072106E-02 -1.67691173956619E-01 3.25870158640320E-02 -4.66553318805857E-01
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT AUX POINTS DE GAUSS DE NOM SYMBOLIQUE VARI_ELGA
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
E1 VARI
|
||||
1 0.00000000000000E+00
|
||||
2 0.00000000000000E+00
|
||||
3 0.00000000000000E+00
|
||||
4 0.00000000000000E+00
|
||||
|
||||
|
||||
------>
|
||||
CARTE DE NOM SYMBOLIQUE COMPORTEMENT
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
|
||||
------>
|
||||
CHAMP AUX NOEUDS DE NOM SYMBOLIQUE ENEL_NOEU
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
NOEUD TOTALE
|
||||
N1 3.54914783015860E+01
|
||||
N2 -9.86342721345517E+00
|
||||
N3 -2.25443717206190E+01
|
||||
N4 1.13556696866632E+02
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT CONSTANT SUR L'ELEMENT DE NOM SYMBOLIQUE ENEL_ELEM
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
E1 TOTALE
|
||||
2.91600940585360E+02
|
||||
|
||||
|
||||
------>
|
||||
CHAMP PAR ELEMENT CONSTANT SUR L'ELEMENT DE NOM SYMBOLIQUE ETOT_ELEM
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
E1 TOTALE
|
||||
3.04350687094184E+01
|
||||
|
||||
|
||||
------>
|
||||
CHAMP AUX NOEUDS DE NOM SYMBOLIQUE ETOT_NOEU
|
||||
NUMERO D'ORDRE: 1 INST: 1.00000000000000E+00
|
||||
NOEUD TOTALE
|
||||
N1 1.66816662962836E+01
|
||||
N2 3.28045573071458E+00
|
||||
N3 -3.38190091410633E+01
|
||||
N4 2.60309145978325E+01
|
||||
|
||||
<I> <FIN> FERMETURE DE LA BASE "GLOBALE" EFFECTUEE.
|
||||
|
||||
<FIN> Arrêt normal dans "FIN".
|
||||
<I> <FIN> ARRET NORMAL DANS "FIN" PAR APPEL A "JEFINI".
|
||||
|
||||
<I> <FIN> MEMOIRE JEVEUX MINIMALE REQUISE POUR L'EXECUTION : 21.14 Mo
|
||||
<I> <FIN> MEMOIRE JEVEUX OPTIMALE REQUISE POUR L'EXECUTION : 27.32 Mo
|
||||
<I> <FIN> MAXIMUM DE MEMOIRE UTILISEE PAR LE PROCESSUS LORS DE L'EXECUTION : 226.65 Mo
|
||||
|
||||
********************************************************************************
|
||||
* COMMAND : USER : SYSTEM : USER+SYS : ELAPSED *
|
||||
********************************************************************************
|
||||
* init (jdc) : 0.17 : 0.01 : 0.18 : 0.20 *
|
||||
* . compile : 0.01 : 0.00 : 0.01 : 0.00 *
|
||||
* . exec_compile : 0.06 : 0.00 : 0.06 : 0.07 *
|
||||
* . report : 0.01 : 0.00 : 0.01 : 0.00 *
|
||||
* . build : 0.00 : 0.00 : 0.00 : 0.00 *
|
||||
* DEBUT : 0.02 : 0.01 : 0.03 : 0.09 *
|
||||
* LIRE_MAILLAGE : 0.01 : 0.00 : 0.01 : 0.10 *
|
||||
* AFFE_MODELE : 0.00 : 0.00 : 0.00 : 0.17 *
|
||||
* DEFI_MATERIAU : 0.00 : 0.00 : 0.00 : 0.01 *
|
||||
* AFFE_MATERIAU : 0.01 : 0.00 : 0.01 : 0.00 *
|
||||
* AFFE_CHAR_MECA : 0.00 : 0.00 : 0.00 : 0.05 *
|
||||
* AFFE_CHAR_MECA : 0.00 : 0.00 : 0.00 : 0.00 *
|
||||
* DEFI_LIST_REEL : 0.01 : 0.00 : 0.01 : 0.00 *
|
||||
* DEFI_FONCTION : 0.00 : 0.00 : 0.00 : 0.00 *
|
||||
* STAT_NON_LINE : 0.08 : 0.00 : 0.08 : 0.51 *
|
||||
* CALC_CHAMP : 0.05 : 0.00 : 0.05 : 0.07 *
|
||||
* IMPR_RESU : 0.01 : 0.00 : 0.01 : 0.07 *
|
||||
* FIN : 0.01 : 0.02 : 0.03 : 0.03 *
|
||||
* . part Superviseur : 0.20 : 0.02 : 0.22 : 0.41 *
|
||||
* . part Fortran : 0.17 : 0.02 : 0.19 : 1.01 *
|
||||
********************************************************************************
|
||||
* TOTAL_JOB : 0.37 : 0.04 : 0.41 : 1.42 *
|
||||
********************************************************************************
|
||||
|
||||
Reference in New Issue
Block a user