613 lines
21 KiB
Fortran
613 lines
21 KiB
Fortran
program grain_container_bench
|
|
use fem_precision
|
|
use fem_error
|
|
use fem_api
|
|
use fem_particle_state
|
|
use fem_particle_contact
|
|
use fem_particle_step
|
|
use fem_particle_facet_coupling
|
|
use fem_particle_facet_step
|
|
use fem_particle_coupling
|
|
implicit none
|
|
|
|
type grain_cfg
|
|
character(len=512) :: structure_file = 'flexible_container_grain_benchmark.inp'
|
|
integer :: steps = 40
|
|
integer :: probe_node = 5
|
|
real(rk) :: dt = 2.0e-6_rk
|
|
real(rk) :: gravity(NDIM) = (/ ZERO, ZERO, -9.81_rk /)
|
|
real(rk) :: damping = ZERO
|
|
real(rk) :: search_gap = 1.0e-5_rk
|
|
integer :: particle_count = 0
|
|
end type grain_cfg
|
|
|
|
type grain_stats
|
|
integer :: max_particle_count = 0
|
|
integer :: max_facet_contacts = 0
|
|
integer :: max_pair_contacts = 0
|
|
integer :: max_wall_contacts = 0
|
|
integer :: mapped_steps = 0
|
|
real(rk) :: max_overlap = ZERO
|
|
real(rk) :: max_particle_kinetic = ZERO
|
|
real(rk) :: particle_dissipated = ZERO
|
|
real(rk) :: facet_dissipated = ZERO
|
|
real(rk) :: final_mass = ZERO
|
|
real(rk) :: min_container_uz = ZERO
|
|
real(rk) :: final_container_uz = ZERO
|
|
real(rk) :: max_abs_load_z = ZERO
|
|
real(rk) :: max_particle_force_norm = ZERO
|
|
real(rk) :: max_node_force_norm = ZERO
|
|
end type grain_stats
|
|
|
|
type(grain_cfg) :: cfg
|
|
type(grain_stats) :: stats
|
|
type(particle_contact_params) :: params
|
|
character(len=512) :: input_file
|
|
character(len=512) :: out_dir
|
|
character(len=512) :: structure_path
|
|
integer :: argc
|
|
integer :: ierr
|
|
|
|
intrinsic iargc
|
|
intrinsic getarg
|
|
|
|
argc = iargc()
|
|
if (argc .lt. 2) then
|
|
write(*,'(A)') 'Usage: dynamic_grain_container_benchmark INPUT.inp OUTPUT_DIR'
|
|
stop 2
|
|
end if
|
|
|
|
call getarg(1, input_file)
|
|
call getarg(2, out_dir)
|
|
|
|
call read_grain_input(trim(input_file), cfg, params, ierr)
|
|
call exit_if_error(ierr)
|
|
call resolve_case_path(trim(input_file), trim(cfg%structure_file), &
|
|
structure_path)
|
|
call run_grain_case(cfg, params, trim(structure_path), trim(out_dir), &
|
|
stats, ierr)
|
|
call exit_if_error(ierr)
|
|
call write_summary(join_path(out_dir, 'grain_container_summary.csv'), cfg, &
|
|
stats, ierr)
|
|
call exit_if_error(ierr)
|
|
|
|
call particle_reset()
|
|
call fem_finalize(ierr)
|
|
|
|
write(*,'(A,I0,A,I0,A,ES12.5,A,ES12.5)') &
|
|
'particles=', stats%max_particle_count, ' facet_contacts=', &
|
|
stats%max_facet_contacts, ' min_uz=', stats%min_container_uz, &
|
|
' max_load_z=', stats%max_abs_load_z
|
|
|
|
contains
|
|
|
|
subroutine read_grain_input(filename, cfg, params, ierr)
|
|
character(len=*), intent(in) :: filename
|
|
type(grain_cfg), intent(out) :: cfg
|
|
type(particle_contact_params), intent(out) :: params
|
|
integer, intent(out) :: ierr
|
|
|
|
character(len=512) :: line
|
|
character(len=512) :: upper
|
|
integer :: unit
|
|
integer :: ios
|
|
integer :: mode
|
|
|
|
call set_defaults(cfg, params)
|
|
call particle_reset()
|
|
mode = 0
|
|
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 grain benchmark 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 grain benchmark input', &
|
|
ierr)
|
|
return
|
|
end if
|
|
if (is_blank_or_comment(line)) cycle
|
|
call uppercase(line, upper)
|
|
if (upper(1:1) .eq. '*') then
|
|
call update_mode(upper, mode)
|
|
else if (mode .eq. 1) then
|
|
call parse_control(line, cfg, ios)
|
|
if (ios .ne. 0) exit
|
|
else if (mode .eq. 2) then
|
|
call parse_contact(line, params, ios)
|
|
if (ios .ne. 0) exit
|
|
else if (mode .eq. 3) then
|
|
call add_particle_line(line, cfg, ios)
|
|
if (ios .ne. 0) exit
|
|
end if
|
|
end do
|
|
close(unit)
|
|
if (ios .gt. 0) then
|
|
call error_set(FEM_ERR_INPUT, 'failed to parse grain benchmark input', &
|
|
ierr)
|
|
return
|
|
end if
|
|
call validate_cfg(cfg, params, ierr)
|
|
end subroutine read_grain_input
|
|
|
|
subroutine set_defaults(cfg, params)
|
|
type(grain_cfg), intent(out) :: cfg
|
|
type(particle_contact_params), intent(out) :: params
|
|
integer :: ierr
|
|
|
|
cfg%structure_file = 'flexible_container_grain_benchmark.inp'
|
|
cfg%steps = 40
|
|
cfg%probe_node = 5
|
|
cfg%dt = 2.0e-6_rk
|
|
cfg%gravity = (/ ZERO, ZERO, -9.81_rk /)
|
|
cfg%damping = ZERO
|
|
cfg%search_gap = 1.0e-5_rk
|
|
cfg%particle_count = 0
|
|
call particle_contact_init(3.0e3_rk, ONE, ZERO, ZERO, 3.0e3_rk, ONE, &
|
|
params, ierr)
|
|
end subroutine set_defaults
|
|
|
|
subroutine update_mode(upper, mode)
|
|
character(len=*), intent(in) :: upper
|
|
integer, intent(out) :: mode
|
|
|
|
if (index(upper, '*DYNAMIC GRAIN CONTAINER') .eq. 1) then
|
|
mode = 1
|
|
else if (index(upper, '*PARTICLE CONTACT') .eq. 1) then
|
|
mode = 2
|
|
else if (index(upper, '*PARTICLES') .eq. 1) then
|
|
mode = 3
|
|
else
|
|
mode = 0
|
|
end if
|
|
end subroutine update_mode
|
|
|
|
subroutine parse_control(line, cfg, ios)
|
|
character(len=*), intent(in) :: line
|
|
type(grain_cfg), intent(inout) :: cfg
|
|
integer, intent(out) :: ios
|
|
|
|
read(line,*,iostat=ios) cfg%structure_file, cfg%steps, cfg%dt, &
|
|
cfg%gravity(1), cfg%gravity(2), cfg%gravity(3), cfg%damping, &
|
|
cfg%search_gap, cfg%probe_node
|
|
end subroutine parse_control
|
|
|
|
subroutine parse_contact(line, params, ios)
|
|
character(len=*), intent(in) :: line
|
|
type(particle_contact_params), intent(out) :: params
|
|
integer, intent(out) :: ios
|
|
integer :: ierr
|
|
real(rk) :: kn
|
|
real(rk) :: cn
|
|
real(rk) :: kt
|
|
real(rk) :: mu
|
|
real(rk) :: kwall
|
|
real(rk) :: cwall
|
|
|
|
read(line,*,iostat=ios) kn, cn, kt, mu, kwall, cwall
|
|
if (ios .ne. 0) return
|
|
call particle_contact_init(kn, cn, kt, mu, kwall, cwall, params, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) ios = 1
|
|
end subroutine parse_contact
|
|
|
|
subroutine add_particle_line(line, cfg, ios)
|
|
character(len=*), intent(in) :: line
|
|
type(grain_cfg), intent(inout) :: cfg
|
|
integer, intent(out) :: ios
|
|
|
|
integer :: id
|
|
integer :: slot
|
|
integer :: ierr
|
|
real(rk) :: pos(NDIM)
|
|
real(rk) :: vel(NDIM)
|
|
real(rk) :: radius
|
|
real(rk) :: mass
|
|
|
|
read(line,*,iostat=ios) id, pos(1), pos(2), pos(3), vel(1), vel(2), &
|
|
vel(3), radius, mass
|
|
if (ios .ne. 0) return
|
|
call particle_add(id, pos, vel, radius, mass, slot, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) then
|
|
ios = 1
|
|
return
|
|
end if
|
|
cfg%particle_count = cfg%particle_count + 1
|
|
end subroutine add_particle_line
|
|
|
|
subroutine validate_cfg(cfg, params, ierr)
|
|
type(grain_cfg), intent(in) :: cfg
|
|
type(particle_contact_params), intent(in) :: params
|
|
integer, intent(out) :: ierr
|
|
|
|
if (cfg%steps .lt. 2 .or. cfg%dt .le. ZERO .or. &
|
|
cfg%search_gap .lt. ZERO .or. cfg%particle_count .le. 0) then
|
|
call error_set(FEM_ERR_INPUT, 'invalid grain benchmark controls', ierr)
|
|
return
|
|
end if
|
|
if (cfg%probe_node .le. 0 .or. params%normal_stiffness .le. ZERO .or. &
|
|
params%wall_stiffness .le. ZERO) then
|
|
call error_set(FEM_ERR_INPUT, 'invalid grain benchmark contact data', &
|
|
ierr)
|
|
return
|
|
end if
|
|
call error_clear(ierr)
|
|
end subroutine validate_cfg
|
|
|
|
subroutine reset_stats(stats)
|
|
type(grain_stats), intent(out) :: stats
|
|
|
|
stats%max_particle_count = 0
|
|
stats%max_facet_contacts = 0
|
|
stats%max_pair_contacts = 0
|
|
stats%max_wall_contacts = 0
|
|
stats%mapped_steps = 0
|
|
stats%max_overlap = ZERO
|
|
stats%max_particle_kinetic = ZERO
|
|
stats%particle_dissipated = ZERO
|
|
stats%facet_dissipated = ZERO
|
|
stats%final_mass = ZERO
|
|
stats%min_container_uz = ZERO
|
|
stats%final_container_uz = ZERO
|
|
stats%max_abs_load_z = ZERO
|
|
stats%max_particle_force_norm = ZERO
|
|
stats%max_node_force_norm = ZERO
|
|
end subroutine reset_stats
|
|
|
|
subroutine run_grain_case(cfg, params, structure_path, out_dir, stats, ierr)
|
|
type(grain_cfg), intent(in) :: cfg
|
|
type(particle_contact_params), intent(in) :: params
|
|
character(len=*), intent(in) :: structure_path
|
|
character(len=*), intent(in) :: out_dir
|
|
type(grain_stats), intent(out) :: stats
|
|
integer, intent(out) :: ierr
|
|
|
|
integer :: unit
|
|
integer :: ios
|
|
integer :: step
|
|
type(particle_step_ctrl) :: ctrl
|
|
type(particle_step_diag) :: pdiag
|
|
type(pfacet_step_stats) :: fstats
|
|
type(particle_wall_def) :: walls(1)
|
|
|
|
call reset_stats(stats)
|
|
call initialize_fem_model(structure_path, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call configure_step(cfg, ctrl, walls, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
unit = 95
|
|
open(unit=unit, file=join_path(out_dir, 'grain_container_history.csv'), &
|
|
status='replace', action='write', iostat=ios)
|
|
if (ios .ne. 0) then
|
|
call error_set(FEM_ERR_OUTPUT, 'failed to open grain history output', &
|
|
ierr)
|
|
return
|
|
end if
|
|
call write_history_header(unit)
|
|
do step = 1, cfg%steps
|
|
call run_one_step(step, cfg, params, ctrl, walls, pdiag, fstats, unit, &
|
|
stats, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) then
|
|
close(unit)
|
|
return
|
|
end if
|
|
end do
|
|
close(unit)
|
|
call error_clear(ierr)
|
|
end subroutine run_grain_case
|
|
|
|
subroutine initialize_fem_model(structure_path, ierr)
|
|
character(len=*), intent(in) :: structure_path
|
|
integer, intent(out) :: ierr
|
|
|
|
call fem_initialize(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_read_inp(trim(structure_path), ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_build_model(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_compute_lumped_mass(ierr)
|
|
end subroutine initialize_fem_model
|
|
|
|
subroutine configure_step(cfg, ctrl, walls, ierr)
|
|
type(grain_cfg), intent(in) :: cfg
|
|
type(particle_step_ctrl), intent(out) :: ctrl
|
|
type(particle_wall_def), intent(out) :: walls(1)
|
|
integer, intent(out) :: ierr
|
|
|
|
call pstep_ctrl_init(cfg%dt, cfg%damping, cfg%gravity, cfg%search_gap, &
|
|
ctrl, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
ctrl%clear_forces = .false.
|
|
walls(1)%active = .false.
|
|
walls(1)%point = ZERO
|
|
walls(1)%normal = (/ ZERO, ZERO, ONE /)
|
|
call error_clear(ierr)
|
|
end subroutine configure_step
|
|
|
|
subroutine run_one_step(step, cfg, params, ctrl, walls, pdiag, fstats, unit, &
|
|
stats, ierr)
|
|
integer, intent(in) :: step
|
|
type(grain_cfg), intent(in) :: cfg
|
|
type(particle_contact_params), intent(in) :: params
|
|
type(particle_step_ctrl), intent(in) :: ctrl
|
|
type(particle_wall_def), intent(in) :: walls(1)
|
|
type(particle_step_diag), intent(out) :: pdiag
|
|
type(pfacet_step_stats), intent(out) :: fstats
|
|
integer, intent(in) :: unit
|
|
type(grain_stats), intent(inout) :: stats
|
|
integer, intent(out) :: ierr
|
|
|
|
real(rk) :: total_load(NDIM)
|
|
real(rk) :: disp(NDIM)
|
|
real(rk) :: vel(NDIM)
|
|
real(rk) :: acc(NDIM)
|
|
real(rk) :: time
|
|
integer :: particle_n
|
|
integer :: facet_contacts
|
|
real(rk) :: facet_overlap
|
|
real(rk) :: facet_energy
|
|
real(rk) :: facet_power
|
|
real(rk) :: facet_force_norm
|
|
real(rk) :: particle_force_norm
|
|
real(rk) :: node_force_norm
|
|
|
|
call fem_clear_sph_forces(ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call particle_fem_apply_all(params, .true., fstats, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_get_sph_force_summary(total_load, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_advance_explicit(cfg%dt, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call pstep_advance(ctrl, params, walls, 1, pdiag, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call fem_get_node_kinematics(cfg%probe_node, disp, vel, acc, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call particle_fem_stats_summary(fstats, particle_n, facet_contacts, &
|
|
facet_overlap, facet_energy, facet_power, facet_force_norm, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
call particle_fem_stats_force_norms(fstats, particle_force_norm, &
|
|
node_force_norm, ierr)
|
|
if (ierr .ne. FEM_SUCCESS) return
|
|
time = real(step,rk) * cfg%dt
|
|
call update_stats(cfg, stats, pdiag, fstats, total_load, disp, &
|
|
particle_force_norm, node_force_norm)
|
|
call write_history_row(unit, step, time, particle_n, facet_contacts, &
|
|
pdiag, fstats, total_load, disp, particle_force_norm, node_force_norm, &
|
|
cfg%dt)
|
|
end subroutine run_one_step
|
|
|
|
subroutine update_stats(cfg, stats, pdiag, fstats, total_load, disp, &
|
|
particle_force_norm, node_force_norm)
|
|
type(grain_cfg), intent(in) :: cfg
|
|
type(grain_stats), intent(inout) :: stats
|
|
type(particle_step_diag), intent(in) :: pdiag
|
|
type(pfacet_step_stats), intent(in) :: fstats
|
|
real(rk), intent(in) :: total_load(NDIM)
|
|
real(rk), intent(in) :: disp(NDIM)
|
|
real(rk), intent(in) :: particle_force_norm
|
|
real(rk), intent(in) :: node_force_norm
|
|
|
|
stats%max_particle_count = max(stats%max_particle_count, cfg%particle_count)
|
|
stats%max_facet_contacts = max(stats%max_facet_contacts, &
|
|
fstats%contact_count)
|
|
stats%max_pair_contacts = max(stats%max_pair_contacts, pdiag%pair_count)
|
|
stats%max_wall_contacts = max(stats%max_wall_contacts, pdiag%wall_count)
|
|
stats%max_overlap = max(stats%max_overlap, pdiag%max_overlap)
|
|
stats%max_overlap = max(stats%max_overlap, fstats%max_overlap)
|
|
stats%max_particle_kinetic = max(stats%max_particle_kinetic, &
|
|
pdiag%kinetic_after)
|
|
stats%particle_dissipated = stats%particle_dissipated + &
|
|
pdiag%dissipated_power * cfg%dt
|
|
stats%facet_dissipated = stats%facet_dissipated + &
|
|
fstats%dissipated_power * cfg%dt
|
|
stats%final_mass = pdiag%total_mass_after
|
|
stats%min_container_uz = min(stats%min_container_uz, disp(3))
|
|
stats%final_container_uz = disp(3)
|
|
stats%max_abs_load_z = max(stats%max_abs_load_z, abs(total_load(3)))
|
|
stats%max_particle_force_norm = max(stats%max_particle_force_norm, &
|
|
particle_force_norm)
|
|
stats%max_node_force_norm = max(stats%max_node_force_norm, &
|
|
node_force_norm)
|
|
if (fstats%contact_count .gt. 0 .and. abs(total_load(3)) .gt. 1.0e-12_rk) &
|
|
stats%mapped_steps = stats%mapped_steps + 1
|
|
end subroutine update_stats
|
|
|
|
subroutine write_history_header(unit)
|
|
integer, intent(in) :: unit
|
|
|
|
write(unit,'(A)') 'step,time,particle_count,facet_contacts,pair_contacts,' // &
|
|
'wall_contacts,max_overlap,particle_kinetic,particle_dissipated,' // &
|
|
'facet_dissipated,total_mass,container_disp_z,total_load_z,' // &
|
|
'particle_force_norm,node_force_norm'
|
|
end subroutine write_history_header
|
|
|
|
subroutine write_history_row(unit, step, time, particle_n, facet_contacts, &
|
|
pdiag, fstats, total_load, disp, &
|
|
particle_force_norm, node_force_norm, dt)
|
|
integer, intent(in) :: unit
|
|
integer, intent(in) :: step
|
|
integer, intent(in) :: particle_n
|
|
integer, intent(in) :: facet_contacts
|
|
real(rk), intent(in) :: time
|
|
type(particle_step_diag), intent(in) :: pdiag
|
|
type(pfacet_step_stats), intent(in) :: fstats
|
|
real(rk), intent(in) :: total_load(NDIM)
|
|
real(rk), intent(in) :: disp(NDIM)
|
|
real(rk), intent(in) :: particle_force_norm
|
|
real(rk), intent(in) :: node_force_norm
|
|
real(rk), intent(in) :: dt
|
|
|
|
write(unit,'(I0,",",ES16.8,",",I0,",",I0,",",I0,",",I0,",",ES16.8,' // &
|
|
'",",ES16.8,",",ES16.8,",",ES16.8,",",ES16.8,",",ES16.8,' // &
|
|
'",",ES16.8,",",ES16.8,",",ES16.8)') step, time, particle_n, &
|
|
facet_contacts, pdiag%pair_count, pdiag%wall_count, &
|
|
max(pdiag%max_overlap, fstats%max_overlap), pdiag%kinetic_after, &
|
|
pdiag%dissipated_power * dt, fstats%dissipated_power * dt, &
|
|
pdiag%total_mass_after, disp(3), total_load(3), particle_force_norm, &
|
|
node_force_norm
|
|
end subroutine write_history_row
|
|
|
|
subroutine write_summary(filename, cfg, stats, ierr)
|
|
character(len=*), intent(in) :: filename
|
|
type(grain_cfg), intent(in) :: cfg
|
|
type(grain_stats), intent(in) :: stats
|
|
integer, intent(out) :: ierr
|
|
|
|
integer :: unit
|
|
integer :: ios
|
|
|
|
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 grain summary output', &
|
|
ierr)
|
|
return
|
|
end if
|
|
write(unit,'(A)') 'metric,value'
|
|
call write_metric_i(unit, 'steps', cfg%steps)
|
|
call write_metric_i(unit, 'particles', cfg%particle_count)
|
|
call write_metric_i(unit, 'max_facet_contacts', stats%max_facet_contacts)
|
|
call write_metric_i(unit, 'max_pair_contacts', stats%max_pair_contacts)
|
|
call write_metric_i(unit, 'max_wall_contacts', stats%max_wall_contacts)
|
|
call write_metric_i(unit, 'mapped_steps', stats%mapped_steps)
|
|
call write_metric_r(unit, 'max_overlap', stats%max_overlap)
|
|
call write_metric_r(unit, 'max_particle_kinetic', &
|
|
stats%max_particle_kinetic)
|
|
call write_metric_r(unit, 'particle_dissipated', stats%particle_dissipated)
|
|
call write_metric_r(unit, 'facet_dissipated', stats%facet_dissipated)
|
|
call write_metric_r(unit, 'final_mass', stats%final_mass)
|
|
call write_metric_r(unit, 'min_container_uz', stats%min_container_uz)
|
|
call write_metric_r(unit, 'final_container_uz', stats%final_container_uz)
|
|
call write_metric_r(unit, 'max_abs_load_z', stats%max_abs_load_z)
|
|
call write_metric_r(unit, 'max_particle_force_norm', &
|
|
stats%max_particle_force_norm)
|
|
call write_metric_r(unit, 'max_node_force_norm', stats%max_node_force_norm)
|
|
close(unit)
|
|
call error_clear(ierr)
|
|
end subroutine write_summary
|
|
|
|
subroutine write_metric_i(unit, name, value)
|
|
integer, intent(in) :: unit
|
|
character(len=*), intent(in) :: name
|
|
integer, intent(in) :: value
|
|
|
|
write(unit,'(A,",",I0)') trim(name), value
|
|
end subroutine write_metric_i
|
|
|
|
subroutine write_metric_r(unit, name, value)
|
|
integer, intent(in) :: unit
|
|
character(len=*), intent(in) :: name
|
|
real(rk), intent(in) :: value
|
|
|
|
write(unit,'(A,",",ES16.8)') trim(name), value
|
|
end subroutine write_metric_r
|
|
|
|
subroutine resolve_case_path(input_file, rel_path, out_path)
|
|
character(len=*), intent(in) :: input_file
|
|
character(len=*), intent(in) :: rel_path
|
|
character(len=*), intent(out) :: out_path
|
|
character(len=512) :: base
|
|
|
|
if (is_absolute_path(rel_path)) then
|
|
out_path = trim(rel_path)
|
|
else
|
|
call path_dirname(input_file, base)
|
|
out_path = join_path(base, rel_path)
|
|
end if
|
|
end subroutine resolve_case_path
|
|
|
|
subroutine path_dirname(path, dirname)
|
|
character(len=*), intent(in) :: path
|
|
character(len=*), intent(out) :: dirname
|
|
integer :: idx
|
|
integer :: i
|
|
|
|
idx = 0
|
|
do i = len_trim(path), 1, -1
|
|
if (path(i:i) .eq. '/' .or. path(i:i) .eq. '\') then
|
|
idx = i - 1
|
|
exit
|
|
end if
|
|
end do
|
|
if (idx .le. 0) then
|
|
dirname = '.'
|
|
else
|
|
dirname = path(1:idx)
|
|
end if
|
|
end subroutine path_dirname
|
|
|
|
logical function is_absolute_path(path)
|
|
character(len=*), intent(in) :: path
|
|
|
|
is_absolute_path = .false.
|
|
if (len_trim(path) .ge. 1) then
|
|
is_absolute_path = path(1:1) .eq. '/' .or. path(1:1) .eq. '\'
|
|
end if
|
|
if (len_trim(path) .ge. 2) then
|
|
is_absolute_path = is_absolute_path .or. path(2:2) .eq. ':'
|
|
end if
|
|
end function is_absolute_path
|
|
|
|
character(len=1024) function join_path(dir, name) result(path)
|
|
character(len=*), intent(in) :: dir
|
|
character(len=*), intent(in) :: name
|
|
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
|
|
|
|
logical function is_blank_or_comment(line)
|
|
character(len=*), intent(in) :: line
|
|
character(len=512) :: tmp
|
|
integer :: first
|
|
|
|
tmp = adjustl(line)
|
|
first = len_trim(tmp)
|
|
is_blank_or_comment = first .eq. 0
|
|
if (.not. is_blank_or_comment) then
|
|
is_blank_or_comment = tmp(1:1) .eq. '#' .or. &
|
|
(len_trim(tmp) .ge. 2 .and. tmp(1:2) .eq. '**')
|
|
end if
|
|
end function is_blank_or_comment
|
|
|
|
subroutine uppercase(line, upper)
|
|
character(len=*), intent(in) :: line
|
|
character(len=*), intent(out) :: upper
|
|
integer :: i
|
|
integer :: c
|
|
|
|
upper = line
|
|
do i = 1, len_trim(upper)
|
|
c = iachar(upper(i:i))
|
|
if (c .ge. iachar('a') .and. c .le. iachar('z')) then
|
|
upper(i:i) = achar(c - 32)
|
|
end if
|
|
end do
|
|
end subroutine uppercase
|
|
|
|
subroutine exit_if_error(ierr)
|
|
integer, intent(in) :: ierr
|
|
|
|
if (ierr .ne. FEM_SUCCESS) then
|
|
write(*,'(A,I0)') 'dynamic grain container benchmark failed: ierr=', ierr
|
|
stop 1
|
|
end if
|
|
end subroutine exit_if_error
|
|
|
|
end program grain_container_bench
|