396 lines
12 KiB
Fortran
396 lines
12 KiB
Fortran
program euler_column_buckling_benchmark
|
|
use fem_precision
|
|
use fem_error
|
|
use fem_geometric_stiffness
|
|
use fem_buckling_solver
|
|
implicit none
|
|
|
|
integer, parameter :: MAX_MODE = 3
|
|
real(rk) :: young
|
|
real(rk) :: inertia
|
|
real(rk) :: length
|
|
real(rk) :: kfactor
|
|
real(rk) :: exact
|
|
real(rk) :: rel_error
|
|
real(rk) :: mode_norm
|
|
real(rk), allocatable :: kfull(:,:)
|
|
real(rk), allocatable :: kgfull(:,:)
|
|
real(rk), allocatable :: kred(:,:)
|
|
real(rk), allocatable :: kgred(:,:)
|
|
real(rk), allocatable :: modes(:,:)
|
|
real(rk), allocatable :: full_mode(:)
|
|
real(rk) :: factors(MAX_MODE)
|
|
real(rk) :: residuals(MAX_MODE)
|
|
character(len=512) :: input_file
|
|
character(len=512) :: out_dir
|
|
character(len=512) :: path
|
|
integer :: elem_count
|
|
integer :: ndof
|
|
integer :: nfree
|
|
integer :: ierr
|
|
integer :: argc
|
|
|
|
intrinsic iargc
|
|
intrinsic getarg
|
|
|
|
argc = iargc()
|
|
if (argc .lt. 2) then
|
|
write(*,'(A)') 'Usage: euler_column_buckling_benchmark INPUT.inp OUTPUT_DIR'
|
|
stop 2
|
|
end if
|
|
|
|
call getarg(1, input_file)
|
|
call getarg(2, out_dir)
|
|
call read_column_input(trim(input_file), young, inertia, length, elem_count, &
|
|
kfactor, ierr)
|
|
call exit_if_error(ierr)
|
|
|
|
ndof = 2 * (elem_count + 1)
|
|
nfree = ndof - 2
|
|
allocate(kfull(ndof,ndof), kgfull(ndof,ndof), kred(nfree,nfree), &
|
|
kgred(nfree,nfree), modes(nfree,MAX_MODE), full_mode(ndof), &
|
|
stat=ierr)
|
|
if (ierr .ne. 0) then
|
|
call error_set(FEM_ERR_INTERNAL, 'failed to allocate Euler buckling arrays', ierr)
|
|
call exit_if_error(ierr)
|
|
end if
|
|
|
|
call assemble_column(young, inertia, length, elem_count, kfull, kgfull, ierr)
|
|
call exit_if_error(ierr)
|
|
call reduce_pinned_column(kfull, kgfull, elem_count, kred, kgred, ierr)
|
|
call exit_if_error(ierr)
|
|
call buckling_dense_solve(nfree, kred, kgred, MAX_MODE, factors, modes, &
|
|
residuals, ierr)
|
|
call exit_if_error(ierr)
|
|
call buckling_euler_column_load(young, inertia, length, kfactor, exact, ierr)
|
|
call exit_if_error(ierr)
|
|
rel_error = abs(factors(1) - exact) / exact
|
|
mode_norm = dot_product(modes(:,1), matmul(kgred, modes(:,1)))
|
|
call expand_pinned_mode(elem_count, modes(:,1), full_mode)
|
|
|
|
path = join_path(out_dir, 'buckling_summary.csv')
|
|
call write_summary(trim(path), elem_count, young, inertia, length, kfactor, &
|
|
exact, factors, residuals, rel_error, mode_norm, ierr)
|
|
call exit_if_error(ierr)
|
|
path = join_path(out_dir, 'buckling_mode_1.csv')
|
|
call write_mode(trim(path), length, elem_count, full_mode, ierr)
|
|
call exit_if_error(ierr)
|
|
|
|
write(*,'(A,ES12.5,A,ES12.5,A,ES12.5)') 'Euler column Pcr=', exact, &
|
|
' factor=', factors(1), ' rel_error=', rel_error
|
|
|
|
contains
|
|
|
|
subroutine read_column_input(filename, young, inertia, length, elem_count, &
|
|
kfactor, ierr)
|
|
character(len=*), intent(in) :: filename
|
|
real(rk), intent(out) :: young
|
|
real(rk), intent(out) :: inertia
|
|
real(rk), intent(out) :: length
|
|
integer, intent(out) :: elem_count
|
|
real(rk), intent(out) :: kfactor
|
|
integer, intent(out) :: ierr
|
|
character(len=512) :: line
|
|
character(len=512) :: upper
|
|
integer :: unit
|
|
integer :: ios
|
|
logical :: want_data
|
|
|
|
young = 210.0e9_rk
|
|
inertia = 8.0e-6_rk
|
|
length = 3.0_rk
|
|
elem_count = 8
|
|
kfactor = ONE
|
|
want_data = .false.
|
|
unit = 94
|
|
open(unit=unit, file=trim(filename), status='old', action='read', iostat=ios)
|
|
if (ios .ne. 0) then
|
|
call error_set(FEM_ERR_INPUT, 'failed to open Euler buckling input', ierr)
|
|
return
|
|
end if
|
|
|
|
do
|
|
read(unit,'(A)',iostat=ios) line
|
|
if (ios .lt. 0) exit
|
|
if (ios .gt. 0) then
|
|
close(unit)
|
|
call error_set(FEM_ERR_INPUT, 'failed to read Euler buckling input', ierr)
|
|
return
|
|
end if
|
|
if (len_trim(line) .eq. 0) cycle
|
|
if (len_trim(line) .ge. 2) then
|
|
if (line(1:2) .eq. '**') cycle
|
|
end if
|
|
call uppercase(line, upper)
|
|
if (upper(1:1) .eq. '*') then
|
|
want_data = index(upper, '*BUCKLING COLUMN') .eq. 1
|
|
else if (want_data) then
|
|
read(line,*,iostat=ios) young, inertia, length, elem_count, kfactor
|
|
close(unit)
|
|
if (ios .ne. 0) then
|
|
call error_set(FEM_ERR_INPUT, 'failed to parse Euler buckling data', ierr)
|
|
return
|
|
end if
|
|
call validate_input(young, inertia, length, elem_count, kfactor, ierr)
|
|
return
|
|
end if
|
|
end do
|
|
close(unit)
|
|
call validate_input(young, inertia, length, elem_count, kfactor, ierr)
|
|
end subroutine read_column_input
|
|
|
|
subroutine validate_input(young, inertia, length, elem_count, kfactor, ierr)
|
|
real(rk), intent(in) :: young
|
|
real(rk), intent(in) :: inertia
|
|
real(rk), intent(in) :: length
|
|
integer, intent(in) :: elem_count
|
|
real(rk), intent(in) :: kfactor
|
|
integer, intent(out) :: ierr
|
|
|
|
if (young .le. ZERO .or. inertia .le. ZERO .or. length .le. ZERO .or. &
|
|
kfactor .le. ZERO .or. elem_count .lt. 2) then
|
|
call error_set(FEM_ERR_INPUT, 'invalid Euler buckling benchmark data', ierr)
|
|
return
|
|
end if
|
|
if (elem_count .gt. 64) then
|
|
call error_set(FEM_ERR_INPUT, 'Euler buckling element count is too large', ierr)
|
|
return
|
|
end if
|
|
call error_clear(ierr)
|
|
end subroutine validate_input
|
|
|
|
subroutine assemble_column(young, inertia, length, elem_count, kfull, kgfull, ierr)
|
|
real(rk), intent(in) :: young
|
|
real(rk), intent(in) :: inertia
|
|
real(rk), intent(in) :: length
|
|
integer, intent(in) :: elem_count
|
|
real(rk), intent(out) :: kfull(:,:)
|
|
real(rk), intent(out) :: kgfull(:,:)
|
|
integer, intent(out) :: ierr
|
|
real(rk) :: le
|
|
real(rk) :: ke(4,4)
|
|
real(rk) :: kg(4,4)
|
|
integer :: elem
|
|
integer :: ids(4)
|
|
|
|
kfull = ZERO
|
|
kgfull = ZERO
|
|
le = length / real(elem_count, rk)
|
|
do elem = 1, elem_count
|
|
call beam_bending_stiffness(young, inertia, le, ke)
|
|
call geom_beam2d_column_stiffness(le, ONE, kg, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
ids = (/ 2 * elem - 1, 2 * elem, 2 * elem + 1, 2 * elem + 2 /)
|
|
call add_local4(kfull, ids, ke)
|
|
call add_local4(kgfull, ids, kg)
|
|
end do
|
|
call error_clear(ierr)
|
|
end subroutine assemble_column
|
|
|
|
subroutine beam_bending_stiffness(young, inertia, le, ke)
|
|
real(rk), intent(in) :: young
|
|
real(rk), intent(in) :: inertia
|
|
real(rk), intent(in) :: le
|
|
real(rk), intent(out) :: ke(4,4)
|
|
real(rk) :: c
|
|
real(rk) :: l2
|
|
|
|
c = young * inertia / (le * le * le)
|
|
l2 = le * le
|
|
ke(1,:) = (/ 12.0_rk, 6.0_rk * le, -12.0_rk, 6.0_rk * le /)
|
|
ke(2,:) = (/ 6.0_rk * le, 4.0_rk * l2, -6.0_rk * le, 2.0_rk * l2 /)
|
|
ke(3,:) = (/ -12.0_rk, -6.0_rk * le, 12.0_rk, -6.0_rk * le /)
|
|
ke(4,:) = (/ 6.0_rk * le, 2.0_rk * l2, -6.0_rk * le, 4.0_rk * l2 /)
|
|
ke = c * ke
|
|
end subroutine beam_bending_stiffness
|
|
|
|
subroutine add_local4(global, ids, local)
|
|
real(rk), intent(inout) :: global(:,:)
|
|
integer, intent(in) :: ids(4)
|
|
real(rk), intent(in) :: local(4,4)
|
|
integer :: i
|
|
integer :: j
|
|
|
|
do i = 1, 4
|
|
do j = 1, 4
|
|
global(ids(i),ids(j)) = global(ids(i),ids(j)) + local(i,j)
|
|
end do
|
|
end do
|
|
end subroutine add_local4
|
|
|
|
subroutine reduce_pinned_column(kfull, kgfull, elem_count, kred, kgred, ierr)
|
|
real(rk), intent(in) :: kfull(:,:)
|
|
real(rk), intent(in) :: kgfull(:,:)
|
|
integer, intent(in) :: elem_count
|
|
real(rk), intent(out) :: kred(:,:)
|
|
real(rk), intent(out) :: kgred(:,:)
|
|
integer, intent(out) :: ierr
|
|
integer :: ndof
|
|
integer :: i
|
|
integer :: j
|
|
integer :: ii
|
|
integer :: jj
|
|
integer, allocatable :: free_ids(:)
|
|
|
|
ndof = 2 * (elem_count + 1)
|
|
allocate(free_ids(ndof - 2), stat=ierr)
|
|
if (ierr .ne. 0) then
|
|
call error_set(FEM_ERR_INTERNAL, 'failed to allocate Euler free id map', ierr)
|
|
return
|
|
end if
|
|
ii = 0
|
|
do i = 1, ndof
|
|
if (i .ne. 1 .and. i .ne. ndof - 1) then
|
|
ii = ii + 1
|
|
free_ids(ii) = i
|
|
end if
|
|
end do
|
|
do i = 1, ii
|
|
do j = 1, ii
|
|
jj = free_ids(j)
|
|
kred(i,j) = kfull(free_ids(i),jj)
|
|
kgred(i,j) = kgfull(free_ids(i),jj)
|
|
end do
|
|
end do
|
|
deallocate(free_ids)
|
|
call error_clear(ierr)
|
|
end subroutine reduce_pinned_column
|
|
|
|
subroutine expand_pinned_mode(elem_count, reduced, full)
|
|
integer, intent(in) :: elem_count
|
|
real(rk), intent(in) :: reduced(:)
|
|
real(rk), intent(out) :: full(:)
|
|
integer :: ndof
|
|
integer :: i
|
|
integer :: ii
|
|
|
|
ndof = 2 * (elem_count + 1)
|
|
full = ZERO
|
|
ii = 0
|
|
do i = 1, ndof
|
|
if (i .ne. 1 .and. i .ne. ndof - 1) then
|
|
ii = ii + 1
|
|
full(i) = reduced(ii)
|
|
end if
|
|
end do
|
|
end subroutine expand_pinned_mode
|
|
|
|
subroutine write_summary(filename, elem_count, young, inertia, length, &
|
|
kfactor, exact, factors, residuals, rel_error, &
|
|
mode_norm, ierr)
|
|
character(len=*), intent(in) :: filename
|
|
integer, intent(in) :: elem_count
|
|
real(rk), intent(in) :: young
|
|
real(rk), intent(in) :: inertia
|
|
real(rk), intent(in) :: length
|
|
real(rk), intent(in) :: kfactor
|
|
real(rk), intent(in) :: exact
|
|
real(rk), intent(in) :: factors(MAX_MODE)
|
|
real(rk), intent(in) :: residuals(MAX_MODE)
|
|
real(rk), intent(in) :: rel_error
|
|
real(rk), intent(in) :: mode_norm
|
|
integer, intent(out) :: ierr
|
|
integer :: unit
|
|
integer :: ios
|
|
|
|
unit = 95
|
|
open(unit=unit, file=trim(filename), status='replace', action='write', &
|
|
iostat=ios)
|
|
if (ios .ne. 0) then
|
|
call error_set(FEM_ERR_OUTPUT, 'failed to open Euler buckling summary', ierr)
|
|
return
|
|
end if
|
|
write(unit,'(A)') 'key,value'
|
|
write(unit,'(A,I0)') 'element_count,', elem_count
|
|
write(unit,'(A,ES16.8)') 'young,', young
|
|
write(unit,'(A,ES16.8)') 'inertia,', inertia
|
|
write(unit,'(A,ES16.8)') 'length,', length
|
|
write(unit,'(A,ES16.8)') 'kfactor,', kfactor
|
|
write(unit,'(A,ES16.8)') 'euler_pcr,', exact
|
|
write(unit,'(A,ES16.8)') 'mode_1_factor,', factors(1)
|
|
write(unit,'(A,ES16.8)') 'mode_2_factor,', factors(2)
|
|
write(unit,'(A,ES16.8)') 'mode_3_factor,', factors(3)
|
|
write(unit,'(A,ES16.8)') 'mode_1_residual,', residuals(1)
|
|
write(unit,'(A,ES16.8)') 'relative_error,', rel_error
|
|
write(unit,'(A,ES16.8)') 'kg_mode_norm,', mode_norm
|
|
close(unit)
|
|
call error_clear(ierr)
|
|
end subroutine write_summary
|
|
|
|
subroutine write_mode(filename, length, elem_count, full_mode, ierr)
|
|
character(len=*), intent(in) :: filename
|
|
real(rk), intent(in) :: length
|
|
integer, intent(in) :: elem_count
|
|
real(rk), intent(in) :: full_mode(:)
|
|
integer, intent(out) :: ierr
|
|
integer :: unit
|
|
integer :: ios
|
|
integer :: node
|
|
real(rk) :: x
|
|
|
|
unit = 96
|
|
open(unit=unit, file=trim(filename), status='replace', action='write', &
|
|
iostat=ios)
|
|
if (ios .ne. 0) then
|
|
call error_set(FEM_ERR_OUTPUT, 'failed to open Euler buckling mode', ierr)
|
|
return
|
|
end if
|
|
write(unit,'(A)') 'node,x,w,theta'
|
|
do node = 1, elem_count + 1
|
|
x = length * real(node - 1, rk) / real(elem_count, rk)
|
|
write(unit,'(I0,",",ES16.8,",",ES16.8,",",ES16.8)') node, x, &
|
|
full_mode(2 * node - 1), full_mode(2 * node)
|
|
end do
|
|
close(unit)
|
|
call error_clear(ierr)
|
|
end subroutine write_mode
|
|
|
|
function join_path(dir, name) result(path)
|
|
character(len=*), intent(in) :: dir
|
|
character(len=*), intent(in) :: name
|
|
character(len=512) :: path
|
|
integer :: n
|
|
|
|
n = len_trim(dir)
|
|
if (n .le. 0) then
|
|
path = trim(name)
|
|
else if (dir(n:n) .eq. '\' .or. dir(n:n) .eq. '/') then
|
|
path = trim(dir)//trim(name)
|
|
else
|
|
path = trim(dir)//'/'//trim(name)
|
|
end if
|
|
end function join_path
|
|
|
|
subroutine uppercase(line, upper)
|
|
character(len=*), intent(in) :: line
|
|
character(len=*), intent(out) :: upper
|
|
integer :: i
|
|
integer :: code
|
|
|
|
upper = line
|
|
do i = 1, len_trim(upper)
|
|
code = iachar(upper(i:i))
|
|
if (code .ge. iachar('a') .and. code .le. iachar('z')) then
|
|
upper(i:i) = achar(code - iachar('a') + iachar('A'))
|
|
end if
|
|
end do
|
|
end subroutine uppercase
|
|
|
|
subroutine exit_if_error(ierr)
|
|
integer, intent(in) :: ierr
|
|
integer :: code
|
|
integer :: ierr2
|
|
character(len=256) :: msg
|
|
|
|
if (ierr .eq. FEM_SUCCESS) return
|
|
call fem_get_last_error(code, msg, ierr2)
|
|
if (ierr2 .eq. FEM_SUCCESS) then
|
|
write(*,'(A,I0,2A)') 'Error ', code, ': ', trim(msg)
|
|
else
|
|
write(*,'(A,I0)') 'Error: ', ierr
|
|
end if
|
|
stop 1
|
|
end subroutine exit_if_error
|
|
|
|
end program euler_column_buckling_benchmark
|