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

2378 lines
61 KiB
Fortran
Raw Normal View History

Update the copyright info and fix the length of separating lines.
2010-10-13 03:32:10 -03:00
!!******************************************************************************
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!!
Change the license to GNU General Public License version 3.
2012-07-22 12:30:20 -03:00
!! This file is part of the AMUN source code, a program to perform
!! Newtonian or relativistic magnetohydrodynamical simulations on uniform or
!! adaptive mesh.
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!!
Change the license to GNU General Public License version 3.
2012-07-22 12:30:20 -03:00
!! Copyright (C) 2008-2012 Grzegorz Kowal <grzegorz@amuncode.org>
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!!
Change the license to GNU General Public License version 3.
2012-07-22 12:30:20 -03:00
!! This program 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.
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!!
Change the license to GNU General Public License, version 2.
2011-04-29 11:21:30 -03:00
!! This program is distributed in the hope that it will be useful,
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!! 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
Change the license to GNU General Public License version 3.
2012-07-22 12:30:20 -03:00
!! along with this program. If not, see <http://www.gnu.org/licenses/>.
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!!
Update the copyright info and fix the length of separating lines.
2010-10-13 03:32:10 -03:00
!!******************************************************************************
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!!
Change the license to GNU General Public License version 3.
2012-07-22 12:30:20 -03:00
!! module: SCHEME - handling the actual solver of the set of equations
!!
!!******************************************************************************
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!
module scheme
implicit none
SCHEME: move cmax parameter from module 'evolution' to 'scheme'.
2010-12-01 13:13:27 -02:00
! the maximal speed in the system
!
real, save :: cmax
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
contains
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef CONSERVATIVE
!
!===============================================================================
!
! update_flux: subroutine sweeps over all directions and calculates the
! numerical fluxes, which is used to update the solution
!
!===============================================================================
!
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
subroutine update_flux(idir, dx, q, f)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
Use variables from COORDINATES in module SCHEME.
2012-07-27 16:06:27 -03:00
use coordinates, only : im, jm, km
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
use variables , only : nqt, nfl
use variables , only : idn, ivx, ivy, ivz, imx, imy, imz
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef ADI
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
use variables , only : ipr, ien
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* ADI */
#ifdef MHD
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
use variables , only : ibx, iby, ibz
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef GLM
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
use variables , only : iph
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* GLM */
#endif /* MHD */
implicit none
! input arguments
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
integer , intent(in) :: idir
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
real , intent(in) :: dx
real, dimension(nqt,im,jm,km), intent(in) :: q
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
real, dimension(nqt,im,jm,km), intent(out) :: f
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
! local variables
!
integer :: i, j, k
! local temporary arrays
!
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
real, dimension(nqt,im) :: qx, fx
real, dimension(nqt,jm) :: qy, fy
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#if NDIMS == 3
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
real, dimension(nqt,km) :: qz, fz
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* NDIMS == 3 */
!
!-------------------------------------------------------------------------------
!
! reset the flux array
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(:,:,:,:) = 0.0d0
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! select the directional flux to compute
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
select case(idir)
case(1)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! calculate the flux along the X-direction
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
do k = 1, km
do j = 1, jm
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
! copy directional vectors of variables for the one dimensional solver
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
do i = 1, im
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
qx(idn,i) = q(idn,i,j,k)
qx(imx,i) = q(ivx,i,j,k)
qx(imy,i) = q(ivy,i,j,k)
qx(imz,i) = q(ivz,i,j,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef ADI
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
qx(ien,i) = q(ien,i,j,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* ADI */
#ifdef MHD
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
qx(ibx,i) = q(ibx,i,j,k)
qx(iby,i) = q(iby,i,j,k)
qx(ibz,i) = q(ibz,i,j,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef GLM
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
qx(iph,i) = q(iph,i,j,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* GLM */
#endif /* MHD */
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
end do
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
! execute solver (returns fluxes for the update)
!
#ifdef HLL
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
call hll (im, dx, qx(:,:), fx(:,:))
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* HLL */
#ifdef HLLC
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
call hllc(im, dx, qx(:,:), fx(:,:))
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* HLLC */
#ifdef HLLD
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
call hlld(im, dx, qx(:,:), fx(:,:))
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* HLLD */
#ifdef ROE
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
call roe (im, dx, qx(:,:), fx(:,:))
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* ROE */
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! insert the flux for a given stencil
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
do i = 1, im
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! fluid variable fluxes
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(idn,i,j,k) = fx(idn,i)
f(imx,i,j,k) = fx(imx,i)
f(imy,i,j,k) = fx(imy,i)
f(imz,i,j,k) = fx(imz,i)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef ADI
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(ien,i,j,k) = fx(ien,i)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* ADI */
#ifdef MHD
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! magnetic field fluxes
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(ibx,i,j,k) = fx(ibx,i)
f(iby,i,j,k) = fx(iby,i)
f(ibz,i,j,k) = fx(ibz,i)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef GLM
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! scalar potential flux
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(iph,i,j,k) = fx(iph,i)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* GLM */
#endif /* MHD */
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
end do
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
end do
end do
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
case(2)
! calculate the flux along the Y direction
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
do k = 1, km
do i = 1, im
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
! copy directional vectors of variables for the one dimensional solver
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
do j = 1, jm
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
qy(idn,j) = q(idn,i,j,k)
qy(ivx,j) = q(ivy,i,j,k)
qy(ivy,j) = q(ivz,i,j,k)
qy(ivz,j) = q(ivx,i,j,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef ADI
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
qy(ien,j) = q(ien,i,j,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* ADI */
#ifdef MHD
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
qy(ibx,j) = q(iby,i,j,k)
qy(iby,j) = q(ibz,i,j,k)
qy(ibz,j) = q(ibx,i,j,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef GLM
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
qy(iph,j) = q(iph,i,j,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* GLM */
#endif /* MHD */
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
end do
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
! execute solver (returns fluxes for the update)
!
#ifdef HLL
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
call hll (jm, dx, qy(:,:), fy(:,:))
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* HLL */
#ifdef HLLC
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
call hllc(jm, dx, qy(:,:), fy(:,:))
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* HLLC */
#ifdef HLLD
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
call hlld(jm, dx, qy(:,:), fy(:,:))
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* HLLD */
#ifdef ROE
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
call roe (jm, dx, qy(:,:), fy(:,:))
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* ROE */
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! insert the flux for a given stencil
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
do j = 1, jm
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! fluid variable fluxes
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(idn,i,j,k) = fy(idn,j)
f(imx,i,j,k) = fy(imz,j)
f(imy,i,j,k) = fy(imx,j)
f(imz,i,j,k) = fy(imy,j)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef ADI
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(ien,i,j,k) = fy(ien,j)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* ADI */
#ifdef MHD
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! magnetic field fluxes
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(ibx,i,j,k) = fy(ibz,j)
f(iby,i,j,k) = fy(ibx,j)
f(ibz,i,j,k) = fy(iby,j)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef GLM
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! scalar potential flux
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(iph,i,j,k) = fy(iph,j)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* GLM */
#endif /* MHD */
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
end do
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
end do
end do
#if NDIMS == 3
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
case(3)
! calculate the flux along the Z direction
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
do j = 1, jm
do i = 1, im
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
! copy directional vectors of variables for the one dimensional solver
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
do k = 1, km
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
qz(idn,k) = q(idn,i,j,k)
qz(ivx,k) = q(ivz,i,j,k)
qz(ivy,k) = q(ivx,i,j,k)
qz(ivz,k) = q(ivy,i,j,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef ADI
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
qz(ien,k) = q(ien,i,j,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* ADI */
#ifdef MHD
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
qz(ibx,k) = q(ibz,i,j,k)
qz(iby,k) = q(ibx,i,j,k)
qz(ibz,k) = q(iby,i,j,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef GLM
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
qz(iph,k) = q(iph,i,j,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* GLM */
#endif /* MHD */
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
end do
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
! execute solver (returns fluxes for the update)
!
#ifdef HLL
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
call hll (km, dx, qz(:,:), fz(:,:))
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* HLL */
#ifdef HLLC
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
call hllc(km, dx, qz(:,:), fz(:,:))
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* HLLC */
#ifdef HLLD
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
call hlld(km, dx, qz(:,:), fz(:,:))
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* HLLD */
#ifdef ROE
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
call roe (km, dx, qz(:,:), fz(:,:))
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* ROE */
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! insert the flux for a given stencil
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
do k = 1, km
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! fluid variable fluxes
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(idn,i,j,k) = fz(idn,k)
f(imx,i,j,k) = fz(imy,k)
f(imy,i,j,k) = fz(imz,k)
f(imz,i,j,k) = fz(imx,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef ADI
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(ien,i,j,k) = fz(ien,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* ADI */
#ifdef MHD
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! magnetic field fluxes
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(ibx,i,j,k) = fz(iby,k)
f(iby,i,j,k) = fz(ibz,k)
f(ibz,i,j,k) = fz(ibx,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#ifdef GLM
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
! scalar potential flux
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
f(iph,i,j,k) = fz(iph,k)
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* GLM */
#endif /* MHD */
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
end do
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
end do
end do
#endif /* NDIMS == 3 */
Calculate directional fluxes in update_flux() only. - instead of calculating all fluxes at once in update_flux(), select the direction as a subroutine argument and calculate only the flux along this direction; - directional fluxes are needed for the directional RK integration of the numerical fluxes; - update subroutines flux_euler(), flux_rk2(), and flux_rk3() to use new update_flux() subroutine;
2011-05-19 18:24:09 -03:00
end select
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
!-------------------------------------------------------------------------------
!
end subroutine update_flux
#else /* CONSERVATIVE */
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!
Update the copyright info and fix the length of separating lines.
2010-10-13 03:32:10 -03:00
!===============================================================================
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
! update: subroutine sweeps over all directions and integrates the directional
! derivatives of the flux in order to get the increment of solution
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!
Update the copyright info and fix the length of separating lines.
2010-10-13 03:32:10 -03:00
!===============================================================================
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!
Revert "INTERPOLATION: pass the spacial increment to reconstruct()." This reverts commit d92ae5d3a62743b66e97c42be4aa5f31ef5993d1.
2010-12-06 16:20:49 -02:00
subroutine update(u, du, dxi, dyi, dzi)
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
Use variables from COORDINATES in module SCHEME.
2012-07-27 16:06:27 -03:00
use coordinates, only : im, jm, km
Move variable indices to new module 'variables'. VARIABLES - create new module 'variables' which stores references to variable indices; we gonna store dofferent objects related to variables in this module;
2010-12-01 09:25:30 -02:00
use variables , only : nvr, nqt, nfl
use variables , only : idn, imx, imy, imz
#ifdef ADI
use variables , only : ien
#endif /* ADI */
#ifdef MHD
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
use variables , only : ibx, iby, ibz
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
#ifdef GLM
use variables , only : iph
#endif /* GLM */
Move variable indices to new module 'variables'. VARIABLES - create new module 'variables' which stores references to variable indices; we gonna store dofferent objects related to variables in this module;
2010-12-01 09:25:30 -02:00
#endif /* MHD */
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
implicit none
! input arguments
!
Revert "INTERPOLATION: pass the spacial increment to reconstruct()." This reverts commit d92ae5d3a62743b66e97c42be4aa5f31ef5993d1.
2010-12-06 16:20:49 -02:00
real, dimension(nqt,im,jm,km) , intent(in) :: u
real, dimension(nqt,im,jm,km) , intent(out) :: du
real , intent(in) :: dxi, dyi, dzi
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
! local variables
!
SCHEME: slightly rewrite subroutine update().
2010-12-11 14:38:34 -02:00
integer :: i, j, k
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
real :: dx, dy, dz
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
! local temporary arrays
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
real, dimension(nvr,im) :: ux
real, dimension(nqt,im) :: fx
real, dimension(nvr,jm) :: uy
real, dimension(nqt,jm) :: fy
#if NDIMS == 3
real, dimension(nvr,km) :: uz
real, dimension(nqt,km) :: fz
#endif /* NDIMS == 3 */
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!-------------------------------------------------------------------------------
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
!
! reset the increment array
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!
du(:,:,:,:) = 0.0
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
! prepare the spacial increment
!
dx = 1.0d0 / dxi
dy = 1.0d0 / dyi
#if NDIMS == 3
dz = 1.0d0 / dzi
#endif /* NDIMS == 3 */
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
! update along X-direction
!
A few bugs fixed. Some reorganization of dimension variables.
2008-12-09 22:28:29 -06:00
do k = 1, km
do j = 1, jm
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
! copy directional vectors of variables for the one dimensional solver
!
A few bugs fixed. Some reorganization of dimension variables.
2008-12-09 22:28:29 -06:00
do i = 1, im
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
ux(idn,i) = u(idn,i,j,k)
ux(imx,i) = u(imx,i,j,k)
ux(imy,i) = u(imy,i,j,k)
ux(imz,i) = u(imz,i,j,k)
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#ifdef ADI
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
ux(ien,i) = u(ien,i,j,k)
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#endif /* ADI */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
ux(ibx,i) = u(ibx,i,j,k)
ux(iby,i) = u(iby,i,j,k)
ux(ibz,i) = u(ibz,i,j,k)
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
#ifdef GLM
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
ux(iph,i) = u(iph,i,j,k)
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
#endif /* GLM */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
end do
! execute solver (returns fluxes for the update)
!
#ifdef HLL
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call hll (im, dx, ux(:,:), fx(:,:))
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#endif /* HLL */
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
#ifdef HLLC
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call hllc(im, dx, ux(:,:), fx(:,:))
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
#endif /* HLLC */
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
#ifdef HLLD
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call hlld(im, dx, ux(:,:), fx(:,:))
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
#endif /* HLLD */
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
#ifdef ROE
call roe (im, dx, ux(:,:), fx(:,:))
#endif /* ROE */
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
! update the arrays of increments
!
A few bugs fixed. Some reorganization of dimension variables.
2008-12-09 22:28:29 -06:00
do i = 1, im
SCHEME: slightly rewrite subroutine update().
2010-12-11 14:38:34 -02:00
! update fluid variables
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
du(idn,i,j,k) = du(idn,i,j,k) + dxi * fx(idn,i)
du(imx,i,j,k) = du(imx,i,j,k) + dxi * fx(imx,i)
du(imy,i,j,k) = du(imy,i,j,k) + dxi * fx(imy,i)
du(imz,i,j,k) = du(imz,i,j,k) + dxi * fx(imz,i)
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#ifdef ADI
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
du(ien,i,j,k) = du(ien,i,j,k) + dxi * fx(ien,i)
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#endif /* ADI */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
SCHEME: slightly rewrite subroutine update().
2010-12-11 14:38:34 -02:00
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
! update magnetic variables
!
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
du(ibx,i,j,k) = du(ibx,i,j,k) + dxi * fx(ibx,i)
du(iby,i,j,k) = du(iby,i,j,k) + dxi * fx(iby,i)
du(ibz,i,j,k) = du(ibz,i,j,k) + dxi * fx(ibz,i)
SCHEME: slightly rewrite subroutine update().
2010-12-11 14:38:34 -02:00
#ifdef GLM
! update scalar potential
!
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
du(iph,i,j,k) = du(iph,i,j,k) + dxi * fx(iph,i)
#endif /* GLM */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
end do
end do
end do
! update along Y-direction
!
A few bugs fixed. Some reorganization of dimension variables.
2008-12-09 22:28:29 -06:00
do k = 1, km
do i = 1, im
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
! copy directional vectors of variables for the one dimensional solver
!
A few bugs fixed. Some reorganization of dimension variables.
2008-12-09 22:28:29 -06:00
do j = 1, jm
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
uy(idn,j) = u(idn,i,j,k)
uy(imx,j) = u(imy,i,j,k)
uy(imy,j) = u(imz,i,j,k)
uy(imz,j) = u(imx,i,j,k)
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#ifdef ADI
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
uy(ien,j) = u(ien,i,j,k)
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#endif /* ADI */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
uy(ibx,j) = u(iby,i,j,k)
uy(iby,j) = u(ibz,i,j,k)
uy(ibz,j) = u(ibx,i,j,k)
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
#ifdef GLM
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
uy(iph,j) = u(iph,i,j,k)
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
#endif /* GLM */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
end do
! execute solver (returns fluxes for the update)
!
#ifdef HLL
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call hll (jm, dy, uy(:,:), fy(:,:))
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#endif /* HLL */
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
#ifdef HLLC
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call hllc(jm, dy, uy(:,:), fy(:,:))
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
#endif /* HLLC */
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
#ifdef HLLD
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call hlld(jm, dy, uy(:,:), fy(:,:))
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
#endif /* HLLD */
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
#ifdef ROE
call roe (jm, dy, uy(:,:), fy(:,:))
#endif /* ROE */
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
! update the arrays of increments
!
A few bugs fixed. Some reorganization of dimension variables.
2008-12-09 22:28:29 -06:00
do j = 1, jm
SCHEME: slightly rewrite subroutine update().
2010-12-11 14:38:34 -02:00
! update fluid variables
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
du(idn,i,j,k) = du(idn,i,j,k) + dyi * fy(idn,j)
du(imx,i,j,k) = du(imx,i,j,k) + dyi * fy(imz,j)
du(imy,i,j,k) = du(imy,i,j,k) + dyi * fy(imx,j)
du(imz,i,j,k) = du(imz,i,j,k) + dyi * fy(imy,j)
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#ifdef ADI
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
du(ien,i,j,k) = du(ien,i,j,k) + dyi * fy(ien,j)
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#endif /* ADI */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
SCHEME: slightly rewrite subroutine update().
2010-12-11 14:38:34 -02:00
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
! update magnetic variables
!
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
du(ibx,i,j,k) = du(ibx,i,j,k) + dyi * fy(ibz,j)
du(iby,i,j,k) = du(iby,i,j,k) + dyi * fy(ibx,j)
du(ibz,i,j,k) = du(ibz,i,j,k) + dyi * fy(iby,j)
SCHEME: slightly rewrite subroutine update().
2010-12-11 14:38:34 -02:00
#ifdef GLM
! update scalar potential
!
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
du(iph,i,j,k) = du(iph,i,j,k) + dyi * fy(iph,j)
#endif /* GLM */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
end do
end do
end do
#if NDIMS == 3
! update along Z-direction
!
A few bugs fixed. Some reorganization of dimension variables.
2008-12-09 22:28:29 -06:00
do j = 1, jm
do i = 1, im
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
! copy directional vectors of variables for the one dimensional solver
!
A few bugs fixed. Some reorganization of dimension variables.
2008-12-09 22:28:29 -06:00
do k = 1, km
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
uz(idn,k) = u(idn,i,j,k)
uz(imx,k) = u(imz,i,j,k)
uz(imy,k) = u(imx,i,j,k)
uz(imz,k) = u(imy,i,j,k)
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#ifdef ADI
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
uz(ien,k) = u(ien,i,j,k)
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#endif /* ADI */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
uz(ibx,k) = u(ibz,i,j,k)
uz(iby,k) = u(ibx,i,j,k)
uz(ibz,k) = u(iby,i,j,k)
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
#ifdef GLM
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
uz(iph,k) = u(iph,i,j,k)
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
#endif /* GLM */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
end do
! execute solver (returns fluxes for the update)
!
#ifdef HLL
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call hll (km, dz, uz(:,:), fz(:,:))
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#endif /* HLL */
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
#ifdef HLLC
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call hllc(km, dz, uz(:,:), fz(:,:))
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
#endif /* HLLC */
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
#ifdef HLLD
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call hlld(km, dz, uz(:,:), fz(:,:))
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
#endif /* HLLD */
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
#ifdef ROE
call roe (km, dz, uz(:,:), fz(:,:))
#endif /* ROE */
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
! update the arrays of increments
!
A few bugs fixed. Some reorganization of dimension variables.
2008-12-09 22:28:29 -06:00
do k = 1, km
SCHEME: slightly rewrite subroutine update().
2010-12-11 14:38:34 -02:00
! update fluid variables
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
du(idn,i,j,k) = du(idn,i,j,k) + dzi * fz(idn,k)
du(imx,i,j,k) = du(imx,i,j,k) + dzi * fz(imy,k)
du(imy,i,j,k) = du(imy,i,j,k) + dzi * fz(imz,k)
du(imz,i,j,k) = du(imz,i,j,k) + dzi * fz(imx,k)
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#ifdef ADI
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
du(ien,i,j,k) = du(ien,i,j,k) + dzi * fz(ien,k)
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
#endif /* ADI */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
SCHEME: slightly rewrite subroutine update().
2010-12-11 14:38:34 -02:00
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
! update magnetic variables
!
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
du(ibx,i,j,k) = du(ibx,i,j,k) + dzi * fz(iby,k)
du(iby,i,j,k) = du(iby,i,j,k) + dzi * fz(ibz,k)
du(ibz,i,j,k) = du(ibz,i,j,k) + dzi * fz(ibx,k)
SCHEME: slightly rewrite subroutine update().
2010-12-11 14:38:34 -02:00
#ifdef GLM
! update scalar potential
!
GLM_MHD: update magnetic field and potential increment. - update the magnetic field component and the scalar potential Psi increments in the subroutine update();
2010-12-01 09:51:12 -02:00
du(iph,i,j,k) = du(iph,i,j,k) + dzi * fz(iph,k)
#endif /* GLM */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
Update sweeps over direction calculating dU. We compute dFdx contribution along each direction and update total dU. Apart from that I've added generation of coordinate variables, like dx, dxi, etc. in the mesh module. The next step is to implement the HLL solver.
2008-12-08 20:03:01 -06:00
end do
end do
end do
#endif /* NDIMS == 3 */
Fix divergence free prolongation and boundary conditions. BOUNDARY CONDITIONS - update boundary conditions starting from the block with the maximum refinement level and stepping down; this fixes update of the boundary conditions in the corners; INTERPOLATION - fix divergence free prolongation of the staggered magnetic field;
2010-03-21 19:05:29 -03:00
!
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!-------------------------------------------------------------------------------
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
!
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
end subroutine update
Add a subroutine to calculate numerical fluxes. - the subroutine update_flux() in the SCHEME module calculates numerical fluxes from the conserved variables; the calculated fluxes are then returned;
2011-04-30 12:28:02 -03:00
#endif /* CONSERVATIVE */
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
#ifdef HLL
!
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!===============================================================================
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
!
SCHEME: remove argument 'd' from the Riemann solvers. - this flag specifies if to return the flux or its spatial derivative; this is not used in the GLM-MHD approach;
2010-12-02 10:14:39 -02:00
! hll: subroutine computes the approximated flux using the HLL method
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
!
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!===============================================================================
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
!
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
subroutine hll(n, h, u, f)
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use interpolations, only : reconstruct
use variables , only : nvr, nfl, nqt
use variables , only : ivx, ivy, ivz
Add viscous and resistive terms for adiabatic EOS. - also slightly optimize the dissipation term calculations;
2011-04-05 00:42:24 +02:00
#ifdef ADI
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use variables , only : ien
Add viscous and resistive terms for adiabatic EOS. - also slightly optimize the dissipation term calculations;
2011-04-05 00:42:24 +02:00
#endif /* ADI */
Boundaries, interpolation, indices. Rewritten boundaries allow for a proper handling boundaries between blocks at different refinement levels. Prolongation and restriction of the boundaries are improved now. Rewritten interpolation for prolongation and restriction. References to the variable indices are assigned more properly.
2010-02-11 23:30:46 -02:00
#ifdef MHD
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use variables , only : ibx, iby, ibz
GLM-MHD: update the numerical fluxes in HLL solver. - reconstruct the states for the magnetic field components and scalar potential just like other fluid variables; - calculate the numerical fluxes for the magnetic field components and scalar potential;
2010-12-01 10:03:00 -02:00
#ifdef GLM
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use variables , only : iph
GLM-MHD: update the numerical fluxes in HLL solver. - reconstruct the states for the magnetic field components and scalar potential just like other fluid variables; - calculate the numerical fluxes for the magnetic field components and scalar potential;
2010-12-01 10:03:00 -02:00
#endif /* GLM */
Boundaries, interpolation, indices. Rewritten boundaries allow for a proper handling boundaries between blocks at different refinement levels. Prolongation and restriction of the boundaries are improved now. Rewritten interpolation for prolongation and restriction. References to the variable indices are assigned more properly.
2010-02-11 23:30:46 -02:00
#endif /* MHD */
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
implicit none
! input/output arguments
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
integer , intent(in) :: n
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
real , intent(in) :: h
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
real, dimension(nvr,n), intent(in) :: u
real, dimension(nqt,n), intent(out) :: f
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
! local variables
!
Add viscous and resistive terms for adiabatic EOS. - also slightly optimize the dissipation term calculations;
2011-04-05 00:42:24 +02:00
integer :: p, i, ip1
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
real, dimension(nvr,n) :: q, ql, qr, ul, ur
real, dimension(nqt,n) :: fl, fr, fn
real, dimension(n) :: cl, cr
real :: al, ar, ap, div
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
!
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!-------------------------------------------------------------------------------
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
! calculate the primitive variables
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
!
SCHEME: slightly rewrite subroutine hll().
2010-12-11 14:32:38 -02:00
call cons2prim(n, u(:,:), q(:,:))
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
! reconstruct the left and right states of the primitive variables
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
do p = 1, nfl
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call reconstruct(n, h, q(p,:), ql(p,:), qr(p,:))
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
end do
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
#ifdef MHD
GLM-MHD: update the numerical fluxes in HLL solver. - reconstruct the states for the magnetic field components and scalar potential just like other fluid variables; - calculate the numerical fluxes for the magnetic field components and scalar potential;
2010-12-01 10:03:00 -02:00
! reconstruct the left and right states of the magnetic field components
!
SCHEME: fix iteration for reconstruction in HLL. - fix the index for reconstruction of magnetic field components in the subroutine HLL;
2010-12-01 12:39:56 -02:00
do p = ibx, ibz
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call reconstruct(n, h, q(p,:), ql(p,:), qr(p,:))
GLM-MHD: update the numerical fluxes in HLL solver. - reconstruct the states for the magnetic field components and scalar potential just like other fluid variables; - calculate the numerical fluxes for the magnetic field components and scalar potential;
2010-12-01 10:03:00 -02:00
end do
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
#ifdef GLM
GLM-MHD: update the numerical fluxes in HLL solver. - reconstruct the states for the magnetic field components and scalar potential just like other fluid variables; - calculate the numerical fluxes for the magnetic field components and scalar potential;
2010-12-01 10:03:00 -02:00
! reconstruct the left and right states of the scalar potential
!
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call reconstruct(n, h, q(iph,:), ql(iph,:), qr(iph,:))
GLM-MHD: obtain the states for Bx and Psi. - in the GLM-MHD set of equations variables Bx and Psi are couples, thus find their values and substitute to the left and right states before entering the approximate Riemann solver;
2010-12-01 13:27:01 -02:00
! obtain the state values for Bx and Psi for the GLM-MHD equations
!
cl(:) = 0.5d0 * ((qr(ibx,:) + ql(ibx,:)) - (qr(iph,:) - ql(iph,:)) / cmax)
cr(:) = 0.5d0 * ((qr(iph,:) + ql(iph,:)) - (qr(ibx,:) - ql(ibx,:)) * cmax)
ql(ibx,:) = cl(:)
qr(ibx,:) = cl(:)
ql(iph,:) = cr(:)
qr(iph,:) = cr(:)
GLM-MHD: update the numerical fluxes in HLL solver. - reconstruct the states for the magnetic field components and scalar potential just like other fluid variables; - calculate the numerical fluxes for the magnetic field components and scalar potential;
2010-12-01 10:03:00 -02:00
#endif /* GLM */
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
#endif /* MHD */
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
! calculate conservative variables at states
!
SCHEME: slightly rewrite subroutine hll().
2010-12-11 14:32:38 -02:00
call prim2cons(n, ql(:,:), ul(:,:))
call prim2cons(n, qr(:,:), ur(:,:))
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
! calculate fluxes and speeds
!
SCHEME: slightly rewrite subroutine hll().
2010-12-11 14:32:38 -02:00
call fluxspeed(n, ql(:,:), ul(:,:), fl(:,:), cl(:))
call fluxspeed(n, qr(:,:), ur(:,:), fr(:,:), cr(:))
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
! iterate over all points
!
do i = 1, n
! calculate min and max and intermediate speeds: eq. (67)
!
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
al = min(ql(ivx,i) - cl(i), qr(ivx,i) - cr(i))
ar = max(ql(ivx,i) + cl(i), qr(ivx,i) + cr(i))
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
! calculate HLL flux
!
SCHEME: small corrections in subroutine hll().
2010-12-12 21:54:29 -02:00
if (al .ge. 0.0d0) then
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
fn(:,i) = fl(:,i)
SCHEME: small corrections in subroutine hll().
2010-12-12 21:54:29 -02:00
else if (ar .le. 0.0d0) then
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
fn(:,i) = fr(:,i)
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
else
ap = ar * al
SCHEME: small corrections in subroutine hll().
2010-12-12 21:54:29 -02:00
div = 1.0d0 / (ar - al)
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
SCHEME: fix iteration for reconstruction in HLL. - fix the index for reconstruction of magnetic field components in the subroutine HLL;
2010-12-01 12:39:56 -02:00
fn(:,i) = div * (ar * fl(:,i) - al * fr(:,i) + ap * (ur(:,i) - ul(:,i)))
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
end if
end do
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
Return fluxes instead of their derivatives if CONSERVATIVE=Y. - if the flag CONSERVATIVE is enable, we need to return the numerical fluxes instead of their derivatives; the directional derivatives are calculated after sunchronization of the flux;
2011-04-30 12:49:29 -03:00
#ifdef CONSERVATIVE
! return numerica flux at i+1/2
!
f( : , : ) = fn( : , : )
#else /* CONSERVATIVE */
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
! calculate numerical flux
!
Add viscous and resistive terms for adiabatic EOS. - also slightly optimize the dissipation term calculations;
2011-04-05 00:42:24 +02:00
f( 1:nfl,2:n) = - fn( 1:nfl,2:n) + fn( 1:nfl,1:n-1)
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
Add viscous and resistive terms for adiabatic EOS. - also slightly optimize the dissipation term calculations;
2011-04-05 00:42:24 +02:00
f(ibx:ibz,2:n) = - fn(ibx:ibz,2:n) + fn(ibx:ibz,1:n-1)
Fix a bug introduced in 58cfb07e9ab54a0cb77775f78bdb9e6105c89309. - the order of flags CONSERVATIVE was wrong in the subroutines calculating numerical fluxes;
2011-05-01 16:56:34 -03:00
#ifdef GLM
Add viscous and resistive terms for adiabatic EOS. - also slightly optimize the dissipation term calculations;
2011-04-05 00:42:24 +02:00
f(iph ,2:n) = - fn(iph ,2:n) + fn(iph ,1:n-1)
GLM-MHD: fix the preprocessor flag.
2010-12-01 10:07:06 -02:00
#endif /* GLM */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
Return fluxes instead of their derivatives if CONSERVATIVE=Y. - if the flag CONSERVATIVE is enable, we need to return the numerical fluxes instead of their derivatives; the directional derivatives are calculated after sunchronization of the flux;
2011-04-30 12:49:29 -03:00
#endif /* CONSERVATIVE */
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!-------------------------------------------------------------------------------
Implement HLL flux approximation. The most general HLL flux approximation has been implemented.
2008-12-08 20:16:37 -06:00
!
end subroutine hll
#endif /* HLL */
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
#ifdef HLLC
!===============================================================================
!
! hllc: subroutine to compute flux approximated by HLLC method (HYDRO only)
! ([1] Batten et al., 1997, JSC, 18, 6, 1553)
! ([2] Miyoshi & Kusano, 2005, JCP, 208, 315)
!
!===============================================================================
!
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
subroutine hllc(n, h, q, f)
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use interpolations, only : reconstruct
use variables , only : nvr, nfl, nqt
use variables , only : idn, imx, imy, imz, ien, ivx, ivy, ivz, ipr
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
implicit none
! input/output arguments
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
integer , intent(in) :: n
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
real , intent(in) :: h
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
real, dimension(nvr,n), intent(in) :: q
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
real, dimension(nqt,n), intent(out) :: f
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
! local variables
!
Add viscous and resistive terms for adiabatic EOS. - also slightly optimize the dissipation term calculations;
2011-04-05 00:42:24 +02:00
integer :: p, i, ip1
Use primitive variables in the Riemann solvers. There is no need to convert conservative variables to primitive ones, since they are already up to date, so pass primitive variables directly to Riemann solvers in subroutine update_flux().
2012-07-31 16:49:14 -03:00
real, dimension(nvr,n) :: ql, qr, ul, ur
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
real, dimension(nfl,n) :: fl, fr, fn
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
real, dimension(n) :: cl, cr, cm
real :: sl, sr, sm, sml, smr, srmv, slmv, srmm, slmm &
, smvl, smvr, div, pt
real, dimension(nvr) :: q1l, q1r, u1l, u1r
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
Update the copyright info and fix the length of separating lines.
2010-10-13 03:32:10 -03:00
!-------------------------------------------------------------------------------
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
! reconstruct the left and right states of the primitive variables
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
do p = 1, nfl
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call reconstruct(n, h, q(p,:), ql(p,:), qr(p,:))
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
end do
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
! obtain the conservative variables at both states
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
call prim2cons(n, ql(:,:), ul(:,:))
call prim2cons(n, qr(:,:), ur(:,:))
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
! calculate the physical fluxes and speeds
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
call fluxspeed(n, ql(:,:), ul(:,:), fl(:,:), cl(:))
call fluxspeed(n, qr(:,:), ur(:,:), fr(:,:), cr(:))
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
! iterate along the direction
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
do i = 1, n
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
! calculate the minimum and maxximum speeds
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
sl = min(ql(ivx,i) - cl(i), qr(ivx,i) - cr(i))
sr = max(ql(ivx,i) + cl(i), qr(ivx,i) + cr(i))
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
! all speeds >= 0, left side flux
!
if (sl .ge. 0.0) then
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
fn(:,i) = fl(:,i)
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
! all speeds <= 0, right side flux
!
else if (sr .le. 0.0) then
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
fn(:,i) = fr(:,i)
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
! intermediate states
!
else ! sl < 0 & sr > 0
! useful differences
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
slmv = sl - ql(ivx,i)
srmv = sr - qr(ivx,i)
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
! speed of the contact discontinuity (eq. 34 [1], 14 [2])
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
div = srmv * qr(idn,i) - slmv * ql(idn,i)
sml = (srmv * ur(imx,i) - slmv * ul(imx,i) &
- qr(ipr,i) + ql(ipr,i)) / div
div = slmv * ql(idn,i) - srmv * qr(idn,i)
smr = (slmv * ul(imx,i) - srmv * ur(imx,i) &
- ql(ipr,i) + qr(ipr,i)) / div
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
sm = 0.5d0 * (sml + smr)
if (sm .eq. 0.0d0) then
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
! calculate the left intermediate state
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
pt = ql(ipr,i) - ul(imx,i) * slmv
u1l(idn) = ql(idn,i) * slmv / sl
u1l(imx) = 0.0d0
u1l(imy) = u1l(idn) * ql(ivy,i)
u1l(imz) = u1l(idn) * ql(ivz,i)
if (sl .eq. 0.0d0) then
u1l(ien) = ul(ien,i)
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
else
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
u1l(ien) = (slmv * ul(ien,i) - ql(ipr,i) * ql(ivx,i)) / sl
end if
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
! calculate right intermediate state
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
pt = qr(ipr,i) - ur(imx,i) * srmv
u1r(idn) = qr(idn,i) * srmv / sr
u1r(imx) = 0.0d0
u1r(imy) = u1r(idn) * qr(ivy,i)
u1r(imz) = u1r(idn) * qr(ivz,i)
if (sr .eq. 0.0d0) then
u1r(ien) = ur(ien,i)
else
u1r(ien) = (srmv * ur(ien,i) - qr(ipr,i) * qr(ivx,i)) / sr
endif
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
! calculate intermediate flux
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
fn(:,i) = 0.5d0 * (fl(:,i) + sl * (u1l(:) - ul(:,i)) &
+ fr(:,i) + sr * (u1r(:) - ur(:,i)))
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
else
! useful differences
!
slmm = sl - sm
srmm = sr - sm
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
smvl = sm - ql(ivx,i)
smvr = sm - qr(ivx,i)
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
! intermediate discontinuities
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
if (sm .gt. 0.0d0) then
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
! pressure of intermediate states (eq. 36 [1], 16 [2])
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
pt = ql(ipr,i) + ql(idn,i) * slmv * smvl
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
! calculate the left intermediate state
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
u1l(idn) = ql(idn,i) * slmv / slmm
u1l(imx) = u1l(idn) * sm
u1l(imy) = u1l(idn) * ql(ivy,i)
u1l(imz) = u1l(idn) * ql(ivz,i)
if (slmm .eq. 0.0d0) then
u1l(ien) = ul(ien,i)
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
else
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
u1l(ien) = (slmv * ul(ien,i) - ql(ipr,i) * ql(ivx,i) &
+ pt * sm) / slmm
end if
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
! calculate the left intermediate flux
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
fn(:,i) = fl(:,i) + sl * (u1l(:) - ul(:,i))
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
else if (sm .lt. 0.0) then
! pressure of intermediate states (eq. 36 [1], 16 [2])
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
pt = qr(ipr,i) + qr(idn,i) * srmv * smvr
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
! calculate the right intermediate state
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
u1r(idn) = qr(idn,i) * srmv / srmm
u1r(imx) = u1r(idn) * sm
u1r(imy) = u1r(idn) * qr(ivy,i)
u1r(imz) = u1r(idn) * qr(ivz,i)
if (srmm .eq. 0.0d0) then
u1r(ien) = ur(ien,i)
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
else
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
u1r(ien) = (srmv * ur(ien,i) - qr(ipr,i) * qr(ivx,i) &
+ pt * sm) / srmm
end if
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
! calculate the right intermediate flux
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
fn(:,i) = fr(:,i) + sr * (u1r(:) - ur(:,i))
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
end if
end if
end if
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
end do
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
Return fluxes instead of their derivatives if CONSERVATIVE=Y. - if the flag CONSERVATIVE is enable, we need to return the numerical fluxes instead of their derivatives; the directional derivatives are calculated after sunchronization of the flux;
2011-04-30 12:49:29 -03:00
#ifdef CONSERVATIVE
! return numerica flux at i+1/2
!
f(:, : ) = fn(:, : )
#else /* CONSERVATIVE */
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
! calculate numerical flux
!
SCHEME: rewrite the HLLC Riemann solver. - rewrite the HLLC hydrodynamic Riemann solver; - also add more conditions for compilation flags;
2010-12-03 16:29:28 -02:00
f(:,2:n) = - fn(:,2:n) + fn(:,1:n-1)
Return fluxes instead of their derivatives if CONSERVATIVE=Y. - if the flag CONSERVATIVE is enable, we need to return the numerical fluxes instead of their derivatives; the directional derivatives are calculated after sunchronization of the flux;
2011-04-30 12:49:29 -03:00
#endif /* CONSERVATIVE */
HLLC solver implemented. The HLLC solver is implemented now. It resolves contact discontinuities properly. A small adjustment to the criterion has been done too.
2008-12-16 14:38:04 -06:00
!-------------------------------------------------------------------------------
!
end subroutine hllc
#endif /* HLLC */
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
#ifdef MHD
#ifdef HLLD
#ifdef ISO
!
!===============================================================================
!
! hlld: subroutine computes the approximated flux using the HLLD method
! for the isothermal equation of state
!
!===============================================================================
!
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
subroutine hlld(n, h, u, f)
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use interpolations, only : reconstruct
use variables , only : nvr, nfl, nqt
use variables , only : idn, imx, imy, imz, ivx, ivy, ivz
use variables , only : ibx, iby, ibz
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
#ifdef GLM
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use variables , only : iph
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
#endif /* GLM */
implicit none
! input/output arguments
!
integer , intent(in) :: n
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
real , intent(in) :: h
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
real, dimension(nvr,n), intent(in) :: u
real, dimension(nqt,n), intent(out) :: f
! local variables
!
Add viscous and resistive terms for adiabatic EOS. - also slightly optimize the dissipation term calculations;
2011-04-05 00:42:24 +02:00
integer :: p, i, ip1
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
real, dimension(nvr,n) :: q, ql, qr, ul, ur
real, dimension(nqt,n) :: fl, fr, fn
real, dimension(n) :: cl, cr
real, dimension(nvr) :: u1l, u1r, u2
real :: sl, sr, srl, srml, sm, sml, smr
real :: dnm, mxm, sqd, div, fac, bxs
!
!-------------------------------------------------------------------------------
!
! calculate the primitive variables
!
call cons2prim(n, u, q)
! reconstruct the left and right states of the primitive variables
!
do p = 1, nfl
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call reconstruct(n, h, q(p,:), ql(p,:), qr(p,:))
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
end do
! reconstruct the left and right states of the magnetic field components
!
do p = ibx, ibz
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call reconstruct(n, h, q(p,:), ql(p,:), qr(p,:))
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
end do
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
#ifdef GLM
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
! reconstruct the left and right states of the scalar potential
!
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call reconstruct(n, h, q(iph,:), ql(iph,:), qr(iph,:))
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
! obtain the state values for Bx and Psi for the GLM-MHD equations
!
cl(:) = 0.5d0 * ((qr(ibx,:) + ql(ibx,:)) - (qr(iph,:) - ql(iph,:)) / cmax)
cr(:) = 0.5d0 * ((qr(iph,:) + ql(iph,:)) - (qr(ibx,:) - ql(ibx,:)) * cmax)
ql(ibx,:) = cl(:)
qr(ibx,:) = cl(:)
ql(iph,:) = cr(:)
qr(iph,:) = cr(:)
#endif /* GLM */
! calculate conservative variables at states
!
call prim2cons(n, ql, ul)
call prim2cons(n, qr, ur)
! calculate fluxes and speeds
!
call fluxspeed(n, ql, ul, fl, cl)
call fluxspeed(n, qr, ur, fr, cr)
! iterate over all points and calculate the HLLD flux
!
do i = 1, n
! calculate min and max and intermediate speeds: eq. (67)
!
sl = min(ql(ivx,i) - cl(i), qr(ivx,i) - cr(i))
sr = max(ql(ivx,i) + cl(i), qr(ivx,i) + cr(i))
! all speeds > 0, left side flux
!
if (sl .ge. 0.0) then
fn(:,i) = fl(:,i)
! all speeds < 0, right side flux
!
else if (sr .le. 0.0) then
fn(:,i) = fr(:,i)
! intermediate states
!
else ! sl < 0 & sr > 0
! product and difference of speeds
!
srl = sr * sl
srml = sr - sl
! density of the intermediate state (eq. 20 and 21)
!
dnm = (sr * ur(idn,i) - sl * ul(idn,i) - fr(idn,i) + fl(idn,i)) / srml
mxm = (sr * ur(imx,i) - sl * ul(imx,i) - fr(imx,i) + fl(imx,i)) / srml
sqd = sqrt(dnm)
! fluxes for density and x-momentum are the same for all intermediate states (eq. 22 and 23)
!
fn(idn,i) = (sr * fl(idn,i) - sl * fr(idn,i) &
+ srl * (ur(idn,i) - ul(idn,i))) / srml
fn(imx,i) = (sr * fl(imx,i) - sl * fr(imx,i) &
+ srl * (ur(imx,i) - ul(imx,i))) / srml
#ifdef GLM
! fluxes for parallel magnetic component and the scalar potential is the same
! as well
fn(ibx,i) = (sr * fl(ibx,i) - sl * fr(ibx,i) &
+ srl * (ur(ibx,i) - ul(ibx,i))) / srml
fn(iph,i) = (sr * fl(iph,i) - sl * fr(iph,i) &
+ srl * (ur(iph,i) - ul(iph,i))) / srml
#endif /* GLM */
! the speed of contact discontinuity (from eq. 15 and eq. 17)
!
sm = fn(idn,i) / dnm
! Alfven speeds (eq. 29)
!
sml = sm - abs(ql(ibx,i)) / sqd
smr = sm + abs(qr(ibx,i)) / sqd
! calculate the left intermediate state
!
u1l(idn) = dnm
u1l(imx) = mxm
div = (sl - sml) * (sl - smr)
if (sm .eq. ql(ivx,i) .or. div .eq. 0.0 .or. ql(ibx,i) .eq. 0.0) then
u1l(imy) = dnm * ql(ivy,i)
u1l(imz) = dnm * ql(ivz,i)
u1l(iby) = ql(iby,i)
u1l(ibz) = ql(ibz,i)
else
fac = ql(ibx,i) * (sm - ql(ivx,i)) / div
u1l(imy) = dnm * ql(ivy,i) - ql(iby,i) * fac
u1l(imz) = dnm * ql(ivz,i) - ql(ibz,i) * fac
fac = (ql(idn,i) * (sl - ql(ivx,i))**2 - ql(ibx,i)**2) &
/ (dnm * div)
u1l(iby) = ql(iby,i) * fac
u1l(ibz) = ql(ibz,i) * fac
end if
! calculate the right intermediate state
!
u1r(idn) = dnm
u1r(imx) = mxm
div = (sr - sml) * (sr - smr)
if (sm .eq. qr(ivx,i) .or. div .eq. 0.0 .or. qr(ibx,i) .eq. 0.0) then
u1r(imy) = dnm * qr(ivy,i)
u1r(imz) = dnm * qr(ivz,i)
u1r(iby) = qr(iby,i)
u1r(ibz) = qr(ibz,i)
else
fac = qr(ibx,i) * (sm - qr(ivx,i)) / div
u1r(imy) = dnm * qr(ivy,i) - qr(iby,i) * fac
u1r(imz) = dnm * qr(ivz,i) - qr(ibz,i) * fac
fac = (qr(idn,i) * (sr - qr(ivx,i))**2 - qr(ibx,i)**2) &
/ (dnm * div)
u1r(iby) = qr(iby,i) * fac
u1r(ibz) = qr(ibz,i) * fac
end if
! intermediate discontinuities
!
if (sml .ge. 0.0) then
! calculate the left intermediate flux
!
fn(imy,i) = fl(imy,i) + sl * (u1l(imy) - ul(imy,i)) ! eq. (38)
fn(imz,i) = fl(imz,i) + sl * (u1l(imz) - ul(imz,i))
fn(iby,i) = fl(iby,i) + sl * (u1l(iby) - ul(iby,i))
fn(ibz,i) = fl(ibz,i) + sl * (u1l(ibz) - ul(ibz,i))
else if (smr .le. 0.0) then
! calculate right intermediate flux
!
fn(imy,i) = fr(imy,i) + sr * (u1r(imy) - ur(imy,i)) ! eq. (38)
fn(imz,i) = fr(imz,i) + sr * (u1r(imz) - ur(imz,i))
fn(iby,i) = fr(iby,i) + sr * (u1r(iby) - ur(iby,i))
fn(ibz,i) = fr(ibz,i) + sr * (u1r(ibz) - ur(ibz,i))
else ! sml < 0 & smr > 0
! normal component of magnetic field multiplied by sqrt(dnm)
!
if (ql(ibx,i) .ge. 0.0) then
bxs = sqd
else
bxs = - sqd
end if
! calculate the intermediate state (eq. 34-37)
!
u2(imy) = 0.5d0 * (u1r(imy) + u1l(imy) + bxs * (u1r(iby) - u1l(iby)))
u2(imz) = 0.5d0 * (u1r(imz) + u1l(imz) + bxs * (u1r(ibz) - u1l(ibz)))
u2(iby) = 0.5d0 * (u1r(iby) + u1l(iby) + (u1r(imy) - u1l(imy)) / bxs)
u2(ibz) = 0.5d0 * (u1r(ibz) + u1l(ibz) + (u1r(imz) - u1l(imz)) / bxs)
! calculate the intermediate flux (eq. 24)
!
fn(imy,i) = sm * u2(imy) - ql(ibx,i) * u2(iby)
fn(imz,i) = sm * u2(imz) - ql(ibx,i) * u2(ibz)
fn(iby,i) = sm * u2(iby) - ql(ibx,i) * u2(imy) / dnm
fn(ibz,i) = sm * u2(ibz) - ql(ibx,i) * u2(imz) / dnm
end if
end if
end do
Return fluxes instead of their derivatives if CONSERVATIVE=Y. - if the flag CONSERVATIVE is enable, we need to return the numerical fluxes instead of their derivatives; the directional derivatives are calculated after sunchronization of the flux;
2011-04-30 12:49:29 -03:00
#ifdef CONSERVATIVE
! return numerica flux at i+1/2
!
f( : , : ) = fn( : , : )
#else /* CONSERVATIVE */
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
! calculate numerical flux
!
f( 1:nfl,2:n) = - fn( 1:nfl,2:n) + fn( 1:nfl,1:n-1)
f(ibx:ibz,2:n) = - fn(ibx:ibz,2:n) + fn(ibx:ibz,1:n-1)
#ifdef GLM
f(iph ,2:n) = - fn(iph ,2:n) + fn(iph ,1:n-1)
#endif /* GLM */
Return fluxes instead of their derivatives if CONSERVATIVE=Y. - if the flag CONSERVATIVE is enable, we need to return the numerical fluxes instead of their derivatives; the directional derivatives are calculated after sunchronization of the flux;
2011-04-30 12:49:29 -03:00
#endif /* CONSERVATIVE */
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
!-------------------------------------------------------------------------------
!
end subroutine hlld
#endif /* ISO */
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
#ifdef ADI
!
!===============================================================================
!
! hlld: subroutine computes the approximated flux using the HLLD method
! for the adiabatic equation of state
!
!===============================================================================
!
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
subroutine hlld(n, h, u, f)
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use equations , only : gamma
use interpolations, only : reconstruct
use variables , only : nvr, nfl, nqt
use variables , only : idn, imx, imy, imz, ien, ivx, ivy, ivz, ipr
use variables , only : ibx, iby, ibz
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
#ifdef GLM
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use variables , only : iph
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
#endif /* GLM */
implicit none
! input/output arguments
!
integer , intent(in) :: n
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
real , intent(in) :: h
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
real, dimension(nvr,n), intent(in) :: u
real, dimension(nqt,n), intent(out) :: f
! local variables
!
Add viscous and resistive terms for adiabatic EOS. - also slightly optimize the dissipation term calculations;
2011-04-05 00:42:24 +02:00
integer :: p, i, ip1
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
real, dimension(nvr,n) :: q, ql, qr, ul, ur
real, dimension(nqt,n) :: fl, fr, fn
real, dimension(n) :: cl, cr
real, dimension(nvr) :: u1l, u1r, u2, q1l, q1r, q2
real :: sl, sr, slmv, srmv, slmm, srmm, sm, smvl, smvr &
, sml, smr
real :: ptl, ptr, pt, bx2, div, fac, bxs, dlsq, drsq
!
!-------------------------------------------------------------------------------
!
! calculate the primitive variables
!
call cons2prim(n, u, q)
! reconstruct the left and right states of the primitive variables
!
do p = 1, nfl
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call reconstruct(n, h, q(p,:), ql(p,:), qr(p,:))
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
end do
! reconstruct the left and right states of the magnetic field components
!
do p = ibx, ibz
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call reconstruct(n, h, q(p,:), ql(p,:), qr(p,:))
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
end do
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
#ifdef GLM
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
! reconstruct the left and right states of the scalar potential
!
INTERPOLATION: pass dx to the reconstruction. - the spacial increment is required by some interpolation methods, so pass it to the subroutine reconstruct();
2010-12-06 16:27:49 -02:00
call reconstruct(n, h, q(iph,:), ql(iph,:), qr(iph,:))
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
! obtain the state values for Bx and Psi for the GLM-MHD equations
!
cl(:) = 0.5d0 * ((qr(ibx,:) + ql(ibx,:)) - (qr(iph,:) - ql(iph,:)) / cmax)
cr(:) = 0.5d0 * ((qr(iph,:) + ql(iph,:)) - (qr(ibx,:) - ql(ibx,:)) * cmax)
ql(ibx,:) = cl(:)
qr(ibx,:) = cl(:)
ql(iph,:) = cr(:)
qr(iph,:) = cr(:)
#endif /* GLM */
! calculate conservative variables at states
!
call prim2cons(n, ql, ul)
call prim2cons(n, qr, ur)
! calculate fluxes and speeds
!
call fluxspeed(n, ql, ul, fl, cl)
call fluxspeed(n, qr, ur, fr, cr)
! iterate over all points and calculate the HLLD flux
!
do i = 1, n
! calculate min and max and intermediate speeds: eq. (67)
!
sl = min(ql(ivx,i) - cl(i), qr(ivx,i) - cr(i))
sr = max(ql(ivx,i) + cl(i), qr(ivx,i) + cr(i))
! all speeds > 0, left side flux
!
if (sl .ge. 0.0) then
fn(:,i) = fl(:,i)
! all speeds < 0, right side flux
!
else if (sr .le. 0.0) then
fn(:,i) = fr(:,i)
! intermediate states
!
else ! sl < 0 & sr > 0
! calculate the total left and right pressures
!
SCHEME: small fixes in the adiabatic HLLD solver.
2010-12-03 12:27:53 -02:00
ptl = ql(ipr,i) + 0.5d0 * sum(ql(ibx:ibz,i)**2)
ptr = qr(ipr,i) + 0.5d0 * sum(qr(ibx:ibz,i)**2)
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
! useful speed differences
!
slmv = sl - ql(ivx,i)
srmv = sr - qr(ivx,i)
! the speed of contact discontinuity (eq. 38, average from the both states)
!
div = slmv * ql(idn,i) - srmv * qr(idn,i)
slmm = (slmv * ul(imx,i) - srmv * ur(imx,i) - ptl + ptr) / div
div = srmv * qr(idn,i) - slmv * ql(idn,i)
srmm = (srmv * ur(imx,i) - slmv * ul(imx,i) - ptr + ptl) / div
sm = 0.5d0 * (slmm + srmm)
! more useful speed differences
!
slmm = sl - sm
srmm = sr - sm
smvl = sm - ql(ivx,i)
smvr = sm - qr(ivx,i)
bx2 = ql(ibx,i) * qr(ibx,i)
! pressure of the intermediate states (eq. 41)
!
pt = 0.5d0 * (ptl + ptr + ql(idn,i) * slmv * smvl &
+ qr(idn,i) * srmv * smvr)
! calculate the left intermediate state variables
!
q1l(idn) = ql(idn,i) * slmv / slmm
q1l(ivx) = sm
q1l(ibx) = ql(ibx,i)
div = ql(idn,i) * slmv * slmm - bx2
if ((sm .eq. ql(ivx,i)) .or. (div .eq. 0.0) &
.or. (bx2 .ge. gamma * ql(ipr,i)) &
.or. (sl .eq. (ql(ivx,i) + cl(i))) &
.or. (sl .eq. (ql(ivx,i) - cl(i)))) then
q1l(ivy) = ql(ivy,i)
q1l(ivz) = ql(ivz,i)
q1l(iby) = ql(iby,i)
q1l(ibz) = ql(ibz,i)
else
fac = ql(ibx,i) * smvl / div
q1l(ivy) = ql(ivy,i) - ql(iby,i) * fac
q1l(ivz) = ql(ivz,i) - ql(ibz,i) * fac
fac = (ql(idn,i) * slmv**2 - bx2) / div
q1l(iby) = ql(iby,i) * fac
q1l(ibz) = ql(ibz,i) * fac
end if
! convert the left intermediate state to the conservative form
!
u1l(idn) = q1l(idn)
u1l(imx) = q1l(idn) * q1l(ivx)
u1l(imy) = q1l(idn) * q1l(ivy)
u1l(imz) = q1l(idn) * q1l(ivz)
if (slmm .ne. 0.0) then
u1l(ien) = (slmv * ul(ien,i) - ptl * ql(ivx,i) + pt * sm &
+ ql(ibx,i) * (sum(ql(ivx:ivz,i) * ql(ibx:ibz,i)) &
- sum(q1l(ivx:ivz) * q1l(ibx:ibz)))) / slmm
else
u1l(ien) = ul(ien,i)
end if
u1l(ibx) = q1l(ibx)
u1l(iby) = q1l(iby)
u1l(ibz) = q1l(ibz)
#ifdef GLM
u1l(iph) = ul(iph,i)
#endif /* GLM */
! calculate the right intermediate state variables
!
q1r(idn) = qr(idn,i) * srmv / srmm
q1r(ivx) = sm
q1r(ibx) = qr(ibx,i)
div = qr(idn,i) * srmv * srmm - bx2
if ((sm .eq. qr(ivx,i)) .or. (div .eq. 0.0) &
.or. (bx2 .ge. gamma * qr(ipr,i)) &
.or. (sr .eq. (qr(ivx,i) + cr(i))) &
.or. (sr .eq. (qr(ivx,i) - cr(i)))) then
q1r(ivy) = qr(ivy,i)
q1r(ivz) = qr(ivz,i)
q1r(iby) = qr(iby,i)
q1r(ibz) = qr(ibz,i)
else
fac = qr(ibx,i) * smvr / div
q1r(ivy) = qr(ivy,i) - qr(iby,i) * fac
q1r(ivz) = qr(ivz,i) - qr(ibz,i) * fac
fac = (qr(idn,i) * srmv**2 - bx2) / div
q1r(iby) = qr(iby,i) * fac
q1r(ibz) = qr(ibz,i) * fac
end if
! convert the right intermediate state to the conservative form
!
u1r(idn) = q1r(idn)
u1r(imx) = q1r(idn) * q1r(ivx)
u1r(imy) = q1r(idn) * q1r(ivy)
u1r(imz) = q1r(idn) * q1r(ivz)
if (srmm .ne. 0.0) then
u1r(ien) = (srmv * ur(ien,i) - ptr * qr(ivx,i) + pt * sm &
+ qr(ibx,i) * (sum(qr(ivx:ivz,i) * qr(ibx:ibz,i)) &
- sum(q1r(ivx:ivz) * q1r(ibx:ibz)))) / srmm
else
u1r(ien) = ur(ien,i)
end if
u1r(ibx) = q1r(ibx)
u1r(iby) = q1r(iby)
u1r(ibz) = q1r(ibz)
#ifdef GLM
u1r(iph) = ur(iph,i)
#endif /* GLM */
! Alfven speeds (eq. 51)
!
sml = sm - abs(ql(ibx,i)) / sqrt(q1l(idn))
smr = sm + abs(qr(ibx,i)) / sqrt(q1r(idn))
! intermediate discontinuities
!
if (sml .ge. 0.0d0) then
! calculate the left intermediate flux
!
fn(:,i) = fl(:,i) + sl * (u1l(:) - ul(:,i))
else if (smr .le. 0.0d0) then
! calculate the right intermediate flux
!
fn(:,i) = fr(:,i) + sr * (u1r(:) - ur(:,i))
else ! sml < 0 & smr > 0
! obtain the normal component of magnetic field
!
if (ql(ibx,i) .gt. 0.0d0) then
bxs = 1.0d0
else if (ql(ibx,i) .lt. 0.0d0) then
bxs = -1.0d0
else
bxs = 0.0d0
end if
! compute the density root squares
!
dlsq = sqrt(q1l(idn))
drsq = sqrt(q1r(idn))
div = dlsq + drsq
! calculate the velocity components
!
q2(ivx) = sm
q2(ivy) = (dlsq * q1l(ivy) + drsq * q1r(ivy) &
+ (q1r(iby) - q1l(iby)) * bxs) / div
q2(ivz) = (dlsq * q1l(ivz) + drsq * q1r(ivz) &
+ (q1r(ibz) - q1l(ibz)) * bxs) / div
! calculate the magnetic field components
!
q2(ibx) = ql(ibx,i)
q2(iby) = (dlsq * q1r(iby) + drsq * q1l(iby) &
+ dlsq * drsq * (q1r(ivy) - q1l(ivy)) * bxs) / div
q2(ibz) = (dlsq * q1r(ibz) + drsq * q1l(ibz) &
+ dlsq * drsq * (q1r(ivz) - q1l(ivz)) * bxs) / div
if (sm .ge. 0.0) then
! convert the left Alfven intermediate state to the conservative form
!
u2(idn) = u1l(idn)
u2(imx) = u1l(idn) * q2(ivx)
u2(imy) = u1l(idn) * q2(ivy)
u2(imz) = u1l(idn) * q2(ivz)
u2(ien) = u1l(ien) - dlsq * (sum(q1l(ivx:ivz) * q1l(ibx:ibz)) &
- sum(q2 (ivx:ivz) * q2 (ibx:ibz))) * bxs
SCHEME: small fixes in the adiabatic HLLD solver.
2010-12-03 12:27:53 -02:00
u2(ibx) = u1l(ibx)
u2(iby) = q2(iby)
u2(ibz) = q2(ibz)
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
#ifdef GLM
u2(iph) = u1l(iph)
#endif /* GLM */
! calculate the numerical flux
!
fn(:,i) = fl(:,i) + sml * u2(:) - (sml - sl) * u1l(:) - sl * ul(:,i)
else ! sm < 0
! convert the right Alfven intermediate state to the conservative form
!
u2(idn) = u1r(idn)
u2(imx) = u1r(idn) * q2(ivx)
u2(imy) = u1r(idn) * q2(ivy)
u2(imz) = u1r(idn) * q2(ivz)
u2(ien) = u1r(ien) + drsq * (sum(q1r(ivx:ivz) * q1r(ibx:ibz)) &
SCHEME: small fixes in the adiabatic HLLD solver.
2010-12-03 12:27:53 -02:00
- sum(q2 (ivx:ivz) * q2 (ibx:ibz))) * bxs
u2(ibx) = u1r(ibx)
u2(iby) = q2(iby)
u2(ibz) = q2(ibz)
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
#ifdef GLM
u2(iph) = u1r(iph)
#endif /* GLM */
! calculate the numerical flux
!
fn(:,i) = fr(:,i) + smr * u2(:) - (smr - sr) * u1r(:) - sr * ur(:,i)
end if
end if
end if
end do
Return fluxes instead of their derivatives if CONSERVATIVE=Y. - if the flag CONSERVATIVE is enable, we need to return the numerical fluxes instead of their derivatives; the directional derivatives are calculated after sunchronization of the flux;
2011-04-30 12:49:29 -03:00
#ifdef CONSERVATIVE
! return numerica flux at i+1/2
!
f( : , : ) = fn( : , : )
#else /* CONSERVATIVE */
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
! calculate the numerical flux derivative
!
SCHEME: small fixes in the adiabatic HLLD solver.
2010-12-03 12:27:53 -02:00
f( 1:nfl,2:n) = - fn( 1:nfl,2:n) + fn( 1:nfl,1:n-1)
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
f(ibx:ibz,2:n) = - fn(ibx:ibz,2:n) + fn(ibx:ibz,1:n-1)
#ifdef GLM
f(iph ,2:n) = - fn(iph ,2:n) + fn(iph ,1:n-1)
#endif /* GLM */
Return fluxes instead of their derivatives if CONSERVATIVE=Y. - if the flag CONSERVATIVE is enable, we need to return the numerical fluxes instead of their derivatives; the directional derivatives are calculated after sunchronization of the flux;
2011-04-30 12:49:29 -03:00
#endif /* CONSERVATIVE */
SCHEME: implement the adiabatic HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the adiabatic equation of states for the MHD equations;
2010-12-02 17:54:15 -02:00
!-------------------------------------------------------------------------------
!
end subroutine hlld
#endif /* ADI */
SCHEME: implement the isothermal HLLD Riemann solver. - the HLLD approximate solver calculates the numerical fluxes for the isothermal equation of states for the MHD equations;
2010-12-02 12:07:01 -02:00
#endif /* HLLD */
#endif /* MHD */
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
#ifdef ROE
!
!===============================================================================
!
! roe: subroutine computes the approximated flux using the ROE method
!
! references:
!
! - Roe, P. L., 1981, Journal of Computational Physics, 43, 357
!
!===============================================================================
!
subroutine roe(n, h, u, f)
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use equations , only : gamma
use interpolations, only : reconstruct
use variables , only : nvr, nfl, nqt
use variables , only : idn, ivx, ivy, ivz
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
#ifdef ADI
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use variables , only : ien, ipr
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
#endif /* ADI */
#ifdef MHD
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use variables , only : ibx, iby, ibz
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
#ifdef GLM
Rename module INTERPOLATION to INTERPOLATIONS.
2012-07-27 16:36:51 -03:00
use variables , only : iph
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
#endif /* GLM */
#endif /* MHD */
implicit none
! input/output arguments
!
integer , intent(in) :: n
real , intent(in) :: h
real, dimension(nvr,n), intent(in) :: u
real, dimension(nqt,n), intent(out) :: f
! local variables
!
Add viscous and resistive terms for adiabatic EOS. - also slightly optimize the dissipation term calculations;
2011-04-05 00:42:24 +02:00
integer :: p, i, ip1
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
real, dimension(nvr,n) :: q, ql, qr, ul, ur
real, dimension(nqt,n) :: fl, fr, fn
real, dimension(n) :: cl, cr
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
real, dimension(nqt) :: qi, ci, et, du
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
real, dimension(nqt,nqt) :: li, ri
real :: al, ar, ap, div
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
real :: sdl, sdr, sds, sfl, sfr
Fix a bug introduced in 58cfb07e9ab54a0cb77775f78bdb9e6105c89309. - the order of flags CONSERVATIVE was wrong in the subroutines calculating numerical fluxes;
2011-05-01 16:56:34 -03:00
#ifdef MHD
real :: pbl, pbr, xfc, yfc
#endif /* MHD */
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
!
!-------------------------------------------------------------------------------
!
! reset eigensystem values
!
ci(:) = 0.0d0
li(:,:) = 0.0d0
ri(:,:) = 0.0d0
! calculate the primitive variables
!
call cons2prim(n, u(:,:), q(:,:))
! reconstruct the left and right states of the primitive variables
!
do p = 1, nfl
call reconstruct(n, h, q(p,:), ql(p,:), qr(p,:))
end do
#ifdef MHD
! reconstruct the left and right states of the magnetic field components
!
do p = ibx, ibz
call reconstruct(n, h, q(p,:), ql(p,:), qr(p,:))
end do
#ifdef GLM
! reconstruct the left and right states of the scalar potential
!
call reconstruct(n, h, q(iph,:), ql(iph,:), qr(iph,:))
! obtain the state values for Bx and Psi for the GLM-MHD equations
!
cl(:) = 0.5d0 * ((qr(ibx,:) + ql(ibx,:)) - (qr(iph,:) - ql(iph,:)) / cmax)
cr(:) = 0.5d0 * ((qr(iph,:) + ql(iph,:)) - (qr(ibx,:) - ql(ibx,:)) * cmax)
ql(ibx,:) = cl(:)
qr(ibx,:) = cl(:)
ql(iph,:) = cr(:)
qr(iph,:) = cr(:)
#endif /* GLM */
#endif /* MHD */
! calculate conservative variables at states
!
call prim2cons(n, ql(:,:), ul(:,:))
call prim2cons(n, qr(:,:), ur(:,:))
! calculate fluxes and speeds
!
call fluxspeed(n, ql(:,:), ul(:,:), fl(:,:), cl(:))
call fluxspeed(n, qr(:,:), ur(:,:), fr(:,:), cr(:))
! iterate over all points
!
do i = 1, n
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
! calculate conserved states difference
!
du(:) = ur(:,i) - ul(:,i)
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
! calculate Roe variables for the eigenproblem solution
!
sdl = sqrt(ql(idn,i))
sdr = sqrt(qr(idn,i))
sds = sdl + sdr
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
sfl = sdl / sds
sfr = sdr / sds
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
qi(idn) = sdl * sdr
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
qi(ivx) = sfl * ql(ivx,i) + sfr * qr(ivx,i)
qi(ivy) = sfl * ql(ivy,i) + sfr * qr(ivy,i)
qi(ivz) = sfl * ql(ivz,i) + sfr * qr(ivz,i)
#ifdef HYDRO
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
#ifdef ADI
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
qi(ipr) = sfl * (ul(ien,i) + ql(ipr,i)) / ql(idn,i) &
+ sfr * (ur(ien,i) + qr(ipr,i)) / qr(idn,i)
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
#endif /* ADI */
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
#endif /* HYDRO */
#ifdef MHD
qi(ibx) = ql(ibx,i)
qi(iby) = sfl * ql(iby,i) + sfr * qr(iby,i)
qi(ibz) = sfl * ql(ibz,i) + sfr * qr(ibz,i)
#ifdef ADI
pbl = 0.5d0 * sum(ql(ibx:ibz,i)**2)
pbr = 0.5d0 * sum(qr(ibx:ibz,i)**2)
qi(ipr) = sfl * (ul(ien,i) + ql(ipr,i) + pbl) / ql(idn,i) &
+ sfr * (ur(ien,i) + qr(ipr,i) + pbr) / qr(idn,i)
#endif /* ADI */
xfc = 0.5d0 * sum(du(iby:ibz)**2) / sds**2
yfc = 0.5d0 * (ql(idn,i) + qr(idn,i)) / qi(idn)
#endif /* MHD */
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
! check if density and pressure are positive
!
#ifdef ADI
if (qi(idn) .gt. 0.0d0 .and. qi(ipr) .gt. 0.0d0) then
#else /* ADI */
if (qi(idn) .gt. 0.0d0) then
#endif /* ADI */
! obtain eigenvalues and eigenvectors
!
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
#ifdef HYDRO
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
call eigensystem(qi(:), ci(:), ri(:,:), li(:,:))
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
#endif /* HYDRO */
#ifdef MHD
call eigensystem(qi(:), ci(:), ri(:,:), li(:,:), xfc, yfc)
#endif /* MHD */
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
! calculate vector (Ur - Ul).L
!
et(:) = 0.0d0
do p = 1, nqt
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
et(:) = et(:) + du(p) * li(p,:)
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
end do
! calculate numerical flux
!
fn(:,i) = 0.5d0 * (fl(:,i) + fr(:,i))
! add term abs(lambda) R.(Ur - Ul).L
!
do p = 1, nqt
fn(:,i) = fn(:,i) - 0.5d0 * abs(ci(p)) * et(p) * ri(p,:)
end do
else ! in the case when density or pressure of the intermediate state
! are negative, use the simplest and most robust HLL flux
! calculate min and max speeds
!
al = min(ql(ivx,i) - cl(i), qr(ivx,i) - cr(i))
ar = max(ql(ivx,i) + cl(i), qr(ivx,i) + cr(i))
! calculate the HLL flux
!
if (al .ge. 0.0d0) then
fn(:,i) = fl(:,i)
else if (ar .le. 0.0d0) then
fn(:,i) = fr(:,i)
else
ap = ar * al
div = 1.0d0 / (ar - al)
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
fn(:,i) = div * (ar * fl(:,i) - al * fr(:,i) &
+ ap * (ur(:,i) - ul(:,i)))
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
end if
end if
end do
Return fluxes instead of their derivatives if CONSERVATIVE=Y. - if the flag CONSERVATIVE is enable, we need to return the numerical fluxes instead of their derivatives; the directional derivatives are calculated after sunchronization of the flux;
2011-04-30 12:49:29 -03:00
#ifdef CONSERVATIVE
! return numerica flux at i+1/2
!
f( : , : ) = fn( : , : )
#else /* CONSERVATIVE */
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
! calculate numerical flux
!
f( 1:nfl,2:n) = - fn( 1:nfl,2:n) + fn( 1:nfl,1:n-1)
#ifdef MHD
f(ibx:ibz,2:n) = - fn(ibx:ibz,2:n) + fn(ibx:ibz,1:n-1)
Fix a bug introduced in 58cfb07e9ab54a0cb77775f78bdb9e6105c89309. - the order of flags CONSERVATIVE was wrong in the subroutines calculating numerical fluxes;
2011-05-01 16:56:34 -03:00
#ifdef GLM
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
f(iph ,2:n) = - fn(iph ,2:n) + fn(iph ,1:n-1)
#endif /* GLM */
#endif /* MHD */
Return fluxes instead of their derivatives if CONSERVATIVE=Y. - if the flag CONSERVATIVE is enable, we need to return the numerical fluxes instead of their derivatives; the directional derivatives are calculated after sunchronization of the flux;
2011-04-30 12:49:29 -03:00
#endif /* CONSERVATIVE */
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
!-------------------------------------------------------------------------------
!
end subroutine roe
!
!===============================================================================
!
! eigensystem: subroutine computes eigenvalues and eigenmatrices for a given
! set of equations and input variables
!
!===============================================================================
!
#ifdef HYDRO
#ifdef ADI
subroutine eigensystem(q, c, r, l)
Remove dependency of module SCHEME on CONFIG.
2012-07-27 16:30:55 -03:00
use equations, only : gamma
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
use variables, only : nqt
use variables, only : idn, ivx, ivy, ivz
use variables, only : ien
implicit none
! input/output arguments
!
real, dimension(nqt) , intent(in) :: q
real, dimension(nqt) , intent(inout) :: c
real, dimension(nqt,nqt), intent(inout) :: l, r
! local variables
!
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
real :: gm, vv, vh, c2, na, cc, vc, ng, nd, nv, nh, nc
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
!
!-------------------------------------------------------------------------------
!
! calculate characteristic speeds and useful variables
!
gm = gamma - 1.0d0
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
vv = sum(q(ivx:ivz)**2)
vh = 0.5d0 * vv
c2 = gm * (q(ien) - vh)
na = 0.5d0 / c2
cc = sqrt(c2)
vc = q(ivx) * cc
ng = na * gm
nd = 2.0 * ng
nv = na * vc
nh = na * gm * vh
nc = na * cc
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
! prepare eigenvalues
!
c(1) = q(ivx) - cc
c(2) = q(ivx)
c(3) = q(ivx)
c(4) = q(ivx)
c(5) = q(ivx) + cc
! prepare the right eigenmatrix
!
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
r(1,idn) = 1.0d0
r(1,ivx) = q(ivx) - cc
r(1,ivy) = q(ivy)
r(1,ivz) = q(ivz)
r(1,ien) = q(ien) - vc
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
r(2,ivy) = 1.0d0
r(2,ien) = q(ivy)
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
r(3,ivz) = 1.0d0
r(3,ien) = q(ivz)
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
r(4,idn) = 1.0d0
r(4,ivx) = q(ivx)
r(4,ivy) = q(ivy)
r(4,ivz) = q(ivz)
r(4,ien) = vh
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
r(5,idn) = 1.0d0
r(5,ivx) = q(ivx) + cc
r(5,ivy) = q(ivy)
r(5,ivz) = q(ivz)
r(5,ien) = q(ien) + vc
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
! prepare the left eigenmatrix
!
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
l(idn,1) = nh + nv
l(ivx,1) = - ng * q(ivx) - nc
l(ivy,1) = - ng * q(ivy)
l(ivz,1) = - ng * q(ivz)
l(ien,1) = ng
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
l(idn,2) = - q(ivy)
l(ivy,2) = 1.0d0
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
l(idn,3) = - q(ivz)
l(ivz,3) = 1.0d0
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
l(idn,4) = 1.0d0 - ng * vv
l(ivx,4) = nd * q(ivx)
l(ivy,4) = nd * q(ivy)
l(ivz,4) = nd * q(ivz)
l(ien,4) = - nd
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
l(idn,5) = nh - nv
l(ivx,5) = - ng * q(ivx) + nc
l(ivy,5) = - ng * q(ivy)
l(ivz,5) = - ng * q(ivz)
l(ien,5) = ng
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
!-------------------------------------------------------------------------------
!
end subroutine eigensystem
#endif /* ADI */
Implement Roe Riemann solver for isothermal hydrodynamics.
2011-03-21 14:58:18 -03:00
#ifdef ISO
subroutine eigensystem(q, c, r, l)
Remove dependency of module SCHEME on CONFIG.
2012-07-27 16:30:55 -03:00
use equations, only : csnd
Implement Roe Riemann solver for isothermal hydrodynamics.
2011-03-21 14:58:18 -03:00
use variables, only : nqt
use variables, only : idn, ivx, ivy, ivz
implicit none
! input/output arguments
!
real, dimension(nqt) , intent(in) :: q
real, dimension(nqt) , intent(inout) :: c
real, dimension(nqt,nqt), intent(inout) :: l, r
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
! local variables
!
real :: ch, vc
Implement Roe Riemann solver for isothermal hydrodynamics.
2011-03-21 14:58:18 -03:00
!
!-------------------------------------------------------------------------------
!
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
! calculate useful variables
!
ch = 0.5d0 / csnd
vc = ch * q(ivx)
Implement Roe Riemann solver for isothermal hydrodynamics.
2011-03-21 14:58:18 -03:00
! prepare eigenvalues
!
c(1) = q(ivx) - csnd
c(2) = q(ivx)
c(3) = q(ivx)
c(4) = q(ivx) + csnd
! prepare the right eigenmatrix
!
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
r(1,idn) = 1.0d0
r(1,ivx) = q(ivx) - csnd
r(1,ivy) = q(ivy)
r(1,ivz) = q(ivz)
Implement Roe Riemann solver for isothermal hydrodynamics.
2011-03-21 14:58:18 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
r(2,ivy) = 1.0d0
Implement Roe Riemann solver for isothermal hydrodynamics.
2011-03-21 14:58:18 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
r(3,ivz) = 1.0d0
Implement Roe Riemann solver for isothermal hydrodynamics.
2011-03-21 14:58:18 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
r(4,idn) = 1.0d0
r(4,ivx) = q(ivx) + csnd
r(4,ivy) = q(ivy)
r(4,ivz) = q(ivz)
Implement Roe Riemann solver for isothermal hydrodynamics.
2011-03-21 14:58:18 -03:00
! prepare the left eigenmatrix
!
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
l(idn,1) = 0.5d0 + vc
l(ivx,1) = - ch
Implement Roe Riemann solver for isothermal hydrodynamics.
2011-03-21 14:58:18 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
l(idn,2) = - q(ivy)
l(ivy,2) = 1.0d0
Implement Roe Riemann solver for isothermal hydrodynamics.
2011-03-21 14:58:18 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
l(idn,3) = - q(ivz)
l(ivz,3) = 1.0d0
Implement Roe Riemann solver for isothermal hydrodynamics.
2011-03-21 14:58:18 -03:00
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
l(idn,4) = 0.5d0 - vc
l(ivx,4) = ch
Implement Roe Riemann solver for isothermal hydrodynamics.
2011-03-21 14:58:18 -03:00
!-------------------------------------------------------------------------------
!
end subroutine eigensystem
#endif /* ISO */
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
#endif /* HYDRO */
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
#ifdef MHD
#ifdef ADI
subroutine eigensystem(q, c, r, l, x, y)
Remove dependency of module SCHEME on CONFIG.
2012-07-27 16:30:55 -03:00
use equations, only : gamma
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
use variables, only : nqt
use variables, only : idn, ivx, ivy, ivz, ibx, iby, ibz, ien
implicit none
! input/output arguments
!
real, dimension(nqt) , intent(in) :: q
real, dimension(nqt) , intent(inout) :: c
real, dimension(nqt,nqt), intent(inout) :: l, r
real , intent(in) :: x, y
! local variables
!
real :: gm1, gm2, v2, b2
real :: ah2, bt2, aa2, cb2, cx2, ct2, ca2, cs2, cf2
real :: cx , ct , cs, ca, cf
!
!-------------------------------------------------------------------------------
!
! calculate characteristic speeds
!
gm1 = gamma - 1.0d0
gm2 = gamma - 2.0d0
v2 = sum(q(ivx:ivz)**2)
b2 = sum(q(ibx:ibz)**2)
ah2 = gm1 * (q(ien) - 0.5d0 * v2 - b2 / q(idn)) - gm2 * x
bt2 = (gm1 - gm2 * y) * sum(q(iby:ibz)**2)
cx2 = q(ibx) * q(ibx) / q(idn)
ct2 = bt2 / q(idn)
ca2 = cx2 + ct2
aa2 = ah2 + ca2
cb2 = sqrt(max(0.0d0, aa2 * aa2 - 4.0d0 * ah2 * cx2))
cs2 = 0.5d0 * (aa2 - cb2)
cf2 = 0.5d0 * (aa2 + cb2)
af2 = (ah2 - cs2) / (cf2 - cs2)
cx = sqrt(cx2)
ca = sqrt(ca2)
cs = sqrt(cs2)
cf = sqrt(cf2)
af = sqrt(af2)
! prepare eigenvalues
!
c(1) = q(ivx) - cf
c(2) = q(ivx) - cx
c(3) = q(ivx) - cs
c(4) = q(ivx)
c(5) = q(ivx) + cs
c(6) = q(ivx) + cx
c(7) = q(ivx) + cf
! prepare the right eigenmatrix
!
r(1,idn) = af
r(1,ivx) = af * (q(ivx) - cf)
! prepare the left eigenmatrix
!
!-------------------------------------------------------------------------------
!
end subroutine eigensystem
#endif /* ADI */
#ifdef ISO
subroutine eigensystem(q, c, r, l, x, y)
Remove dependency of module SCHEME on CONFIG.
2012-07-27 16:30:55 -03:00
use equations, only : csnd
Optimize hydro Roe solvers and prepare MHD Roe solvers.
2011-03-22 15:36:59 -03:00
use variables, only : nqt
use variables, only : idn, ivx, ivy, ivz, ibx, iby, ibz
implicit none
! input/output arguments
!
real, dimension(nqt) , intent(in) :: q
real, dimension(nqt) , intent(inout) :: c
real, dimension(nqt,nqt), intent(inout) :: l, r
real , intent(in) :: x, y
! local variables
!
real :: cs, ca, cx, cf
!
!-------------------------------------------------------------------------------
!
! calculate characteristic speeds
!
ca = sqrt(sum(q(ibx:ibz)**2) / q(idn))
cx = abs(q(ibx)) / sqrt(q(idn))
! prepare eigenvalues
!
c(1) = q(ivx) - cf
c(2) = q(ivx) - ca
c(3) = q(ivx) - cs
c(4) = q(ivx) + cs
c(5) = q(ivx) + ca
c(6) = q(ivx) + cf
! prepare the right eigenmatrix
!
! prepare the left eigenmatrix
!
!-------------------------------------------------------------------------------
!
end subroutine eigensystem
#endif /* ISO */
#endif /* MHD */
Implement Roe Riemann solver for adiabatic hydrodynamics. - the method is based on the Athena implementation;
2011-03-21 14:29:40 -03:00
#endif /* ROE */
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
!
!===============================================================================
!
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
! fluxspeed: subroutine computes fluxes and speeds for a given set of equations
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
!
!===============================================================================
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
subroutine fluxspeed(n, q, u, f, c)
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
Remove dependency of module SCHEME on CONFIG.
2012-07-27 16:30:55 -03:00
#ifdef ADI
use equations, only : gamma
#endif /* ADI */
#ifdef ISO
use equations, only : csnd, csnd2
#endif /* ISO */
Move variable indices to new module 'variables'. VARIABLES - create new module 'variables' which stores references to variable indices; we gonna store dofferent objects related to variables in this module;
2010-12-01 09:25:30 -02:00
use variables, only : nvr, nqt
use variables, only : idn, imx, imy, imz, ivx, ivy, ivz
Fix compilation when EOS=ISO. IO - obtain indices ipr and ien only when we use adiabatic equation of state; PROBLEM - obtain indices ien and ipr only when EOS=ADI; - in the case of isothermal EOS define initial star as an increase of density instead of pressure; - in checking the refirement criterion use only density gradient when EOS=ISO; SCHEME - obtain indices ipr and ien only when we use adiabatic EOS; - in function maxspeed() obtain parameter csnd2 in the case of isothermal equation of state;
2010-03-30 23:23:49 -03:00
#ifdef ADI
Move variable indices to new module 'variables'. VARIABLES - create new module 'variables' which stores references to variable indices; we gonna store dofferent objects related to variables in this module;
2010-12-01 09:25:30 -02:00
use variables, only : ipr, ien
Fix compilation when EOS=ISO. IO - obtain indices ipr and ien only when we use adiabatic equation of state; PROBLEM - obtain indices ien and ipr only when EOS=ADI; - in the case of isothermal EOS define initial star as an increase of density instead of pressure; - in checking the refirement criterion use only density gradient when EOS=ISO; SCHEME - obtain indices ipr and ien only when we use adiabatic EOS; - in function maxspeed() obtain parameter csnd2 in the case of isothermal equation of state;
2010-03-30 23:23:49 -03:00
#endif /* ADI */
Boundaries, interpolation, indices. Rewritten boundaries allow for a proper handling boundaries between blocks at different refinement levels. Prolongation and restriction of the boundaries are improved now. Rewritten interpolation for prolongation and restriction. References to the variable indices are assigned more properly.
2010-02-11 23:30:46 -02:00
#ifdef MHD
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
use variables, only : ibx, iby, ibz
GLM-MHD: calculate physical fluxes for B and Psi. - calculate physical fluxes for the magnetic field components and scalar potential in subroutine fluxspeed();
2010-12-01 10:17:10 -02:00
#ifdef GLM
use variables, only : iph
#endif /* GLM */
Boundaries, interpolation, indices. Rewritten boundaries allow for a proper handling boundaries between blocks at different refinement levels. Prolongation and restriction of the boundaries are improved now. Rewritten interpolation for prolongation and restriction. References to the variable indices are assigned more properly.
2010-02-11 23:30:46 -02:00
#endif /* MHD */
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
implicit none
! input/output arguments
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
integer , intent(in) :: n
real, dimension(nvr,n), intent(in) :: q, u
real, dimension(nqt,n), intent(out) :: f
real, dimension(n) , intent(out) :: c
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
! local variables
!
integer :: i
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
real :: bb, pm, vb, cs, cb, ca
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
!
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!-------------------------------------------------------------------------------
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
!
! sweep over all points
!
do i = 1, n
! compute fluxes
!
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
f(idn,i) = u(imx,i)
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
#ifdef ADI
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
f(imx,i) = q(ivx,i) * u(imx,i) + q(ipr,i)
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
#endif /* ADI */
#ifdef ISO
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
f(imx,i) = q(ivx,i) * u(imx,i) + q(idn,i) * csnd2
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
#endif /* ISO */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
f(imy,i) = q(ivx,i) * u(imy,i)
f(imz,i) = q(ivx,i) * u(imz,i)
#ifdef ADI
f(ien,i) = q(ivx,i) * (u(ien,i) + q(ipr,i))
#endif /* ADI */
#ifdef MHD
bb = sum(q(ibx:ibz,i) * q(ibx:ibz,i))
pm = 0.5 * bb
vb = sum(q(ivx:ivz,i) * q(ibx:ibz,i))
f(imx,i) = f(imx,i) - q(ibx,i) * q(ibx,i) + pm
f(imy,i) = f(imy,i) - q(ibx,i) * q(iby,i)
f(imz,i) = f(imz,i) - q(ibx,i) * q(ibz,i)
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
#ifdef ADI
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
f(ien,i) = f(ien,i) + q(ivx,i) * pm - q(ibx,i) * vb
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
#endif /* ADI */
SCHEME: correct flux calculation for magnetic field.
2010-12-11 19:26:33 -02:00
f(ibx,i) = 0.0d0
GLM-MHD: calculate physical fluxes for B and Psi. - calculate physical fluxes for the magnetic field components and scalar potential in subroutine fluxspeed();
2010-12-01 10:17:10 -02:00
f(iby,i) = q(ivx,i) * q(iby,i) - q(ibx,i) * q(ivy,i)
f(ibz,i) = q(ivx,i) * q(ibz,i) - q(ibx,i) * q(ivz,i)
SCHEME: correct flux calculation for magnetic field.
2010-12-11 19:26:33 -02:00
#ifdef GLM
f(ibx,i) = q(iph,i)
GLM-MHD: calculate physical fluxes for B and Psi. - calculate physical fluxes for the magnetic field components and scalar potential in subroutine fluxspeed();
2010-12-01 10:17:10 -02:00
f(iph,i) = q(ibx,i)
#endif /* GLM */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
! compute speeds
!
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
#ifdef ADI
cs = gamma * q(ipr,i)
#endif /* ADI */
#ifdef ISO
cs = csnd2 * q(idn,i)
#endif /* ISO */
cb = cs + bb
ca = q(ibx,i) * q(ibx,i)
c(i) = sqrt(0.5 * (cb + sqrt(max(0.0, cb * cb - 4.0 * cs * ca))) / q(idn,i))
#else /* MHD */
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
#ifdef ADI
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
c(i) = sqrt(gamma * q(ipr,i) / q(idn,i))
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
#endif /* ADI */
#ifdef ISO
c(i) = csnd
#endif /* ISO */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
end do
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!-------------------------------------------------------------------------------
Subroutine to calculate fluxes and speeds implemented. This subroutine calculates fluxes and speeds for hydrodynamic case only. Adiabatic and isothermal equations of state are supported. I also added new parameters, gamma and csnd to the config module.
2008-12-08 20:29:13 -06:00
!
end subroutine fluxspeed
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
!
!===============================================================================
!
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
! cons2prim: subroutine converts primitive variables to conservative
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
!
!===============================================================================
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
subroutine cons2prim(n, u, q)
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
Remove dependency of module SCHEME on CONFIG.
2012-07-27 16:30:55 -03:00
use equations, only : gammam1
Move variable indices to new module 'variables'. VARIABLES - create new module 'variables' which stores references to variable indices; we gonna store dofferent objects related to variables in this module;
2010-12-01 09:25:30 -02:00
use variables, only : nvr
use variables, only : idn, imx, imy, imz, ivx, ivy, ivz
Fix compilation when EOS=ISO. IO - obtain indices ipr and ien only when we use adiabatic equation of state; PROBLEM - obtain indices ien and ipr only when EOS=ADI; - in the case of isothermal EOS define initial star as an increase of density instead of pressure; - in checking the refirement criterion use only density gradient when EOS=ISO; SCHEME - obtain indices ipr and ien only when we use adiabatic EOS; - in function maxspeed() obtain parameter csnd2 in the case of isothermal equation of state;
2010-03-30 23:23:49 -03:00
#ifdef ADI
Move variable indices to new module 'variables'. VARIABLES - create new module 'variables' which stores references to variable indices; we gonna store dofferent objects related to variables in this module;
2010-12-01 09:25:30 -02:00
use variables, only : ipr, ien
Fix compilation when EOS=ISO. IO - obtain indices ipr and ien only when we use adiabatic equation of state; PROBLEM - obtain indices ien and ipr only when EOS=ADI; - in the case of isothermal EOS define initial star as an increase of density instead of pressure; - in checking the refirement criterion use only density gradient when EOS=ISO; SCHEME - obtain indices ipr and ien only when we use adiabatic EOS; - in function maxspeed() obtain parameter csnd2 in the case of isothermal equation of state;
2010-03-30 23:23:49 -03:00
#endif /* ADI */
Boundaries, interpolation, indices. Rewritten boundaries allow for a proper handling boundaries between blocks at different refinement levels. Prolongation and restriction of the boundaries are improved now. Rewritten interpolation for prolongation and restriction. References to the variable indices are assigned more properly.
2010-02-11 23:30:46 -02:00
#ifdef MHD
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
use variables, only : ibx, iby, ibz
GLM-MHD: copy Psi between primitive and conserved variables. - update subroutines cons2prim() and prim2cons() to convert the scalar potential between primitive and conserved variables;
2010-12-01 10:22:00 -02:00
#ifdef GLM
use variables, only : iph
#endif /* GLM */
Boundaries, interpolation, indices. Rewritten boundaries allow for a proper handling boundaries between blocks at different refinement levels. Prolongation and restriction of the boundaries are improved now. Rewritten interpolation for prolongation and restriction. References to the variable indices are assigned more properly.
2010-02-11 23:30:46 -02:00
#endif /* MHD */
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
implicit none
! input/output arguments
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
integer , intent(in) :: n
real, dimension(nvr,n), intent(in) :: u
real, dimension(nvr,n), intent(out) :: q
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
! local variables
!
integer :: i
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
real :: dni, ei, ek, em
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
!
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!-------------------------------------------------------------------------------
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
!
do i = 1, n
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
dni = 1.0 / u(idn,i)
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
q(idn,i) = u(idn,i)
q(ivx,i) = dni * u(imx,i)
q(ivy,i) = dni * u(imy,i)
q(ivz,i) = dni * u(imz,i)
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
#ifdef ADI
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
ek = 0.5 * sum(u(imx:imz,i) * q(ivx:ivz,i))
ei = u(ien,i) - ek
#ifdef MHD
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
em = 0.5 * sum(u(ibx:ibz,i) * u(ibx:ibz,i))
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
ei = ei - em
#endif /* MHD */
q(ipr,i) = gammam1 * ei
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
#endif /* ADI */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
q(ibx,i) = u(ibx,i)
q(iby,i) = u(iby,i)
q(ibz,i) = u(ibz,i)
GLM-MHD: copy Psi between primitive and conserved variables. - update subroutines cons2prim() and prim2cons() to convert the scalar potential between primitive and conserved variables;
2010-12-01 10:22:00 -02:00
#ifdef GLM
q(iph,i) = u(iph,i)
#endif /* GLM */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
end do
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!-------------------------------------------------------------------------------
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
!
end subroutine cons2prim
!
!===============================================================================
!
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
! prim2cons: subroutine converts primitive variables to conservative
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
!
!===============================================================================
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
subroutine prim2cons(n, q, u)
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
Remove dependency of module SCHEME on CONFIG.
2012-07-27 16:30:55 -03:00
use equations, only : gammam1i
Move variable indices to new module 'variables'. VARIABLES - create new module 'variables' which stores references to variable indices; we gonna store dofferent objects related to variables in this module;
2010-12-01 09:25:30 -02:00
use variables, only : nvr
use variables, only : idn, imx, imy, imz, ivx, ivy, ivz
Fix compilation when EOS=ISO. IO - obtain indices ipr and ien only when we use adiabatic equation of state; PROBLEM - obtain indices ien and ipr only when EOS=ADI; - in the case of isothermal EOS define initial star as an increase of density instead of pressure; - in checking the refirement criterion use only density gradient when EOS=ISO; SCHEME - obtain indices ipr and ien only when we use adiabatic EOS; - in function maxspeed() obtain parameter csnd2 in the case of isothermal equation of state;
2010-03-30 23:23:49 -03:00
#ifdef ADI
Move variable indices to new module 'variables'. VARIABLES - create new module 'variables' which stores references to variable indices; we gonna store dofferent objects related to variables in this module;
2010-12-01 09:25:30 -02:00
use variables, only : ipr, ien
Fix compilation when EOS=ISO. IO - obtain indices ipr and ien only when we use adiabatic equation of state; PROBLEM - obtain indices ien and ipr only when EOS=ADI; - in the case of isothermal EOS define initial star as an increase of density instead of pressure; - in checking the refirement criterion use only density gradient when EOS=ISO; SCHEME - obtain indices ipr and ien only when we use adiabatic EOS; - in function maxspeed() obtain parameter csnd2 in the case of isothermal equation of state;
2010-03-30 23:23:49 -03:00
#endif /* ADI */
Boundaries, interpolation, indices. Rewritten boundaries allow for a proper handling boundaries between blocks at different refinement levels. Prolongation and restriction of the boundaries are improved now. Rewritten interpolation for prolongation and restriction. References to the variable indices are assigned more properly.
2010-02-11 23:30:46 -02:00
#ifdef MHD
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
use variables, only : ibx, iby, ibz
GLM-MHD: copy Psi between primitive and conserved variables. - update subroutines cons2prim() and prim2cons() to convert the scalar potential between primitive and conserved variables;
2010-12-01 10:22:00 -02:00
#ifdef GLM
use variables, only : iph
#endif /* GLM */
Boundaries, interpolation, indices. Rewritten boundaries allow for a proper handling boundaries between blocks at different refinement levels. Prolongation and restriction of the boundaries are improved now. Rewritten interpolation for prolongation and restriction. References to the variable indices are assigned more properly.
2010-02-11 23:30:46 -02:00
#endif /* MHD */
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
implicit none
! input/output arguments
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
integer , intent(in) :: n
real, dimension(nvr,n), intent(in) :: q
real, dimension(nvr,n), intent(out) :: u
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
! local variables
!
integer :: i
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
real :: ei, ek, em
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
!
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!-------------------------------------------------------------------------------
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
!
do i = 1, n
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
u(idn,i) = q(idn,i)
u(imx,i) = q(idn,i) * q(ivx,i)
u(imy,i) = q(idn,i) * q(ivy,i)
u(imz,i) = q(idn,i) * q(ivz,i)
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
#ifdef ADI
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
ei = gammam1i * q(ipr,i)
ek = 0.5 * sum(u(imx:imz,i) * q(ivx:ivz,i))
u(ien,i) = ei + ek
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
#endif /* ADI */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
#ifdef ADI
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
em = 0.5 * sum(q(ibx:ibz,i) * q(ibx:ibz,i))
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
u(ien,i) = u(ien,i) + em
#endif /* ADI */
u(ibx,i) = q(ibx,i)
u(iby,i) = q(iby,i)
u(ibz,i) = q(ibz,i)
GLM-MHD: copy Psi between primitive and conserved variables. - update subroutines cons2prim() and prim2cons() to convert the scalar potential between primitive and conserved variables;
2010-12-01 10:22:00 -02:00
#ifdef GLM
u(iph,i) = q(iph,i)
#endif /* GLM */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
end do
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!-------------------------------------------------------------------------------
Added two subroutines to convert between variables. Two subroutines, cons2prim and prim2cons, to convert between conservative and primitive variables have been added. New parameters, gammam1 and gammam1i have been added to the configuration file. Both are derivation of gamma, first is gamma-1, the secons 1/(gamma-1).
2008-12-08 20:38:46 -06:00
!
end subroutine prim2cons
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
!
!===============================================================================
!
! maxspeed: function to calculate maximum speed in the system
!
!===============================================================================
!
function maxspeed(u)
Use variables from COORDINATES in module SCHEME.
2012-07-27 16:06:27 -03:00
use coordinates, only : im, jm, km, ib, ie, jb, je, kb, ke
Fix compilation when EOS=ISO. IO - obtain indices ipr and ien only when we use adiabatic equation of state; PROBLEM - obtain indices ien and ipr only when EOS=ADI; - in the case of isothermal EOS define initial star as an increase of density instead of pressure; - in checking the refirement criterion use only density gradient when EOS=ISO; SCHEME - obtain indices ipr and ien only when we use adiabatic EOS; - in function maxspeed() obtain parameter csnd2 in the case of isothermal equation of state;
2010-03-30 23:23:49 -03:00
#ifdef ADI
Remove dependency of module SCHEME on CONFIG.
2012-07-27 16:30:55 -03:00
use equations , only : gamma
Fix compilation when EOS=ISO. IO - obtain indices ipr and ien only when we use adiabatic equation of state; PROBLEM - obtain indices ien and ipr only when EOS=ADI; - in the case of isothermal EOS define initial star as an increase of density instead of pressure; - in checking the refirement criterion use only density gradient when EOS=ISO; SCHEME - obtain indices ipr and ien only when we use adiabatic EOS; - in function maxspeed() obtain parameter csnd2 in the case of isothermal equation of state;
2010-03-30 23:23:49 -03:00
#endif /* ADI */
#ifdef ISO
Remove dependency of module SCHEME on CONFIG.
2012-07-27 16:30:55 -03:00
use equations , only : csnd, csnd2
Fix compilation when EOS=ISO. IO - obtain indices ipr and ien only when we use adiabatic equation of state; PROBLEM - obtain indices ien and ipr only when EOS=ADI; - in the case of isothermal EOS define initial star as an increase of density instead of pressure; - in checking the refirement criterion use only density gradient when EOS=ISO; SCHEME - obtain indices ipr and ien only when we use adiabatic EOS; - in function maxspeed() obtain parameter csnd2 in the case of isothermal equation of state;
2010-03-30 23:23:49 -03:00
#endif /* ISO */
Move variable indices to new module 'variables'. VARIABLES - create new module 'variables' which stores references to variable indices; we gonna store dofferent objects related to variables in this module;
2010-12-01 09:25:30 -02:00
use variables , only : nvr, nqt
use variables , only : idn, ivx, ivz
#ifdef ADI
use variables , only : ipr
#endif /* ADI */
#ifdef MHD
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
use variables , only : ibx, iby, ibz
Move variable indices to new module 'variables'. VARIABLES - create new module 'variables' which stores references to variable indices; we gonna store dofferent objects related to variables in this module;
2010-12-01 09:25:30 -02:00
#endif /* MHD */
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
implicit none
! input arguments
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
real, dimension(nqt,im,jm,km), intent(in) :: u
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
! local variables
!
integer :: i, j, k
real :: vv, v, c
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
real :: bb
#endif /* MHD */
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 :: maxspeed
! local arrays
!
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03:00
real, dimension(nvr,im) :: q
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
!
Update the copyright info and fix the length of separating lines.
2010-10-13 03:32:10 -03: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
!
maxspeed = 0.0
! iterate over all points and calculate maximum speed
!
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 = kb, ke
do j = jb, je
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
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
call cons2prim(im, u(1:nqt,1:im,j,k), q(1:nqt,1:im))
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
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 i = ib, ie
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 the velocity
!
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
vv = sum(q(ivx:ivz,i)**2)
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
v = sqrt(vv)
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
SCHEME: clean up code after removal indices icx, icy, icz.
2010-12-05 09:27:19 -02:00
bb = sum(q(ibx:ibz,i)**2)
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
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 the maximum characteristic speed
!
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#ifdef MHD
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
#ifdef ADI
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
c = sqrt((gamma * q(ipr,i) + bb) / q(idn,i))
#endif /* ADI */
#ifdef ISO
c = sqrt(csnd2 + bb / q(idn,i))
#endif /* ISO */
#else /* MHD */
#ifdef ADI
c = sqrt(gamma * q(ipr,i) / q(idn,i))
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
#endif /* ADI */
#ifdef ISO
c = csnd
#endif /* ISO */
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
#endif /* MHD */
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 maximum of the speed
!
maxspeed = max(maxspeed, v + c)
Initial support for the MHD equations. VARIABLES - add indices for the magnetic field components, both face and cell centered SOLVER, MHD - add support for the magnetohydrodynamic (MHD) equations to the subroutines cons2prim(), prim2cons() - add MHD flux and the fastest speed calculation in the subroutine fluxspeed() - include magnetosonic speed in the calculation of the maximum speed in the system required for estimation of the new time step - extend the HLL solver in subroutine hll() to support MHD - calculate the magnetic field update according to a CT scheme in the subroutine update() INTERPOLATION - add subroutine magtocen() to interpolate cell centered magnetic field EVOLUTION - add evolution of the magnetic field components in the evolve_euler() and evolve_rk2() time integration subroutines - also call the subroutine magtocen() in the right places BOUNDARY CONDITIONS - support for magnetic field boundary update only in the case of blocks with the same level so far; later we need to include proper restriction and prolongation for the magnetic field to keep its divergence equal zero PROBLEMS, BLAST - extend the blast problem to include the initial magnetic field IO, HDF5 - write down in a HDF5 file magnetic field components
2009-10-28 00:12:18 -02:00
end do
end do
end do
Implement FLUXCT integration of the induction equation. SCHEME - implement Flux-CT scheme for the staggered magnetic field integration; BLOCK STRUCTURE - use more space efficient storage of the variables, which means storing only staggered components of magnetic field; cell-centered components are calculated only when necessary; EVOLUTION - remove loops in the field updates; operations are performed on the arrays; BOUNDARY CONDITIONS - remove loops in the bnd_copy; operations are calculated on the whole array now; INTERPOLATION - subroutine magtocen() has been rewritten to avoid problems with the array allocation; now as an argument we enter the array of all variables; subroutine uses indices for the face-centered and cell-centered magnetic field components internally; MAKE - add flag defining Flux-CT scheme; PROBLEM - use predefined array variables instead of allocated;
2010-02-28 18:35:57 -03: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
!-------------------------------------------------------------------------------
!
end function maxspeed
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
Updated comments in the scheme module.
2008-12-08 21:04:20 -06:00
!===============================================================================
New module 'scheme' for calculating dU increment. This new module contains subroutines to calculate state vector update using an approximate Riemann solver. The initial version contains only a draft subroutine calculating the state vector increment dU.
2008-12-08 19:07:42 -06:00
!
end module
Reference in New Issue Copy Permalink