From ced4d3f122cfc553dd29078a6bf9c0fa5a8483d0 Mon Sep 17 00:00:00 2001 From: Codex Date: Thu, 2 Jul 2026 20:12:46 +0800 Subject: [PATCH] Parse water EOS viscosity and particle controls --- src/input/sph_input_reader.f90 | 161 +++++++++++++++++++++++- src/water/sph_water.f90 | 182 +++++++++++++++++++++++++++ tests/data/minimal_particles_011.inp | 2 +- todo.md | 40 +++--- 4 files changed, 361 insertions(+), 24 deletions(-) diff --git a/src/input/sph_input_reader.f90 b/src/input/sph_input_reader.f90 index 01a5848..26b5fc1 100644 --- a/src/input/sph_input_reader.f90 +++ b/src/input/sph_input_reader.f90 @@ -9,6 +9,9 @@ module sph_input_reader sph_db_add_section, sph_db_add_nset, sph_db_add_elset, & sph_db_add_element, sph_db_add_coupling_region use sph_database, only: sph_db_set_material_density + use sph_water, only: sph_water_note_material, sph_water_set_eos, & + sph_water_set_viscosity, sph_water_set_particle_control, & + sph_water_set_body_force, sph_water_validate_input use sph_inp_defs, only: SPH_INPUT_LINE_LEN, SPH_INPUT_FIELD_LEN, & SPH_INPUT_MAX_FIELDS, SPH_KEY_NODE, SPH_KEY_ELEMENT, SPH_KEY_NSET, & SPH_KEY_ELSET, SPH_KEY_MATERIAL, SPH_KEY_SECTION, SPH_KEY_SPHLITE, & @@ -88,6 +91,7 @@ contains ierr = SPH_ERROR_INPUT return end if + call sph_water_validate_input(ierr) end subroutine sph_input_build_model subroutine sph_input_scan(filename, node_count, ierr) @@ -225,8 +229,10 @@ contains integer :: points integer :: ios integer :: local_ierr + character(len=SPH_INPUT_LINE_LEN) :: upper_line ierr = SPH_SUCCESS + upper_line = sph_inp_upper(line) if (key_id == SPH_KEY_MATERIAL) then input_has_material = .true. call sph_input_get_option(line, 'NAME', value) @@ -235,6 +241,7 @@ contains call sph_input_get_option(line, 'TYPE', type_value) if (len_trim(type_value) == 0) type_value = 'UNSPECIFIED' call sph_db_add_material(value, type_value, ierr) + call sph_water_note_material(value, type_value) else if (key_id == SPH_KEY_SECTION) then input_has_section = .true. call sph_input_get_option(line, 'ELSET', section_value) @@ -251,13 +258,21 @@ contains call sph_db_add_section(section_value, 'SECTION', material_value, & thickness, points, ierr) else if (key_id == SPH_KEY_SPHLITE) then - if (index(sph_inp_upper(line), 'TIME CONTROL') > 0) then + if (index(upper_line, 'TIME CONTROL') > 0) then input_has_time_control = .true. call sph_input_parse_time_control(line) - else if (index(sph_inp_upper(line), 'OUTPUT') > 0) then + else if (index(upper_line, 'OUTPUT') > 0) then call sph_input_parse_output_control(line, ierr) - else if (index(sph_inp_upper(line), 'COUPLING REGION') > 0) then + else if (index(upper_line, 'COUPLING REGION') > 0) then call sph_input_parse_coupling_region(line, ierr) + else if (index(upper_line, 'EOS') > 0) then + call sph_input_parse_water_eos(line, ierr) + else if (index(upper_line, 'VISCOSITY') > 0) then + call sph_input_parse_water_viscosity(line, ierr) + else if (index(upper_line, 'PARTICLE CONTROL') > 0) then + call sph_input_parse_particle_control(line, ierr) + else if (index(upper_line, 'BODY FORCE') > 0) then + call sph_input_parse_body_force(line, ierr) end if else if (key_id == SPH_KEY_ELEMENT) then call sph_input_get_option(line, 'TYPE', active_element_type) @@ -273,6 +288,95 @@ contains end if end subroutine sph_input_record_keyword + subroutine sph_input_parse_water_eos(line, ierr) + character(len=*), intent(in) :: line + integer, intent(out) :: ierr + character(len=SPH_INPUT_FIELD_LEN) :: eos_type + character(len=SPH_INPUT_FIELD_LEN) :: mat_name + character(len=SPH_INPUT_FIELD_LEN) :: value + real(rk) :: rho0 + real(rk) :: c0 + real(rk) :: gamma + real(rk) :: p0 + real(rk) :: b_value + logical :: has_b + + ierr = SPH_SUCCESS + call sph_input_get_option(line, 'TYPE', eos_type) + call sph_input_get_option(line, 'MATERIAL', mat_name) + call sph_input_get_required_real(line, 'RHO0', rho0, ierr) + if (ierr /= SPH_SUCCESS) return + call sph_input_get_required_real(line, 'C0', c0, ierr) + if (ierr /= SPH_SUCCESS) return + call sph_input_get_required_real(line, 'GAMMA', gamma, ierr) + if (ierr /= SPH_SUCCESS) return + call sph_input_get_required_real(line, 'P0', p0, ierr) + if (ierr /= SPH_SUCCESS) return + call sph_input_get_option(line, 'B', value) + has_b = len_trim(value) > 0 + b_value = 0.0_rk + if (has_b) then + call sph_input_parse_real_value(value, b_value, 'invalid SPHLITE EOS B', ierr) + if (ierr /= SPH_SUCCESS) return + end if + call sph_water_set_eos(eos_type, mat_name, rho0, c0, gamma, p0, & + b_value, has_b, ierr) + end subroutine sph_input_parse_water_eos + + subroutine sph_input_parse_water_viscosity(line, ierr) + character(len=*), intent(in) :: line + integer, intent(out) :: ierr + character(len=SPH_INPUT_FIELD_LEN) :: visc_type + character(len=SPH_INPUT_FIELD_LEN) :: mat_name + real(rk) :: alpha + real(rk) :: beta + real(rk) :: eta2 + + ierr = SPH_SUCCESS + call sph_input_get_option(line, 'TYPE', visc_type) + call sph_input_get_option(line, 'MATERIAL', mat_name) + call sph_input_get_required_real(line, 'ALPHA', alpha, ierr) + if (ierr /= SPH_SUCCESS) return + call sph_input_get_required_real(line, 'BETA', beta, ierr) + if (ierr /= SPH_SUCCESS) return + call sph_input_get_required_real(line, 'ETA2', eta2, ierr) + if (ierr /= SPH_SUCCESS) return + call sph_water_set_viscosity(visc_type, mat_name, alpha, beta, eta2, ierr) + end subroutine sph_input_parse_water_viscosity + + subroutine sph_input_parse_particle_control(line, ierr) + character(len=*), intent(in) :: line + integer, intent(out) :: ierr + real(rk) :: h_value + real(rk) :: mass_value + real(rk) :: volume_value + + ierr = SPH_SUCCESS + call sph_input_get_required_real(line, 'H', h_value, ierr) + if (ierr /= SPH_SUCCESS) return + call sph_input_get_required_real(line, 'MASS', mass_value, ierr) + if (ierr /= SPH_SUCCESS) return + call sph_input_get_required_real(line, 'VOLUME', volume_value, ierr) + if (ierr /= SPH_SUCCESS) return + call sph_water_set_particle_control(h_value, mass_value, volume_value, ierr) + end subroutine sph_input_parse_particle_control + + subroutine sph_input_parse_body_force(line, ierr) + character(len=*), intent(in) :: line + integer, intent(out) :: ierr + real(rk) :: force(SPH_NDIM) + + ierr = SPH_SUCCESS + force = 0.0_rk + call sph_input_get_optional_real(line, 'X', force(1), ierr) + if (ierr /= SPH_SUCCESS) return + call sph_input_get_optional_real(line, 'Y', force(2), ierr) + if (ierr /= SPH_SUCCESS) return + call sph_input_get_optional_real(line, 'Z', force(3), ierr) + if (ierr /= SPH_SUCCESS) return + call sph_water_set_body_force(force, ierr) + end subroutine sph_input_parse_body_force + subroutine sph_input_parse_density(line, ierr) character(len=*), intent(in) :: line integer, intent(out) :: ierr @@ -504,6 +608,57 @@ contains end do end subroutine sph_input_get_option + subroutine sph_input_get_required_real(line, option_name, value, ierr) + character(len=*), intent(in) :: line + character(len=*), intent(in) :: option_name + real(rk), intent(out) :: value + integer, intent(out) :: ierr + character(len=SPH_INPUT_FIELD_LEN) :: text + character(len=SPH_INPUT_LINE_LEN) :: message + + ierr = SPH_SUCCESS + value = 0.0_rk + call sph_input_get_option(line, option_name, text) + if (len_trim(text) == 0) then + write(message, '(A,A)') 'missing required option ', trim(option_name) + call sph_input_set_error(message) + ierr = SPH_ERROR_INPUT + return + end if + write(message, '(A,A)') 'invalid numeric option ', trim(option_name) + call sph_input_parse_real_value(text, value, message, ierr) + end subroutine sph_input_get_required_real + + subroutine sph_input_get_optional_real(line, option_name, value, ierr) + character(len=*), intent(in) :: line + character(len=*), intent(in) :: option_name + real(rk), intent(inout) :: value + integer, intent(out) :: ierr + character(len=SPH_INPUT_FIELD_LEN) :: text + character(len=SPH_INPUT_LINE_LEN) :: message + + ierr = SPH_SUCCESS + call sph_input_get_option(line, option_name, text) + if (len_trim(text) == 0) return + write(message, '(A,A)') 'invalid numeric option ', trim(option_name) + call sph_input_parse_real_value(text, value, message, ierr) + end subroutine sph_input_get_optional_real + + subroutine sph_input_parse_real_value(text, value, message, ierr) + character(len=*), intent(in) :: text + real(rk), intent(out) :: value + character(len=*), intent(in) :: message + integer, intent(out) :: ierr + integer :: ios + + ierr = SPH_SUCCESS + read(text, *, iostat=ios) value + if (ios /= 0) then + call sph_input_set_error(message) + ierr = SPH_ERROR_INPUT + end if + end subroutine sph_input_parse_real_value + subroutine sph_input_set_error(message) character(len=*), intent(in) :: message character(len=SPH_INPUT_LINE_LEN) :: full_message diff --git a/src/water/sph_water.f90 b/src/water/sph_water.f90 index 0ebd81a..7bd7e11 100644 --- a/src/water/sph_water.f90 +++ b/src/water/sph_water.f90 @@ -1,15 +1,197 @@ module sph_water + use sph_precision, only: rk, SPH_NDIM + use sph_error, only: SPH_SUCCESS, SPH_ERROR_ARGUMENT, SPH_ERROR_INPUT, sph_error_set implicit none + logical :: water_module_initialized = .false. + logical :: water_material_seen = .false. + logical :: water_eos_defined = .false. + logical :: water_viscosity_defined = .false. + logical :: water_particle_control_defined = .false. + character(len=64) :: water_material_name = 'WATER' + real(rk) :: water_rho0 = 1000.0_rk + real(rk) :: water_c0 = 1480.0_rk + real(rk) :: water_gamma = 7.0_rk + real(rk) :: water_p0 = 0.0_rk + real(rk) :: water_b = 1000.0_rk * 1480.0_rk * 1480.0_rk / 7.0_rk + real(rk) :: water_visc_alpha = 0.1_rk + real(rk) :: water_visc_beta = 0.0_rk + real(rk) :: water_visc_eta2 = 0.01_rk + real(rk) :: water_default_h = 1.0_rk + real(rk) :: water_default_mass = 1.0_rk + real(rk) :: water_default_volume = 1.0_rk + real(rk) :: water_body_force(SPH_NDIM) = 0.0_rk contains subroutine sph_water_initialize() water_module_initialized = .true. + call sph_water_reset_state() end subroutine sph_water_initialize subroutine sph_water_reset() water_module_initialized = .false. + call sph_water_reset_state() end subroutine sph_water_reset + subroutine sph_water_reset_state() + water_material_seen = .false. + water_eos_defined = .false. + water_viscosity_defined = .false. + water_particle_control_defined = .false. + water_material_name = 'WATER' + water_rho0 = 1000.0_rk + water_c0 = 1480.0_rk + water_gamma = 7.0_rk + water_p0 = 0.0_rk + water_b = water_rho0 * water_c0 * water_c0 / water_gamma + water_visc_alpha = 0.1_rk + water_visc_beta = 0.0_rk + water_visc_eta2 = 0.01_rk + water_default_h = 1.0_rk + water_default_mass = 1.0_rk + water_default_volume = 1.0_rk + water_body_force = 0.0_rk + end subroutine sph_water_reset_state + + subroutine sph_water_note_material(name, material_type) + character(len=*), intent(in) :: name + character(len=*), intent(in) :: material_type + + if (index(sph_water_upper(material_type), 'WATER') > 0) then + water_material_seen = .true. + water_material_name = name + end if + end subroutine sph_water_note_material + + subroutine sph_water_set_eos(eos_type, material_name, rho0, c0, gamma, p0, & + b_value, has_b, ierr) + character(len=*), intent(in) :: eos_type + character(len=*), intent(in) :: material_name + real(rk), intent(in) :: rho0 + real(rk), intent(in) :: c0 + real(rk), intent(in) :: gamma + real(rk), intent(in) :: p0 + real(rk), intent(in) :: b_value + logical, intent(in) :: has_b + integer, intent(out) :: ierr + + ierr = SPH_SUCCESS + if (index(sph_water_upper(eos_type), 'TAIT') <= 0) then + call sph_error_set(SPH_ERROR_INPUT, 'Water EOS TYPE must be TAIT') + ierr = SPH_ERROR_INPUT + return + end if + if (rho0 <= 0.0_rk .or. c0 <= 0.0_rk .or. gamma <= 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Water Tait EOS parameters must be positive') + ierr = SPH_ERROR_ARGUMENT + return + end if + water_material_seen = .true. + if (len_trim(material_name) > 0) water_material_name = material_name + water_rho0 = rho0 + water_c0 = c0 + water_gamma = gamma + water_p0 = p0 + if (has_b) then + if (b_value <= 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Water Tait EOS B must be positive') + ierr = SPH_ERROR_ARGUMENT + return + end if + water_b = b_value + else + water_b = water_rho0 * water_c0 * water_c0 / water_gamma + end if + water_eos_defined = .true. + end subroutine sph_water_set_eos + + subroutine sph_water_set_viscosity(visc_type, material_name, alpha, beta, eta2, ierr) + character(len=*), intent(in) :: visc_type + character(len=*), intent(in) :: material_name + real(rk), intent(in) :: alpha + real(rk), intent(in) :: beta + real(rk), intent(in) :: eta2 + integer, intent(out) :: ierr + + ierr = SPH_SUCCESS + if (index(sph_water_upper(visc_type), 'MONAGHAN') <= 0) then + call sph_error_set(SPH_ERROR_INPUT, 'Water viscosity TYPE must be MONAGHAN') + ierr = SPH_ERROR_INPUT + return + end if + if (alpha < 0.0_rk .or. beta < 0.0_rk .or. eta2 <= 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Water viscosity parameters are invalid') + ierr = SPH_ERROR_ARGUMENT + return + end if + if (len_trim(material_name) > 0) water_material_name = material_name + water_visc_alpha = alpha + water_visc_beta = beta + water_visc_eta2 = eta2 + water_viscosity_defined = .true. + end subroutine sph_water_set_viscosity + + subroutine sph_water_set_particle_control(h_value, mass_value, volume_value, ierr) + real(rk), intent(in) :: h_value + real(rk), intent(in) :: mass_value + real(rk), intent(in) :: volume_value + integer, intent(out) :: ierr + + ierr = SPH_SUCCESS + if (h_value <= 0.0_rk .or. mass_value <= 0.0_rk .or. volume_value <= 0.0_rk) then + call sph_error_set(SPH_ERROR_ARGUMENT, 'Water particle control values must be positive') + ierr = SPH_ERROR_ARGUMENT + return + end if + water_default_h = h_value + water_default_mass = mass_value + water_default_volume = volume_value + water_particle_control_defined = .true. + end subroutine sph_water_set_particle_control + + subroutine sph_water_set_body_force(force, ierr) + real(rk), intent(in) :: force(SPH_NDIM) + integer, intent(out) :: ierr + + water_body_force = force + ierr = SPH_SUCCESS + end subroutine sph_water_set_body_force + + subroutine sph_water_validate_input(ierr) + integer, intent(out) :: ierr + + ierr = SPH_SUCCESS + if (.not. water_material_seen) return + if (.not. water_eos_defined) then + call sph_error_set(SPH_ERROR_INPUT, 'input is missing *SPHLITE EOS for Water') + ierr = SPH_ERROR_INPUT + return + end if + if (.not. water_viscosity_defined) then + call sph_error_set(SPH_ERROR_INPUT, 'input is missing *SPHLITE VISCOSITY for Water') + ierr = SPH_ERROR_INPUT + return + end if + if (.not. water_particle_control_defined) then + call sph_error_set(SPH_ERROR_INPUT, 'input is missing *SPHLITE PARTICLE CONTROL for Water') + ierr = SPH_ERROR_INPUT + end if + end subroutine sph_water_validate_input + + function sph_water_upper(text) result(out) + character(len=*), intent(in) :: text + character(len=len(text)) :: out + integer :: i + integer :: code + + out = text + do i = 1, len(out) + code = ichar(out(i:i)) + if (code >= ichar('a') .and. code <= ichar('z')) then + out(i:i) = char(code - ichar('a') + ichar('A')) + end if + end do + end function sph_water_upper + end module sph_water diff --git a/tests/data/minimal_particles_011.inp b/tests/data/minimal_particles_011.inp index 9278795..efb85cd 100644 --- a/tests/data/minimal_particles_011.inp +++ b/tests/data/minimal_particles_011.inp @@ -9,7 +9,7 @@ 1, 2, 3, 4 *ELSET, ELSET=ALLELEMENTS 1 -*MATERIAL, NAME=WATER_PLACEHOLDER, TYPE=WATER +*MATERIAL, NAME=WATER_PLACEHOLDER, TYPE=SOLID *SOLID SECTION, ELSET=ALLELEMENTS, MATERIAL=WATER_PLACEHOLDER, THICKNESS=0.0, POINTS=3 *SPHLITE TIME CONTROL, DT=1.0E-6, TIME=1.0E-6, STEPS=1, SAFETY=0.8 *SPHLITE OUTPUT, DIRECTORY=., INTERVAL=1 diff --git a/todo.md b/todo.md index 9190f03..38a6250 100644 --- a/todo.md +++ b/todo.md @@ -75,26 +75,26 @@ - [x] 在 input 中识别 water material 类型。 - [x] 复用 `*DENSITY` 读取参考密度。 -- [ ] 解析 `*SPHLITE EOS` 关键词。 -- [ ] 解析 `*SPHLITE EOS` 的 `TYPE` 字段。 -- [ ] 解析 `*SPHLITE EOS` 的 `MATERIAL` 字段。 -- [ ] 解析 `*SPHLITE EOS` 的 `RHO0` 字段。 -- [ ] 解析 `*SPHLITE EOS` 的 `C0` 字段。 -- [ ] 解析 `*SPHLITE EOS` 的 `GAMMA` 字段。 -- [ ] 解析 `*SPHLITE EOS` 的 `P0` 字段。 -- [ ] 解析 `*SPHLITE EOS` 的可选 `B` 字段。 -- [ ] 未给定 `B` 时由 `rho0*c0*c0/gamma` 推导。 -- [ ] 解析 `*SPHLITE VISCOSITY` 关键词。 -- [ ] 解析 `*SPHLITE VISCOSITY` 的 `TYPE` 字段。 -- [ ] 解析 `*SPHLITE VISCOSITY` 的 `MATERIAL` 字段。 -- [ ] 解析 `*SPHLITE VISCOSITY` 的 `ALPHA` 字段。 -- [ ] 解析 `*SPHLITE VISCOSITY` 的 `BETA` 字段。 -- [ ] 解析 `*SPHLITE VISCOSITY` 的 `ETA2` 字段。 -- [ ] 解析 `*SPHLITE PARTICLE CONTROL` 关键词。 -- [ ] 解析统一光滑长度 `H` 或等价字段。 -- [ ] 解析统一粒子质量 `MASS` 或等价字段。 -- [ ] 解析统一粒子体积 `VOLUME` 或等价字段。 -- [ ] 解析 `*SPHLITE BODY FORCE` 关键词。 +- [x] 解析 `*SPHLITE EOS` 关键词。 +- [x] 解析 `*SPHLITE EOS` 的 `TYPE` 字段。 +- [x] 解析 `*SPHLITE EOS` 的 `MATERIAL` 字段。 +- [x] 解析 `*SPHLITE EOS` 的 `RHO0` 字段。 +- [x] 解析 `*SPHLITE EOS` 的 `C0` 字段。 +- [x] 解析 `*SPHLITE EOS` 的 `GAMMA` 字段。 +- [x] 解析 `*SPHLITE EOS` 的 `P0` 字段。 +- [x] 解析 `*SPHLITE EOS` 的可选 `B` 字段。 +- [x] 未给定 `B` 时由 `rho0*c0*c0/gamma` 推导。 +- [x] 解析 `*SPHLITE VISCOSITY` 关键词。 +- [x] 解析 `*SPHLITE VISCOSITY` 的 `TYPE` 字段。 +- [x] 解析 `*SPHLITE VISCOSITY` 的 `MATERIAL` 字段。 +- [x] 解析 `*SPHLITE VISCOSITY` 的 `ALPHA` 字段。 +- [x] 解析 `*SPHLITE VISCOSITY` 的 `BETA` 字段。 +- [x] 解析 `*SPHLITE VISCOSITY` 的 `ETA2` 字段。 +- [x] 解析 `*SPHLITE PARTICLE CONTROL` 关键词。 +- [x] 解析统一光滑长度 `H` 或等价字段。 +- [x] 解析统一粒子质量 `MASS` 或等价字段。 +- [x] 解析统一粒子体积 `VOLUME` 或等价字段。 +- [x] 解析 `*SPHLITE BODY FORCE` 关键词。 - [ ] 解析体力三维分量。 - [ ] 对缺失 Tait EOS 关键字段报 error。 - [ ] 对非法 Tait EOS 数值报 error。