gkowal/amun-code
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
amun-code/src/problem.F90

490 lines
12 KiB
Fortran
Raw Normal View History

Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
!!*****************************************************************************
!!
Reorganization of compilation flags.
2008-12-08 13:59:57 -06:00
!! module: problem - handling the initial problem definition
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
!!
!! Copyright (C) 2008 Grzegorz Kowal <kowal@astro.wisc.edu>
!!
!!*****************************************************************************
!!
!! This file is part of Godunov-AMR.
!!
!! Godunov-AMR is free software; you can redistribute it and/or modify
!! it under the terms of the GNU General Public License as published by
!! the Free Software Foundation; either version 3 of the License, or
!! (at your option) any later version.
!!
!! Godunov-AMR is distributed in the hope that it will be useful,
!! but WITHOUT ANY WARRANTY; without even the implied warranty of
!! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
!! GNU General Public License for more details.
!!
!! You should have received a copy of the GNU General Public License
!! along with this program. If not, see <http://www.gnu.org/licenses/>.
!!
!!*****************************************************************************
!!
!
module problem
implicit none
contains
!
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
!===============================================================================
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
!
! init_problem: subroutine initializes the variables according to
! the studied problem
!
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
!===============================================================================
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
!
subroutine init_problem(pblock)
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
use blocks, only : block
use config, only : problem
! input arguments
!
type(block), pointer, intent(inout) :: pblock
! local arguments
!
type(block), pointer :: pb
!
!-------------------------------------------------------------------------------
!
pb => pblock
select case(trim(problem))
case("blast")
call init_blast(pb)
case("implosion")
call init_implosion(pb)
Binary stars problem implemented. I've implemented the problem of binary stars to study the colliding winds.
2008-12-18 11:09:42 -06:00
case("binaries")
call init_binaries(pb)
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
end select
nullify(pb)
!-------------------------------------------------------------------------------
!
end subroutine init_problem
!
!===============================================================================
!
! init_blast: subroutine initializes the variables for the blast problem
!
!===============================================================================
!
subroutine init_blast(pblock)
Store all variables in one array U. One array U, which is a field in the BLOCK structure, stores all variables. The number of variables is determined by the nvars parameter. To access each variable we use variable index now, like idn, imx, imy, mz, ien, etc.
2008-12-08 12:14:13 -06:00
use blocks, only : block, idn, imx, imy, imz, ien
Fixed generation of dx, dy, and dz. The generation of dx, dy, dz for each level didn't include the base grid, i.e. they were 2 times larger. Now it is fixed. Also plenty of minor corrections in different places.
2008-12-13 21:05:51 -06:00
use config, only : in, jn, kn, im, jm, km, ng, dens, pres, gammam1i
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
! input arguments
!
type(block), pointer, intent(inout) :: pblock
! local variables
!
integer(kind=4), dimension(3) :: dm
integer :: i, j, k
Added CFL condition and calculation of the new time step. The function to calculate the maximum speed in the block has been added. This function is used to determine the maximum speed globally, which is next used to estimate the next time step.
2008-12-09 14:51:33 -06:00
real :: r, dx, dy, dz, en, enamb
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
! local arrays
!
real, dimension(:), allocatable :: x, y, z
!
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
!-------------------------------------------------------------------------------
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
!
Added CFL condition and calculation of the new time step. The function to calculate the maximum speed in the block has been added. This function is used to determine the maximum speed globally, which is next used to estimate the next time step.
2008-12-09 14:51:33 -06:00
! calculate parameters
!
enamb = gammam1i * pres
en = 100.0 * enamb
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
! allocate coordinates
!
Fixed generation of dx, dy, and dz. The generation of dx, dy, dz for each level didn't include the base grid, i.e. they were 2 times larger. Now it is fixed. Also plenty of minor corrections in different places.
2008-12-13 21:05:51 -06:00
allocate(x(im))
allocate(y(jm))
allocate(z(km))
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
! calculate cell sizes
!
Fixed generation of dx, dy, and dz. The generation of dx, dy, dz for each level didn't include the base grid, i.e. they were 2 times larger. Now it is fixed. Also plenty of minor corrections in different places.
2008-12-13 21:05:51 -06:00
dx = (pblock%xmax - pblock%xmin) / in
dy = (pblock%ymax - pblock%ymin) / jn
More reorganization of the compilation flags. Now the source file can use some of the values defined in make files, like NDIMS. The make files, i.e. makefile, make.default, and host files are simpler and should be easier to manage.
2008-12-08 15:31:35 -06:00
#if NDIMS == 3
Fixed generation of dx, dy, and dz. The generation of dx, dy, dz for each level didn't include the base grid, i.e. they were 2 times larger. Now it is fixed. Also plenty of minor corrections in different places.
2008-12-13 21:05:51 -06:00
dz = (pblock%zmax - pblock%zmin) / kn
More reorganization of the compilation flags. Now the source file can use some of the values defined in make files, like NDIMS. The make files, i.e. makefile, make.default, and host files are simpler and should be easier to manage.
2008-12-08 15:31:35 -06:00
#else /* NDIMS == 3 */
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
dz = 1.0
More reorganization of the compilation flags. Now the source file can use some of the values defined in make files, like NDIMS. The make files, i.e. makefile, make.default, and host files are simpler and should be easier to manage.
2008-12-08 15:31:35 -06:00
#endif /* NDIMS == 3 */
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
! generate coordinates
!
Fixed generation of dx, dy, and dz. The generation of dx, dy, dz for each level didn't include the base grid, i.e. they were 2 times larger. Now it is fixed. Also plenty of minor corrections in different places.
2008-12-13 21:05:51 -06:00
x(:) = ((/(i, i = 1, im)/) - ng - 0.5) * dx + pblock%xmin
y(:) = ((/(j, j = 1, jm)/) - ng - 0.5) * dy + pblock%ymin
More reorganization of the compilation flags. Now the source file can use some of the values defined in make files, like NDIMS. The make files, i.e. makefile, make.default, and host files are simpler and should be easier to manage.
2008-12-08 15:31:35 -06:00
#if NDIMS == 3
Fixed generation of dx, dy, and dz. The generation of dx, dy, dz for each level didn't include the base grid, i.e. they were 2 times larger. Now it is fixed. Also plenty of minor corrections in different places.
2008-12-13 21:05:51 -06:00
z(:) = ((/(k, k = 1, km)/) - ng - 0.5) * dz + pblock%zmin
More reorganization of the compilation flags. Now the source file can use some of the values defined in make files, like NDIMS. The make files, i.e. makefile, make.default, and host files are simpler and should be easier to manage.
2008-12-08 15:31:35 -06:00
#else /* NDIMS == 3 */
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
z(1) = 0.0
More reorganization of the compilation flags. Now the source file can use some of the values defined in make files, like NDIMS. The make files, i.e. makefile, make.default, and host files are simpler and should be easier to manage.
2008-12-08 15:31:35 -06:00
#endif /* NDIMS == 3 */
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
! set variables
!
Added CFL condition and calculation of the new time step. The function to calculate the maximum speed in the block has been added. This function is used to determine the maximum speed globally, which is next used to estimate the next time step.
2008-12-09 14:51:33 -06:00
pblock%u(idn,:,:,:) = dens
Store all variables in one array U. One array U, which is a field in the BLOCK structure, stores all variables. The number of variables is determined by the nvars parameter. To access each variable we use variable index now, like idn, imx, imy, mz, ien, etc.
2008-12-08 12:14:13 -06:00
pblock%u(imx,:,:,:) = 0.0d0
pblock%u(imy,:,:,:) = 0.0d0
pblock%u(imz,:,:,:) = 0.0d0
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
! set initial pressure
!
Fixed generation of dx, dy, and dz. The generation of dx, dy, dz for each level didn't include the base grid, i.e. they were 2 times larger. Now it is fixed. Also plenty of minor corrections in different places.
2008-12-13 21:05:51 -06:00
do k = 1, km
do j = 1, jm
do i = 1, im
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
r = sqrt(x(i)**2 + y(j)**2 + z(k)**2)
if (r .le. 0.1) then
pblock%u(ien,i,j,k) = en
else
pblock%u(ien,i,j,k) = enamb
endif
end do
end do
end do
! deallocate coordinates
!
deallocate(x)
deallocate(y)
deallocate(z)
!-------------------------------------------------------------------------------
!
end subroutine init_blast
!
!===============================================================================
!
! init_implosion: subroutine initializes variables for the implosion problem
!
!===============================================================================
!
subroutine init_implosion(pblock)
use blocks, only : block, idn, imx, imy, imz, ien
use config, only : in, jn, kn, im, jm, km, ng, dens, pres, rmid, gammam1i
! input arguments
!
type(block), pointer, intent(inout) :: pblock
! local variables
!
integer(kind=4), dimension(3) :: dm
integer :: i, j, k
real :: dx, dy, dxh, dyh, rc, rl, ru, ds, dl, dr
! local arrays
!
real, dimension(:), allocatable :: x, y
!
!-------------------------------------------------------------------------------
!
! allocate coordinates
!
allocate(x(im))
allocate(y(jm))
! calculate cell sizes
Added control of refinement/derefinement criterions. Now we can control the levels of refinement/derefinement criterion from the config file. The bounds of the domains are stored in the HDF5 files from now.
2008-12-16 22:34:54 -06:00
!
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
dx = (pblock%xmax - pblock%xmin) / in
dy = (pblock%ymax - pblock%ymin) / jn
dxh = 0.5d0 * dx
dyh = 0.5d0 * dy
ds = dx * dy
Added control of refinement/derefinement criterions. Now we can control the levels of refinement/derefinement criterion from the config file. The bounds of the domains are stored in the HDF5 files from now.
2008-12-16 22:34:54 -06:00
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
! generate coordinates
Added control of refinement/derefinement criterions. Now we can control the levels of refinement/derefinement criterion from the config file. The bounds of the domains are stored in the HDF5 files from now.
2008-12-16 22:34:54 -06:00
!
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
x(:) = ((/(i, i = 1, im)/) - ng) * dx - dxh + pblock%xmin
y(:) = ((/(j, j = 1, jm)/) - ng) * dy - dyh + pblock%ymin
! set variables
!
pblock%u(idn,:,:,:) = dens
pblock%u(imx,:,:,:) = 0.0d0
pblock%u(imy,:,:,:) = 0.0d0
pblock%u(imz,:,:,:) = 0.0d0
The initial refinement completed. I've added 'Z' configuration of the refined block, completed 'N', 'C', 'D', and 'U' configurations. Implemented pointers to the neighbors correctly. Finally, I've implemented correct initial geometry generation, by selection of the blocks to refine, their neightbors if of the lower level, and finally performing the actual refinement.
2008-12-06 20:11:36 -06:00
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
! set initial pressure
!
do j = 1, jm
do i = 1, im
rc = x(i) + y(j)
rl = rc - dxh - dyh
ru = rc + dxh + dyh
if (ru .le. rmid) then
pblock%u(idn,i,j,:) = 0.125d0
#ifdef ADI
pblock%u(ien,i,j,:) = gammam1i * 0.140d0
#endif /* ADI */
else if (rl .ge. rmid) then
pblock%u(idn,i,j,:) = 1.0d0
#ifdef ADI
pblock%u(ien,i,j,:) = gammam1i
#endif /* ADI */
else
if (rc .ge. rmid) then
dl = 0.125d0 * (rmid - rl)**2 / ds
dr = 1.0d0 - dl
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
else
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
dr = 0.125d0 * (ru - rmid)**2 / ds
dl = 1.0d0 - dr
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
endif
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
pblock%u(idn,i,j,:) = 0.125d0 * dl + dr
#ifdef ADI
pblock%u(ien,i,j,:) = gammam1i * (0.140d0 * dl + dr)
#endif /* ADI */
endif
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
end do
end do
! deallocate coordinates
!
deallocate(x)
deallocate(y)
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
!-------------------------------------------------------------------------------
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
!
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
end subroutine init_implosion
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
!
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
!===============================================================================
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
!
Binary stars problem implemented. I've implemented the problem of binary stars to study the colliding winds.
2008-12-18 11:09:42 -06:00
! init_binaries: subroutine initializes the variables for the binary star
! problem
!
!===============================================================================
!
subroutine init_binaries(pblock)
use blocks, only : block, idn, imx, imy, imz, ien
use config, only : ng, in, jn, kn, im, jm, km, dens, pres, dnfac, dnrat &
, x1c, y1c, z1c, r1c, x2c, y2c, z2c, r2c &
, csnd2, gamma, gammam1i
! input arguments
!
type(block), pointer, intent(inout) :: pblock
! local variables
!
integer :: i, j, k
real :: dx, dy, dz, dnamb, enamb
real :: dnstar1, enstar1, x1l, y1l, z1l, r1
real :: dnstar2, enstar2, x2l, y2l, z2l, r2
! local arrays
!
real, dimension(:), allocatable :: x, y, z
!
!-------------------------------------------------------------------------------
!
! calculate pressure from sound speed
!
#ifdef ISO
pres = csnd2 * dens
#endif /* ISO */
#ifdef ADI
pres = csnd2 * dens / gamma
#endif /* ADI */
! calculate parameters
!
dnamb = dens
dnstar2 = dnamb*dnfac
dnstar1 = dnstar2*dnrat
enamb = gammam1i*pres
enstar1 = enamb*dnfac
enstar2 = enstar1/dnrat
! allocate coordinates
!
allocate(x(im))
allocate(y(jm))
allocate(z(km))
! calculate cell sizes
!
dx = (pblock%xmax - pblock%xmin) / in
dy = (pblock%ymax - pblock%ymin) / jn
#if NDIMS == 3
dz = (pblock%zmax - pblock%zmin) / kn
#else /* NDIMS == 3 */
dz = 1.0
#endif /* NDIMS == 3 */
! generate coordinates
!
x(:) = ((/(i, i = 1, im)/) - ng - 0.5) * dx + pblock%xmin
y(:) = ((/(j, j = 1, jm)/) - ng - 0.5) * dy + pblock%ymin
#if NDIMS == 3
z(:) = ((/(k, k = 1, km)/) - ng - 0.5) * dz + pblock%zmin
#else /* NDIMS == 3 */
z(1) = 0.0
#endif /* NDIMS == 3 */
! set variables
!
pblock%u(idn,:,:,:) = dnamb
pblock%u(imx,:,:,:) = 0.0d0
pblock%u(imy,:,:,:) = 0.0d0
pblock%u(imz,:,:,:) = 0.0d0
#ifdef ADI
pblock%u(ien,:,:,:) = enamb
#endif /* ADI */
! set initial pressure
!
do k = 1, km
z1l = z(k) - z1c
z2l = z(k) - z2c
do j = 1, jm
y1l = y(j) - y1c
y2l = y(j) - y2c
do i = 1, im
x1l = x(i) - x1c
x2l = x(i) - x2c
r1 = sqrt(x1l**2 + y1l**2 + z1l**2)
r2 = sqrt(x2l**2 + y2l**2 + z2l**2)
if (r1 .le. r1c) then
pblock%u(idn,i,j,k) = dnstar1
#ifdef ADI
pblock%u(ien,i,j,k) = enstar1
#endif /* ADI */
endif
if (r2 .le. r2c) then
pblock%u(idn,i,j,k) = dnstar2
#ifdef ADI
pblock%u(ien,i,j,k) = enstar2
#endif /* ADI */
endif
end do
end do
end do
! deallocate coordinates
!
deallocate(x)
deallocate(y)
deallocate(z)
!-------------------------------------------------------------------------------
!
end subroutine init_binaries
!
!===============================================================================
!
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
! check_ref: function checks refinement criterium and returns +1 if
! the criterium fullfiled and block is selected for
! refinement, 0 there is no need for refinement, and -1 if
! block is selected for refinement
!
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
!===============================================================================
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
!
function check_ref(pblock)
Initial version of refinement/derefinement is working. It looks like the refining and derefining work more or less, at least without interrupting the execution. Nevertheless, there are still some artifacts, like the lack of symmetry after some time or not efficient derefining of the mesh. This could be cause by the solver, however. The refinement criterion is computed using pressure now.
2008-12-13 15:08:18 -06:00
use blocks, only : block, idn, imx, imy, imz, ien, nv => nvars
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
use config, only : im, jm, km, ib, ie, jb, je, kb, ke, gammam1i &
, crefmin, crefmax
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
! input arguments
!
Play more with the refinements criterion.
2008-12-16 13:40:34 -06:00
type(block), pointer, intent(inout) :: pblock
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
! return variable
!
integer(kind=1) :: check_ref
! local variables
!
integer :: i, j, k
Play more with the refinements criterion.
2008-12-16 13:40:34 -06:00
real :: dpmax, vx, vy, vz, en, ek, ei
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
real :: dnl, dnr, prl, prr, ddndx, ddndy, ddn &
, dprdx, dprdy, dpr
Refinement based on density. More cleanups.
2008-12-13 22:41:37 -06:00
real, dimension(im,jm,km) :: dn, pr
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
!
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
!-------------------------------------------------------------------------------
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
!
Initial version of refinement/derefinement is working. It looks like the refining and derefining work more or less, at least without interrupting the execution. Nevertheless, there are still some artifacts, like the lack of symmetry after some time or not efficient derefining of the mesh. This could be cause by the solver, however. The refinement criterion is computed using pressure now.
2008-12-13 15:08:18 -06:00
do k = 1, km
do j = 1, jm
do i = 1, im
Refinement based on density. More cleanups.
2008-12-13 22:41:37 -06:00
dn(i,j,k) = pblock%u(idn,i,j,k)
vx = pblock%u(imx,i,j,k) / dn(i,j,k)
vy = pblock%u(imy,i,j,k) / dn(i,j,k)
vz = pblock%u(imz,i,j,k) / dn(i,j,k)
Initial version of refinement/derefinement is working. It looks like the refining and derefining work more or less, at least without interrupting the execution. Nevertheless, there are still some artifacts, like the lack of symmetry after some time or not efficient derefining of the mesh. This could be cause by the solver, however. The refinement criterion is computed using pressure now.
2008-12-13 15:08:18 -06:00
en = pblock%u(ien,i,j,k)
Refinement based on density. More cleanups.
2008-12-13 22:41:37 -06:00
ek = 0.5 * dn(i,j,k) * (vx*vx + vy*vy + vz*vz)
Initial version of refinement/derefinement is working. It looks like the refining and derefining work more or less, at least without interrupting the execution. Nevertheless, there are still some artifacts, like the lack of symmetry after some time or not efficient derefining of the mesh. This could be cause by the solver, however. The refinement criterion is computed using pressure now.
2008-12-13 15:08:18 -06:00
ei = en - ek
pr(i,j,k) = gammam1i * ei
end do
end do
end do
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
! check gradient of pressure
!
dpmax = 0.0d0
Initial version of refinement/derefinement is working. It looks like the refining and derefining work more or less, at least without interrupting the execution. Nevertheless, there are still some artifacts, like the lack of symmetry after some time or not efficient derefining of the mesh. This could be cause by the solver, however. The refinement criterion is computed using pressure now.
2008-12-13 15:08:18 -06:00
do k = kb, ke
Play more with the refinements criterion.
2008-12-16 13:40:34 -06:00
do j = jb-1, je+1
do i = ib-1, ie+1
dnl = dn(i-1,j,k)
dnr = dn(i+1,j,k)
ddndx = abs(dnr-dnl)/(dnr+dnl)
dnl = dn(i,j-1,k)
dnr = dn(i,j+1,k)
ddndy = abs(dnr-dnl)/(dnr+dnl)
ddn = sqrt(ddndx**2 + ddndy**2)
prl = pr(i-1,j,k)
prr = pr(i+1,j,k)
dprdx = abs(prr-prl)/(prr+prl)
prl = pr(i,j-1,k)
prr = pr(i,j+1,k)
dprdy = abs(prr-prl)/(prr+prl)
dpr = sqrt(dprdx**2 + dprdy**2)
pblock%c(i,j,k) = max(ddn,dpr)
dpmax = max(dpmax, ddn, dpr)
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
end do
end do
end do
! check condition
!
check_ref = 0
Added control of refinement/derefinement criterions. Now we can control the levels of refinement/derefinement criterion from the config file. The bounds of the domains are stored in the HDF5 files from now.
2008-12-16 22:34:54 -06:00
if (dpmax .ge. crefmax) then
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
check_ref = 1
endif
Added control of refinement/derefinement criterions. Now we can control the levels of refinement/derefinement criterion from the config file. The bounds of the domains are stored in the HDF5 files from now.
2008-12-16 22:34:54 -06:00
if (dpmax .le. crefmin) then
Runge-Kutta 2nd order time integration implemented. In addition, I've done some fixes to the problem initialization, and I defined new variables igrids, jgrids, kgrids, which specify the dimensions of the block.
2008-12-08 16:21:59 -06:00
check_ref = -1
endif
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
return
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
!-------------------------------------------------------------------------------
Added a subroutine to check refinement criterion. A new subroutine 'check_ref' to check the refinement criterion has been added. I've added also a structure of the initial refinement of the mesh.
2008-11-29 22:19:02 -06:00
!
end function check_ref
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
Restructured problem module to allow adding of more problems. Now the subroutine init_problem call the initialization os selected problem determined by the config parameter 'problem'. In this way we can choose problem without recompiling the code.
2008-12-18 10:20:15 -06:00
!===============================================================================
Generation of the initial mesh and problem setup. Implemented the generation of initial blocks in N-configuration with proper ataching to the list, pointer, neighbors and bounds initialization, as well as the initial problem setup. Two new files has been added: mesh.F90 - hadling the adaptive mesh structure, and problem.F90 - handling the problem initialization.
2008-11-11 16:12:26 -06:00
!
end module
Reference in New Issue Copy Permalink