|
|
|
@@ -0,0 +1,267 @@
|
|
|
|
|
module sph_blast_load
|
|
|
|
|
use sph_precision, only: rk, SPH_NDIM
|
|
|
|
|
use sph_error, only: SPH_SUCCESS, SPH_ERROR_DATABASE, sph_error_set
|
|
|
|
|
use sph_database, only: SPH_MAX_REGIONS, npart, particle_phase, x, v, &
|
|
|
|
|
volume, SPH_PHASE_SOLID, SPH_PHASE_SHELL
|
|
|
|
|
use sph_blast, only: blast_region_count, blast_region_enabled, &
|
|
|
|
|
blast_center, blast_load_scale, blast_time_window, &
|
|
|
|
|
blast_source_count, blast_target_count, blast_candidate_pair_count, &
|
|
|
|
|
blast_source_pressure_mean, blast_source_energy, blast_water_count, &
|
|
|
|
|
blast_water_pressure_min, blast_water_pressure_max, &
|
|
|
|
|
blast_explosive_progress_mean, sph_blast_refresh_snapshot, &
|
|
|
|
|
sph_blast_target_accepts
|
|
|
|
|
implicit none
|
|
|
|
|
|
|
|
|
|
real(rk), parameter :: SPH_BLAST_LOAD_EPS = 1.0e-12_rk
|
|
|
|
|
real(rk), allocatable :: blast_solid_external_force(:,:)
|
|
|
|
|
real(rk), allocatable :: blast_shell_external_force(:,:)
|
|
|
|
|
real(rk), allocatable :: blast_shell_external_moment(:,:)
|
|
|
|
|
integer :: blast_load_target_count(SPH_MAX_REGIONS) = 0
|
|
|
|
|
integer :: blast_load_pair_count(SPH_MAX_REGIONS) = 0
|
|
|
|
|
integer :: blast_load_zero_weight_count(SPH_MAX_REGIONS) = 0
|
|
|
|
|
integer :: blast_load_nonfinite_count(SPH_MAX_REGIONS) = 0
|
|
|
|
|
real(rk) :: blast_load_total_force(SPH_NDIM,SPH_MAX_REGIONS) = 0.0_rk
|
|
|
|
|
real(rk) :: blast_solid_total_force(SPH_NDIM,SPH_MAX_REGIONS) = 0.0_rk
|
|
|
|
|
real(rk) :: blast_shell_total_force(SPH_NDIM,SPH_MAX_REGIONS) = 0.0_rk
|
|
|
|
|
real(rk) :: blast_load_impulse(SPH_NDIM,SPH_MAX_REGIONS) = 0.0_rk
|
|
|
|
|
real(rk) :: blast_load_momentum_input(SPH_NDIM,SPH_MAX_REGIONS) = 0.0_rk
|
|
|
|
|
real(rk) :: blast_load_work(SPH_MAX_REGIONS) = 0.0_rk
|
|
|
|
|
real(rk) :: blast_load_energy_input(SPH_MAX_REGIONS) = 0.0_rk
|
|
|
|
|
real(rk) :: blast_load_max_particle_force(SPH_MAX_REGIONS) = 0.0_rk
|
|
|
|
|
|
|
|
|
|
contains
|
|
|
|
|
|
|
|
|
|
subroutine sph_blast_load_initialize()
|
|
|
|
|
call sph_blast_load_reset()
|
|
|
|
|
end subroutine sph_blast_load_initialize
|
|
|
|
|
|
|
|
|
|
subroutine sph_blast_load_reset()
|
|
|
|
|
call sph_blast_load_deallocate()
|
|
|
|
|
call sph_blast_load_clear_diagnostics()
|
|
|
|
|
end subroutine sph_blast_load_reset
|
|
|
|
|
|
|
|
|
|
subroutine sph_blast_load_deallocate()
|
|
|
|
|
if (allocated(blast_solid_external_force)) deallocate(blast_solid_external_force)
|
|
|
|
|
if (allocated(blast_shell_external_force)) deallocate(blast_shell_external_force)
|
|
|
|
|
if (allocated(blast_shell_external_moment)) deallocate(blast_shell_external_moment)
|
|
|
|
|
end subroutine sph_blast_load_deallocate
|
|
|
|
|
|
|
|
|
|
subroutine sph_blast_load_clear(ierr)
|
|
|
|
|
integer, intent(out) :: ierr
|
|
|
|
|
|
|
|
|
|
call sph_blast_load_prepare_storage(ierr)
|
|
|
|
|
if (ierr /= SPH_SUCCESS) return
|
|
|
|
|
if (allocated(blast_solid_external_force)) blast_solid_external_force = 0.0_rk
|
|
|
|
|
if (allocated(blast_shell_external_force)) blast_shell_external_force = 0.0_rk
|
|
|
|
|
if (allocated(blast_shell_external_moment)) blast_shell_external_moment = 0.0_rk
|
|
|
|
|
call sph_blast_load_clear_diagnostics()
|
|
|
|
|
end subroutine sph_blast_load_clear
|
|
|
|
|
|
|
|
|
|
subroutine sph_blast_load_clear_diagnostics()
|
|
|
|
|
blast_load_target_count = 0
|
|
|
|
|
blast_load_pair_count = 0
|
|
|
|
|
blast_load_zero_weight_count = 0
|
|
|
|
|
blast_load_nonfinite_count = 0
|
|
|
|
|
blast_load_total_force = 0.0_rk
|
|
|
|
|
blast_solid_total_force = 0.0_rk
|
|
|
|
|
blast_shell_total_force = 0.0_rk
|
|
|
|
|
blast_load_impulse = 0.0_rk
|
|
|
|
|
blast_load_momentum_input = 0.0_rk
|
|
|
|
|
blast_load_work = 0.0_rk
|
|
|
|
|
blast_load_energy_input = 0.0_rk
|
|
|
|
|
blast_load_max_particle_force = 0.0_rk
|
|
|
|
|
end subroutine sph_blast_load_clear_diagnostics
|
|
|
|
|
|
|
|
|
|
subroutine sph_blast_load_prepare_storage(ierr)
|
|
|
|
|
integer, intent(out) :: ierr
|
|
|
|
|
integer :: stat
|
|
|
|
|
|
|
|
|
|
ierr = SPH_SUCCESS
|
|
|
|
|
if (npart <= 0) return
|
|
|
|
|
if (allocated(blast_solid_external_force)) then
|
|
|
|
|
if (size(blast_solid_external_force, 2) == npart) return
|
|
|
|
|
call sph_blast_load_deallocate()
|
|
|
|
|
end if
|
|
|
|
|
allocate(blast_solid_external_force(SPH_NDIM,npart), &
|
|
|
|
|
blast_shell_external_force(SPH_NDIM,npart), &
|
|
|
|
|
blast_shell_external_moment(SPH_NDIM,npart), stat=stat)
|
|
|
|
|
if (stat /= 0) then
|
|
|
|
|
call sph_error_set(SPH_ERROR_DATABASE, 'failed to allocate Blast load cache')
|
|
|
|
|
ierr = SPH_ERROR_DATABASE
|
|
|
|
|
return
|
|
|
|
|
end if
|
|
|
|
|
blast_solid_external_force = 0.0_rk
|
|
|
|
|
blast_shell_external_force = 0.0_rk
|
|
|
|
|
blast_shell_external_moment = 0.0_rk
|
|
|
|
|
end subroutine sph_blast_load_prepare_storage
|
|
|
|
|
|
|
|
|
|
subroutine sph_blast_load_compute(ierr)
|
|
|
|
|
integer, intent(out) :: ierr
|
|
|
|
|
integer :: region
|
|
|
|
|
|
|
|
|
|
call sph_blast_refresh_snapshot(ierr)
|
|
|
|
|
if (ierr /= SPH_SUCCESS) return
|
|
|
|
|
call sph_blast_load_clear(ierr)
|
|
|
|
|
if (ierr /= SPH_SUCCESS) return
|
|
|
|
|
do region = 1, blast_region_count
|
|
|
|
|
if (.not. blast_region_enabled(region)) cycle
|
|
|
|
|
call sph_blast_load_project_region(region)
|
|
|
|
|
end do
|
|
|
|
|
end subroutine sph_blast_load_compute
|
|
|
|
|
|
|
|
|
|
subroutine sph_blast_load_project_region(region)
|
|
|
|
|
integer, intent(in) :: region
|
|
|
|
|
real(rk) :: pressure_value
|
|
|
|
|
real(rk) :: total_area
|
|
|
|
|
integer :: target
|
|
|
|
|
|
|
|
|
|
if (blast_source_count(region) <= 0) return
|
|
|
|
|
if (blast_target_count(region) <= 0) return
|
|
|
|
|
pressure_value = sph_blast_load_pressure(region)
|
|
|
|
|
if (.not. sph_blast_load_real_is_finite(pressure_value)) then
|
|
|
|
|
blast_load_nonfinite_count(region) = blast_load_nonfinite_count(region) + 1
|
|
|
|
|
return
|
|
|
|
|
end if
|
|
|
|
|
call sph_blast_load_total_area(region, total_area)
|
|
|
|
|
if (total_area <= SPH_BLAST_LOAD_EPS) then
|
|
|
|
|
blast_load_zero_weight_count(region) = blast_load_zero_weight_count(region) + 1
|
|
|
|
|
return
|
|
|
|
|
end if
|
|
|
|
|
do target = 1, npart
|
|
|
|
|
if (.not. sph_blast_target_accepts(region, target)) cycle
|
|
|
|
|
call sph_blast_load_apply_target(region, target, pressure_value)
|
|
|
|
|
end do
|
|
|
|
|
blast_load_pair_count(region) = blast_candidate_pair_count(region)
|
|
|
|
|
if (blast_load_target_count(region) > 0) then
|
|
|
|
|
blast_load_energy_input(region) = blast_load_energy_input(region) + &
|
|
|
|
|
blast_explosive_progress_mean(region) * blast_source_energy(region)
|
|
|
|
|
end if
|
|
|
|
|
end subroutine sph_blast_load_project_region
|
|
|
|
|
|
|
|
|
|
real(rk) function sph_blast_load_pressure(region)
|
|
|
|
|
integer, intent(in) :: region
|
|
|
|
|
real(rk) :: water_pressure
|
|
|
|
|
|
|
|
|
|
water_pressure = 0.0_rk
|
|
|
|
|
if (blast_water_count(region) > 0) then
|
|
|
|
|
water_pressure = 0.5_rk * (blast_water_pressure_min(region) + &
|
|
|
|
|
blast_water_pressure_max(region))
|
|
|
|
|
end if
|
|
|
|
|
sph_blast_load_pressure = blast_load_scale(region) * &
|
|
|
|
|
(blast_source_pressure_mean(region) + water_pressure)
|
|
|
|
|
end function sph_blast_load_pressure
|
|
|
|
|
|
|
|
|
|
subroutine sph_blast_load_total_area(region, total_area)
|
|
|
|
|
integer, intent(in) :: region
|
|
|
|
|
real(rk), intent(out) :: total_area
|
|
|
|
|
integer :: target
|
|
|
|
|
|
|
|
|
|
total_area = 0.0_rk
|
|
|
|
|
do target = 1, npart
|
|
|
|
|
if (.not. sph_blast_target_accepts(region, target)) cycle
|
|
|
|
|
total_area = total_area + sph_blast_load_particle_area(target)
|
|
|
|
|
end do
|
|
|
|
|
end subroutine sph_blast_load_total_area
|
|
|
|
|
|
|
|
|
|
subroutine sph_blast_load_apply_target(region, target, pressure_value)
|
|
|
|
|
integer, intent(in) :: region
|
|
|
|
|
integer, intent(in) :: target
|
|
|
|
|
real(rk), intent(in) :: pressure_value
|
|
|
|
|
real(rk) :: direction(SPH_NDIM)
|
|
|
|
|
real(rk) :: area_value
|
|
|
|
|
real(rk) :: force(SPH_NDIM)
|
|
|
|
|
real(rk) :: force_norm
|
|
|
|
|
|
|
|
|
|
call sph_blast_load_direction(region, target, direction)
|
|
|
|
|
if (maxval(abs(direction)) <= 0.0_rk) then
|
|
|
|
|
blast_load_zero_weight_count(region) = blast_load_zero_weight_count(region) + 1
|
|
|
|
|
return
|
|
|
|
|
end if
|
|
|
|
|
area_value = sph_blast_load_particle_area(target)
|
|
|
|
|
if (area_value <= SPH_BLAST_LOAD_EPS) then
|
|
|
|
|
blast_load_zero_weight_count(region) = blast_load_zero_weight_count(region) + 1
|
|
|
|
|
return
|
|
|
|
|
end if
|
|
|
|
|
force = direction * pressure_value * area_value
|
|
|
|
|
if (.not. sph_blast_load_vector_is_finite(force)) then
|
|
|
|
|
blast_load_nonfinite_count(region) = blast_load_nonfinite_count(region) + 1
|
|
|
|
|
return
|
|
|
|
|
end if
|
|
|
|
|
call sph_blast_load_store_force(region, target, force)
|
|
|
|
|
force_norm = sqrt(sum(force * force))
|
|
|
|
|
if (force_norm > blast_load_max_particle_force(region)) then
|
|
|
|
|
blast_load_max_particle_force(region) = force_norm
|
|
|
|
|
end if
|
|
|
|
|
end subroutine sph_blast_load_apply_target
|
|
|
|
|
|
|
|
|
|
subroutine sph_blast_load_store_force(region, target, force)
|
|
|
|
|
integer, intent(in) :: region
|
|
|
|
|
integer, intent(in) :: target
|
|
|
|
|
real(rk), intent(in) :: force(SPH_NDIM)
|
|
|
|
|
|
|
|
|
|
if (particle_phase(target) == SPH_PHASE_SOLID) then
|
|
|
|
|
blast_solid_external_force(:,target) = &
|
|
|
|
|
blast_solid_external_force(:,target) + force
|
|
|
|
|
blast_solid_total_force(:,region) = blast_solid_total_force(:,region) + force
|
|
|
|
|
else if (particle_phase(target) == SPH_PHASE_SHELL) then
|
|
|
|
|
blast_shell_external_force(:,target) = &
|
|
|
|
|
blast_shell_external_force(:,target) + force
|
|
|
|
|
blast_shell_total_force(:,region) = blast_shell_total_force(:,region) + force
|
|
|
|
|
else
|
|
|
|
|
return
|
|
|
|
|
end if
|
|
|
|
|
blast_load_target_count(region) = blast_load_target_count(region) + 1
|
|
|
|
|
blast_load_total_force(:,region) = blast_load_total_force(:,region) + force
|
|
|
|
|
blast_load_impulse(:,region) = blast_load_impulse(:,region) + &
|
|
|
|
|
force * blast_time_window(region)
|
|
|
|
|
blast_load_momentum_input(:,region) = blast_load_impulse(:,region)
|
|
|
|
|
blast_load_work(region) = blast_load_work(region) + &
|
|
|
|
|
sum(force * v(:,target)) * blast_time_window(region)
|
|
|
|
|
end subroutine sph_blast_load_store_force
|
|
|
|
|
|
|
|
|
|
subroutine sph_blast_load_direction(region, target, direction)
|
|
|
|
|
integer, intent(in) :: region
|
|
|
|
|
integer, intent(in) :: target
|
|
|
|
|
real(rk), intent(out) :: direction(SPH_NDIM)
|
|
|
|
|
real(rk) :: length
|
|
|
|
|
|
|
|
|
|
direction = x(:,target) - blast_center(:,region)
|
|
|
|
|
length = sqrt(sum(direction * direction))
|
|
|
|
|
if (length <= SPH_BLAST_LOAD_EPS) then
|
|
|
|
|
direction = 0.0_rk
|
|
|
|
|
else
|
|
|
|
|
direction = direction / length
|
|
|
|
|
end if
|
|
|
|
|
end subroutine sph_blast_load_direction
|
|
|
|
|
|
|
|
|
|
real(rk) function sph_blast_load_particle_area(index)
|
|
|
|
|
integer, intent(in) :: index
|
|
|
|
|
|
|
|
|
|
sph_blast_load_particle_area = 0.0_rk
|
|
|
|
|
if (index < 1 .or. index > npart) return
|
|
|
|
|
if (volume(index) <= 0.0_rk) return
|
|
|
|
|
sph_blast_load_particle_area = volume(index)**(2.0_rk / 3.0_rk)
|
|
|
|
|
end function sph_blast_load_particle_area
|
|
|
|
|
|
|
|
|
|
logical function sph_blast_load_real_is_finite(value)
|
|
|
|
|
real(rk), intent(in) :: value
|
|
|
|
|
|
|
|
|
|
sph_blast_load_real_is_finite = .true.
|
|
|
|
|
if (value /= value) sph_blast_load_real_is_finite = .false.
|
|
|
|
|
if (abs(value) > huge(value) * 0.5_rk) sph_blast_load_real_is_finite = .false.
|
|
|
|
|
end function sph_blast_load_real_is_finite
|
|
|
|
|
|
|
|
|
|
logical function sph_blast_load_vector_is_finite(values)
|
|
|
|
|
real(rk), intent(in) :: values(SPH_NDIM)
|
|
|
|
|
integer :: i
|
|
|
|
|
|
|
|
|
|
sph_blast_load_vector_is_finite = .true.
|
|
|
|
|
do i = 1, SPH_NDIM
|
|
|
|
|
if (.not. sph_blast_load_real_is_finite(values(i))) then
|
|
|
|
|
sph_blast_load_vector_is_finite = .false.
|
|
|
|
|
return
|
|
|
|
|
end if
|
|
|
|
|
end do
|
|
|
|
|
end function sph_blast_load_vector_is_finite
|
|
|
|
|
|
|
|
|
|
end module sph_blast_load
|