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