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

499 lines
12 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 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!!
!! module: evolution - handling the time evolution of the block structure
!!
Update the copyright info and fix the length of separating lines.
2010-10-13 03:32:10 -03:00
!! Copyright (C) 2008-2010 Grzegorz Kowal <grzegorz@gkowal.info>
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!!
Update the copyright info and fix the length of separating lines.
2010-10-13 03:32:10 -03:00
!!******************************************************************************
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!!
!! This file is part of Godunov-AMR.
!!
!! Godunov-AMR is free software; you can redistribute it and/or modify
!! it under the terms of the GNU General Public License as published by
!! the Free Software Foundation; either version 3 of the License, or
!! (at your option) any later version.
!!
!! Godunov-AMR is distributed in the hope that it will be useful,
!! but WITHOUT ANY WARRANTY; without even the implied warranty of
!! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
!! GNU General Public License for more details.
!!
!! You should have received a copy of the GNU General Public License
!! along with this program. If not, see <http://www.gnu.org/licenses/>.
!!
Update the copyright info and fix the length of separating lines.
2010-10-13 03:32:10 -03:00
!!******************************************************************************
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!!
!
module evolution
implicit none
integer, save :: n
EVOLUTION: add subroutine to update the maximum speed. - make the variable cmax global in the module 'evolution'; - add a new subroutine update_maximum_speed() which updates the maximum speed cmax in the system iterating over all data blocks; - use the subroutine update_maximum_speed() in evolve();
2010-12-01 10:39:18 -02:00
real , save :: t, dt, dtn, cmax
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
contains
!
Updated comments in the evolution module.
2008-12-08 21:07:10 -06:00
!===============================================================================
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
First step of implementation of time advance using new method. BLOCK STRUCTURE - add new array to the data block structure to store the electromotive force components; these components are located at the centers of cell edges, in this way the CT update of the staggered magnetic field component will be easier; EVOLUTION - add new subroutine advance() which performs several steps in order to advance the solution in time by one-step update; the substeps are the updates of the numerical flux, the flux boundary, the advance in time the solution, the updates of mesh structure, and the boundaries of conserved variables, and finally the new time step estimation; - add new subroutine update_flux() to update the numerical fluxes stored in the data blocks; SCHEME - add new subroutine numerical_flux() to calculate fluxes at the proper locations; - add new logical argument to HLL and HLLC in order to specify if the flux should be returned as a numerical flux or its derivative;
2010-07-27 19:26:15 -03:00
! advance: subroutine sweeps over all data blocks and updates their numerical
! fluxes; then updates the flux boundaries; next, advances in time the
! conserved variables, refines the mesh, updates the
! boundaries of conserved variables, and finally calculates the new
! time step
!
!===============================================================================
!
subroutine advance
use blocks , only : block_data, list_data
Change the boundary subroutines names. BOUNDARIES - change the name of subroutine boundary() to boundary_variables(); - change the name of subroutine boundary_flux() to boundary_fluxes();
2010-09-19 14:33:57 +02:00
use boundaries , only : boundary_variables, boundary_fluxes
First step of implementation of time advance using new method. BLOCK STRUCTURE - add new array to the data block structure to store the electromotive force components; these components are located at the centers of cell edges, in this way the CT update of the staggered magnetic field component will be easier; EVOLUTION - add new subroutine advance() which performs several steps in order to advance the solution in time by one-step update; the substeps are the updates of the numerical flux, the flux boundary, the advance in time the solution, the updates of mesh structure, and the boundaries of conserved variables, and finally the new time step estimation; - add new subroutine update_flux() to update the numerical fluxes stored in the data blocks; SCHEME - add new subroutine numerical_flux() to calculate fluxes at the proper locations; - add new logical argument to HLL and HLLC in order to specify if the flux should be returned as a numerical flux or its derivative;
2010-07-27 19:26:15 -03:00
use mesh , only : update_mesh, dx_min
#ifdef MPI
use mpitools , only : mallreduceminr
#endif /* MPI */
use scheme , only : maxspeed!, advance_variables
use timer , only : start_timer, stop_timer
implicit none
! local variables
!
type(block_data), pointer :: pblock
EVOLUTION: add subroutine to update the maximum speed. - make the variable cmax global in the module 'evolution'; - add a new subroutine update_maximum_speed() which updates the maximum speed cmax in the system iterating over all data blocks; - use the subroutine update_maximum_speed() in evolve();
2010-12-01 10:39:18 -02:00
real :: cm
First step of implementation of time advance using new method. BLOCK STRUCTURE - add new array to the data block structure to store the electromotive force components; these components are located at the centers of cell edges, in this way the CT update of the staggered magnetic field component will be easier; EVOLUTION - add new subroutine advance() which performs several steps in order to advance the solution in time by one-step update; the substeps are the updates of the numerical flux, the flux boundary, the advance in time the solution, the updates of mesh structure, and the boundaries of conserved variables, and finally the new time step estimation; - add new subroutine update_flux() to update the numerical fluxes stored in the data blocks; SCHEME - add new subroutine numerical_flux() to calculate fluxes at the proper locations; - add new logical argument to HLL and HLLC in order to specify if the flux should be returned as a numerical flux or its derivative;
2010-07-27 19:26:15 -03:00
!
!-------------------------------------------------------------------------------
!
! 1. iterate over all data blocks and calculate the numerical fluxes
!
pblock => list_data
do while (associated(pblock))
! - update the numerical fluxes of the current block
!
call update_flux(pblock)
! - assign pointer to the next block
!
pblock => pblock%next
end do
! ! 2. update the flux boundaries
! !
! call start_timer(4)
Change the boundary subroutines names. BOUNDARIES - change the name of subroutine boundary() to boundary_variables(); - change the name of subroutine boundary_flux() to boundary_fluxes();
2010-09-19 14:33:57 +02:00
! call boundary_fluxes
First step of implementation of time advance using new method. BLOCK STRUCTURE - add new array to the data block structure to store the electromotive force components; these components are located at the centers of cell edges, in this way the CT update of the staggered magnetic field component will be easier; EVOLUTION - add new subroutine advance() which performs several steps in order to advance the solution in time by one-step update; the substeps are the updates of the numerical flux, the flux boundary, the advance in time the solution, the updates of mesh structure, and the boundaries of conserved variables, and finally the new time step estimation; - add new subroutine update_flux() to update the numerical fluxes stored in the data blocks; SCHEME - add new subroutine numerical_flux() to calculate fluxes at the proper locations; - add new logical argument to HLL and HLLC in order to specify if the flux should be returned as a numerical flux or its derivative;
2010-07-27 19:26:15 -03:00
! call stop_timer(4)
!
! ! 3. iterate over all data blocks and advance in time the conserved variables
! !
! pblock => list_data
! do while (associated(pblock))
!
! ! - advance in time the conserved variables of the current block
! !
! call advance_variables(pblock)
!
! ! - assign pointer to the next block
! !
! pblock => pblock%next
!
! end do
!
! ! 4. update the mesh (refine and derefine blocks)
! !
! call start_timer(5)
! call update_mesh
! call stop_timer(5)
!
! ! 5. update the boundaries of the conserved variables
! !
! call start_timer(4)
Change the boundary subroutines names. BOUNDARIES - change the name of subroutine boundary() to boundary_variables(); - change the name of subroutine boundary_flux() to boundary_fluxes();
2010-09-19 14:33:57 +02:00
! call boundary_variables
First step of implementation of time advance using new method. BLOCK STRUCTURE - add new array to the data block structure to store the electromotive force components; these components are located at the centers of cell edges, in this way the CT update of the staggered magnetic field component will be easier; EVOLUTION - add new subroutine advance() which performs several steps in order to advance the solution in time by one-step update; the substeps are the updates of the numerical flux, the flux boundary, the advance in time the solution, the updates of mesh structure, and the boundaries of conserved variables, and finally the new time step estimation; - add new subroutine update_flux() to update the numerical fluxes stored in the data blocks; SCHEME - add new subroutine numerical_flux() to calculate fluxes at the proper locations; - add new logical argument to HLL and HLLC in order to specify if the flux should be returned as a numerical flux or its derivative;
2010-07-27 19:26:15 -03:00
! call stop_timer(4)
!
! ! 6. iterate over all blocks in order to find the maximum speed
! !
! cmax = 1.0e-8
!
! pblock => list_data
! do while (associated(pblock))
!
! ! - calculate the maximum speed for the current block
! !
! cm = maxspeed(pblock%u)
!
! ! - take the maximum of the global and local maximum speeds
! !
! cmax = max(cmax, cm)
!
! ! - assign pointer to the next block
! !
! pblock => pblock%next
!
! end do
!
! ! - calculate the new time step
! !
! dtn = dx_min / max(cmax, 1.e-8)
!
! #ifdef MPI
! ! - reduce the new time step over all processes
! !
! call mallreduceminr(dtn)
! #endif /* MPI */
!
!-------------------------------------------------------------------------------
!
end subroutine advance
!
!===============================================================================
!
Updated comments in the evolution module.
2008-12-08 21:07:10 -06:00
! evolve: subroutine sweeps over all leaf blocks and performs one step time
! evolution for each according to the selected integration scheme
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
Updated comments in the evolution module.
2008-12-08 21:07:10 -06:00
!===============================================================================
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
subroutine evolve
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
use blocks , only : block_data, list_data
Change the boundary subroutines names. BOUNDARIES - change the name of subroutine boundary() to boundary_variables(); - change the name of subroutine boundary_flux() to boundary_fluxes();
2010-09-19 14:33:57 +02:00
use boundaries , only : boundary_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
use mesh , only : update_mesh
use mesh , only : dx_min
Fix boundary update and reduce the next time step over all CPUs. The boundary conditions finally works when using MPI with arbitrary number of processors. This is however a dirty hack. Has to be done in a better way later, since now it may be very tricky to generalize the code to 3D. The next time step should be reduced to the minimum value over all processes. This has been added in subroutine 'evolution' now. The block structure contains a new field %pos which specifies the position of the child block in its parent.
2009-01-02 20:18:57 -06:00
#ifdef MPI
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
use mpitools , only : mallreduceminr
Fix boundary update and reduce the next time step over all CPUs. The boundary conditions finally works when using MPI with arbitrary number of processors. This is however a dirty hack. Has to be done in a better way later, since now it may be very tricky to generalize the code to 3D. The next time step should be reduced to the minimum value over all processes. This has been added in subroutine 'evolution' now. The block structure contains a new field %pos which specifies the position of the child block in its parent.
2009-01-02 20:18:57 -06:00
#endif /* MPI */
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
use scheme , only : maxspeed
use timer , only : start_timer, stop_timer
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
implicit none
! local variables
!
Evolve new list of data blocks. TIME INTEGRATION - now update the solution using new list of data blocks belonging to the current process only
2009-09-14 18:28:17 -03:00
type(block_data), pointer :: pblock
EVOLUTION: add subroutine to update the maximum speed. - make the variable cmax global in the module 'evolution'; - add a new subroutine update_maximum_speed() which updates the maximum speed cmax in the system iterating over all data blocks; - use the subroutine update_maximum_speed() in evolve();
2010-12-01 10:39:18 -02:00
real :: cm
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
Updated comments in the evolution module.
2008-12-08 21:07:10 -06:00
!-------------------------------------------------------------------------------
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
Evolve new list of data blocks. TIME INTEGRATION - now update the solution using new list of data blocks belonging to the current process only
2009-09-14 18:28:17 -03:00
! iterate over all data blocks and perform one step of time evolution
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
Evolve new list of data blocks. TIME INTEGRATION - now update the solution using new list of data blocks belonging to the current process only
2009-09-14 18:28:17 -03:00
pblock => list_data
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
do while (associated(pblock))
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
! check if this block is a leaf
!
Evolve new list of data blocks. TIME INTEGRATION - now update the solution using new list of data blocks belonging to the current process only
2009-09-14 18:28:17 -03:00
if (pblock%meta%leaf) &
New time integration method EULER.
2008-12-09 21:06:21 -06:00
#ifdef EULER
call evolve_euler(pblock)
#endif /* EULER */
Runge-Kutta 2nd order time integration implemented. In addition, I've done some fixes to the problem initialization, and I defined new variables igrids, jgrids, kgrids, which specify the dimensions of the block.
2008-12-08 16:21:59 -06:00
#ifdef RK2
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
call evolve_rk2(pblock)
Runge-Kutta 2nd order time integration implemented. In addition, I've done some fixes to the problem initialization, and I defined new variables igrids, jgrids, kgrids, which specify the dimensions of the block.
2008-12-08 16:21:59 -06:00
#endif /* RK2 */
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
! assign pointer to the next block
!
Added CFL condition and calculation of the new time step. The function to calculate the maximum speed in the block has been added. This function is used to determine the maximum speed globally, which is next used to estimate the next time step.
2008-12-09 14:51:33 -06:00
pblock => pblock%next
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
Added CFL condition and calculation of the new time step. The function to calculate the maximum speed in the block has been added. This function is used to determine the maximum speed globally, which is next used to estimate the next time step.
2008-12-09 14:51:33 -06:00
end do
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
New module to handle the boundary conditions. The subroutine 'boundary' sweeps over all leaf blocks. For each block it sweeps over its neighbors and performs update of the boundaries. This is an initial version yet, it supports only neighboring blocks of the same level of refinement.
2008-12-09 20:37:31 -06:00
! update boundaries
Store all variables in one array U. One array U, which is a field in the BLOCK structure, stores all variables. The number of variables is determined by the nvars parameter. To access each variable we use variable index now, like idn, imx, imy, mz, ien, etc.
2008-12-08 12:14:13 -06:00
!
Refinement based on density. More cleanups.
2008-12-13 22:41:37 -06:00
call start_timer(4)
Change the boundary subroutines names. BOUNDARIES - change the name of subroutine boundary() to boundary_variables(); - change the name of subroutine boundary_flux() to boundary_fluxes();
2010-09-19 14:33:57 +02:00
call boundary_variables
Refinement based on density. More cleanups.
2008-12-13 22:41:37 -06:00
call stop_timer(4)
Store all variables in one array U. One array U, which is a field in the BLOCK structure, stores all variables. The number of variables is determined by the nvars parameter. To access each variable we use variable index now, like idn, imx, imy, mz, ien, etc.
2008-12-08 12:14:13 -06:00
Use TVD interpolation in boundary update, update mesh before time step. BOUNDARY CONDITIONS - use TVD interpolation for prolongation of the boundary conditions CONFIGURATION - put lower limit for the number of ghost and domain cells HOST FILES - host files should not be included in the revision control INTERPOLATION - define all arrays as REAL, not REAL(KIND=8) since the precision of calculations is determined at the compilation stage - replace j0 and j1 indices with new more obvious il and ir MESH - update mesh before calculating new time step
2010-03-14 15:40:24 -03:00
! check refinement and refine
!
call start_timer(5)
call update_mesh
call stop_timer(5)
! update boundaries
!
call start_timer(4)
Change the boundary subroutines names. BOUNDARIES - change the name of subroutine boundary() to boundary_variables(); - change the name of subroutine boundary_flux() to boundary_fluxes();
2010-09-19 14:33:57 +02:00
call boundary_variables
Use TVD interpolation in boundary update, update mesh before time step. BOUNDARY CONDITIONS - use TVD interpolation for prolongation of the boundary conditions CONFIGURATION - put lower limit for the number of ghost and domain cells HOST FILES - host files should not be included in the revision control INTERPOLATION - define all arrays as REAL, not REAL(KIND=8) since the precision of calculations is determined at the compilation stage - replace j0 and j1 indices with new more obvious il and ir MESH - update mesh before calculating new time step
2010-03-14 15:40:24 -03:00
call stop_timer(4)
EVOLUTION: add subroutine to update the maximum speed. - make the variable cmax global in the module 'evolution'; - add a new subroutine update_maximum_speed() which updates the maximum speed cmax in the system iterating over all data blocks; - use the subroutine update_maximum_speed() in evolve();
2010-12-01 10:39:18 -02:00
! update the maximum speed
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
!
EVOLUTION: add subroutine to update the maximum speed. - make the variable cmax global in the module 'evolution'; - add a new subroutine update_maximum_speed() which updates the maximum speed cmax in the system iterating over all data blocks; - use the subroutine update_maximum_speed() in evolve();
2010-12-01 10:39:18 -02:00
call update_maximum_speed()
! get maximum time step
!
dtn = dx_min / max(cmax, 1.0d-16)
#ifdef MPI
! reduce new time step over all processes
!
call mallreduceminr(dtn)
#endif /* MPI */
!
!-------------------------------------------------------------------------------
!
end subroutine evolve
!
!===============================================================================
!
! update_maximum_speed: subroutine updates module variable cmax with the value
! corresponding to the maximum speed in the system
!
!===============================================================================
!
subroutine update_maximum_speed()
use blocks, only : block_data, list_data
use scheme, only : maxspeed
implicit none
! local variables
!
type(block_data), pointer :: pblock
real :: cm
!
!-------------------------------------------------------------------------------
!
! reset the maximum speed
!
cmax = 1.0d-16
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
! iterate over all blocks in order to find the maximum speed
!
Evolve new list of data blocks. TIME INTEGRATION - now update the solution using new list of data blocks belonging to the current process only
2009-09-14 18:28:17 -03:00
pblock => list_data
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
do while (associated(pblock))
! check if this block is a leaf
!
Evolve new list of data blocks. TIME INTEGRATION - now update the solution using new list of data blocks belonging to the current process only
2009-09-14 18:28:17 -03:00
if (pblock%meta%leaf) &
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
cm = maxspeed(pblock%u)
! compare global and local maximum speeds
!
cmax = max(cmax, cm)
! assign pointer to the next block
!
pblock => pblock%next
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
!
Updated comments in the evolution module.
2008-12-08 21:07:10 -06:00
!-------------------------------------------------------------------------------
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
EVOLUTION: add subroutine to update the maximum speed. - make the variable cmax global in the module 'evolution'; - add a new subroutine update_maximum_speed() which updates the maximum speed cmax in the system iterating over all data blocks; - use the subroutine update_maximum_speed() in evolve();
2010-12-01 10:39:18 -02:00
end subroutine update_maximum_speed
First step of implementation of time advance using new method. BLOCK STRUCTURE - add new array to the data block structure to store the electromotive force components; these components are located at the centers of cell edges, in this way the CT update of the staggered magnetic field component will be easier; EVOLUTION - add new subroutine advance() which performs several steps in order to advance the solution in time by one-step update; the substeps are the updates of the numerical flux, the flux boundary, the advance in time the solution, the updates of mesh structure, and the boundaries of conserved variables, and finally the new time step estimation; - add new subroutine update_flux() to update the numerical fluxes stored in the data blocks; SCHEME - add new subroutine numerical_flux() to calculate fluxes at the proper locations; - add new logical argument to HLL and HLLC in order to specify if the flux should be returned as a numerical flux or its derivative;
2010-07-27 19:26:15 -03:00
!
!===============================================================================
!
! update_flux: subroutine updates the fluxes for the current block using the
! conserved variables
!
!===============================================================================
!
subroutine update_flux(pblock)
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 blocks , only : block_data
use config , only : im, jm, km
use scheme , only : numerical_flux
use variables, only : nqt
First step of implementation of time advance using new method. BLOCK STRUCTURE - add new array to the data block structure to store the electromotive force components; these components are located at the centers of cell edges, in this way the CT update of the staggered magnetic field component will be easier; EVOLUTION - add new subroutine advance() which performs several steps in order to advance the solution in time by one-step update; the substeps are the updates of the numerical flux, the flux boundary, the advance in time the solution, the updates of mesh structure, and the boundaries of conserved variables, and finally the new time step estimation; - add new subroutine update_flux() to update the numerical fluxes stored in the data blocks; SCHEME - add new subroutine numerical_flux() to calculate fluxes at the proper locations; - add new logical argument to HLL and HLLC in order to specify if the flux should be returned as a numerical flux or its derivative;
2010-07-27 19:26:15 -03:00
implicit none
! input arguments
!
type(block_data), intent(inout) :: pblock
!
!-------------------------------------------------------------------------------
!
! calculate the numerical flux for the block
!
call numerical_flux(pblock%u, pblock%f, pblock%e)
!
!-------------------------------------------------------------------------------
!
end subroutine update_flux
New time integration method EULER.
2008-12-09 21:06:21 -06:00
#ifdef EULER
!
!===============================================================================
!
! evolve_euler: subroutine evolves the current block using Euler integration
!
!===============================================================================
!
subroutine evolve_euler(pblock)
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 blocks , only : block_data
use config , only : im, jm, km
use mesh , only : adxi, adyi, adzi
Add support for the shapes in the domain. Now, we can define any shape for a given problem inside the domain, which is not updated during the evolution. This allows for using the sources of any kind in the problem studies, such as the colliding winds in the binary stars.
2008-12-18 12:18:36 -06:00
#ifdef SHAPE
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 problem , only : update_shapes
Add support for the shapes in the domain. Now, we can define any shape for a given problem inside the domain, which is not updated during the evolution. This allows for using the sources of any kind in the problem studies, such as the colliding winds in the binary stars.
2008-12-18 12:18:36 -06:00
#endif /* SHAPE */
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 scheme , only : update
use variables, only : nqt, nfl
GLM-MHD: update global solution. - update the magnetic field components and scalar potential in the Euler and RK2 methods, evolve_euler() and evolve_rk2() subroutines, respectively;
2010-12-01 10:53:21 -02:00
#ifdef MHD
use variables, only : ibx, ibz
#ifdef GLM
use variables, only : iph
#endif /* GLM */
#endif /* MHD */
New time integration method EULER.
2008-12-09 21:06:21 -06:00
implicit none
! input arguments
!
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
type(block_data), intent(inout) :: pblock
New time integration method EULER.
2008-12-09 21:06:21 -06:00
! local variables
!
real :: dxi, dyi, dzi
! local arrays
!
Remove flux calculation from the subroutine update(). SCHEME - remove the flux calculation from the subroutine update() and all dependent subroutines;
2010-09-19 00:08:20 +02:00
real, dimension(nqt,im,jm,km) :: du
New time integration method EULER.
2008-12-09 21:06:21 -06:00
!
!-------------------------------------------------------------------------------
!
! prepare dxi, dyi, and dzi
!
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
dxi = adxi(pblock%meta%level)
dyi = adyi(pblock%meta%level)
dzi = adzi(pblock%meta%level)
New time integration method EULER.
2008-12-09 21:06:21 -06:00
! 1st step of integration
!
Remove flux calculation from the subroutine update(). SCHEME - remove the flux calculation from the subroutine update() and all dependent subroutines;
2010-09-19 00:08:20 +02:00
call update(pblock%u, du, dxi, dyi, dzi)
Add support for the shapes in the domain. Now, we can define any shape for a given problem inside the domain, which is not updated during the evolution. This allows for using the sources of any kind in the problem studies, such as the colliding winds in the binary stars.
2008-12-18 12:18:36 -06:00
#ifdef SHAPE
! restrict update in a defined shape
!
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
call update_shapes(pblock, du)
Add support for the shapes in the domain. Now, we can define any shape for a given problem inside the domain, which is not updated during the evolution. This allows for using the sources of any kind in the problem studies, such as the colliding winds in the binary stars.
2008-12-18 12:18:36 -06:00
#endif /* SHAPE */
New time integration method EULER.
2008-12-09 21:06:21 -06:00
GLM-MHD: update global solution. - update the magnetic field components and scalar potential in the Euler and RK2 methods, evolve_euler() and evolve_rk2() subroutines, respectively;
2010-12-01 10:53:21 -02:00
! update the solution for the fluid variables
New time integration method EULER.
2008-12-09 21:06:21 -06:00
!
GLM-MHD: update global solution. - update the magnetic field components and scalar potential in the Euler and RK2 methods, evolve_euler() and evolve_rk2() subroutines, respectively;
2010-12-01 10:53:21 -02:00
pblock%u(1:nfl,:,:,:) = pblock%u(1:nfl,:,:,:) + dt * du(1:nfl,:,:,:)
#ifdef MHD
! update the solution for the magnetic variables
!
pblock%u(ibx:ibz,:,:,:) = pblock%u(ibx:ibz,:,:,:) + dt * du(ibx:ibz,:,:,:)
#ifdef GLM
! update the solution for the scalar potential Psi
!
pblock%u(iph,:,:,:) = pblock%u(iph,:,:,:) + dt * du(iph,:,:,:)
#endif /* GLM */
#endif /* MHD */
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
!
New time integration method EULER.
2008-12-09 21:06:21 -06:00
!-------------------------------------------------------------------------------
!
end subroutine evolve_euler
#endif /* EULER */
Runge-Kutta 2nd order time integration implemented. In addition, I've done some fixes to the problem initialization, and I defined new variables igrids, jgrids, kgrids, which specify the dimensions of the block.
2008-12-08 16:21:59 -06:00
#ifdef RK2
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
Updated comments in the evolution module.
2008-12-08 21:07:10 -06:00
!===============================================================================
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
Updated comments in the evolution module.
2008-12-08 21:07:10 -06:00
! evolve_rk2: subroutine evolves the current block using RK2 integration
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
Updated comments in the evolution module.
2008-12-08 21:07:10 -06:00
!===============================================================================
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
subroutine evolve_rk2(pblock)
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 blocks , only : block_data
use config , only : im, jm, km
use mesh , only : adxi, adyi, adzi
Add support for the shapes in the domain. Now, we can define any shape for a given problem inside the domain, which is not updated during the evolution. This allows for using the sources of any kind in the problem studies, such as the colliding winds in the binary stars.
2008-12-18 12:18:36 -06:00
#ifdef SHAPE
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 problem , only : update_shapes
Add support for the shapes in the domain. Now, we can define any shape for a given problem inside the domain, which is not updated during the evolution. This allows for using the sources of any kind in the problem studies, such as the colliding winds in the binary stars.
2008-12-18 12:18:36 -06:00
#endif /* SHAPE */
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 scheme , only : update
use variables, only : nqt, nfl
GLM-MHD: update global solution. - update the magnetic field components and scalar potential in the Euler and RK2 methods, evolve_euler() and evolve_rk2() subroutines, respectively;
2010-12-01 10:53:21 -02:00
#ifdef MHD
use variables, only : ibx, ibz
#ifdef GLM
use variables, only : iph
#endif /* GLM */
#endif /* MHD */
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
implicit none
! input arguments
!
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
type(block_data), intent(inout) :: pblock
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
! local variables
!
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
real :: dxi, dyi, dzi
Runge-Kutta 2nd order time integration implemented. In addition, I've done some fixes to the problem initialization, and I defined new variables igrids, jgrids, kgrids, which specify the dimensions of the block.
2008-12-08 16:21:59 -06:00
! local arrays
!
Remove flux calculation from the subroutine update(). SCHEME - remove the flux calculation from the subroutine update() and all dependent subroutines;
2010-09-19 00:08:20 +02:00
real, dimension(nqt,im,jm,km) :: u1, du
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
Updated comments in the evolution module.
2008-12-08 21:07:10 -06:00
!-------------------------------------------------------------------------------
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
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
! prepare dxi, dyi, and dzi
!
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
dxi = adxi(pblock%meta%level)
dyi = adyi(pblock%meta%level)
dzi = adzi(pblock%meta%level)
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
Runge-Kutta 2nd order time integration implemented. In addition, I've done some fixes to the problem initialization, and I defined new variables igrids, jgrids, kgrids, which specify the dimensions of the block.
2008-12-08 16:21:59 -06:00
! 1st step of integration
!
Remove flux calculation from the subroutine update(). SCHEME - remove the flux calculation from the subroutine update() and all dependent subroutines;
2010-09-19 00:08:20 +02:00
call update(pblock%u, du, dxi, dyi, dzi)
Add support for the shapes in the domain. Now, we can define any shape for a given problem inside the domain, which is not updated during the evolution. This allows for using the sources of any kind in the problem studies, such as the colliding winds in the binary stars.
2008-12-18 12:18:36 -06:00
#ifdef SHAPE
! restrict update in a defined shape
!
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
call update_shapes(pblock, du)
Add support for the shapes in the domain. Now, we can define any shape for a given problem inside the domain, which is not updated during the evolution. This allows for using the sources of any kind in the problem studies, such as the colliding winds in the binary stars.
2008-12-18 12:18:36 -06:00
#endif /* SHAPE */
Runge-Kutta 2nd order time integration implemented. In addition, I've done some fixes to the problem initialization, and I defined new variables igrids, jgrids, kgrids, which specify the dimensions of the block.
2008-12-08 16:21:59 -06:00
GLM-MHD: update global solution. - update the magnetic field components and scalar potential in the Euler and RK2 methods, evolve_euler() and evolve_rk2() subroutines, respectively;
2010-12-01 10:53:21 -02:00
! update the solution for the fluid variables
!
u1(1:nfl,:,:,:) = pblock%u(1:nfl,:,:,:) + dt * du(1:nfl,:,:,:)
#ifdef MHD
! update the solution for the magnetic variables
Runge-Kutta 2nd order time integration implemented. In addition, I've done some fixes to the problem initialization, and I defined new variables igrids, jgrids, kgrids, which specify the dimensions of the block.
2008-12-08 16:21:59 -06:00
!
GLM-MHD: update global solution. - update the magnetic field components and scalar potential in the Euler and RK2 methods, evolve_euler() and evolve_rk2() subroutines, respectively;
2010-12-01 10:53:21 -02:00
u1(ibx:ibz,:,:,:) = pblock%u(ibx:ibz,:,:,:) + dt * du(ibx:ibz,:,:,:)
#ifdef GLM
! update the solution for the scalar potential Psi
!
u1(iph,:,:,:) = pblock%u(iph,:,:,:) + dt * du(iph,:,:,:)
#endif /* GLM */
#endif /* MHD */
Runge-Kutta 2nd order time integration implemented. In addition, I've done some fixes to the problem initialization, and I defined new variables igrids, jgrids, kgrids, which specify the dimensions of the block.
2008-12-08 16:21:59 -06:00
! 2nd step of integration
!
Remove flux calculation from the subroutine update(). SCHEME - remove the flux calculation from the subroutine update() and all dependent subroutines;
2010-09-19 00:08:20 +02:00
call update(u1, du, dxi, dyi, dzi)
Runge-Kutta 2nd order time integration implemented. In addition, I've done some fixes to the problem initialization, and I defined new variables igrids, jgrids, kgrids, which specify the dimensions of the block.
2008-12-08 16:21:59 -06:00
Add support for the shapes in the domain. Now, we can define any shape for a given problem inside the domain, which is not updated during the evolution. This allows for using the sources of any kind in the problem studies, such as the colliding winds in the binary stars.
2008-12-18 12:18:36 -06:00
#ifdef SHAPE
! restrict update in a defined shape
!
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
call update_shapes(pblock, du)
Add support for the shapes in the domain. Now, we can define any shape for a given problem inside the domain, which is not updated during the evolution. This allows for using the sources of any kind in the problem studies, such as the colliding winds in the binary stars.
2008-12-18 12:18:36 -06:00
#endif /* SHAPE */
GLM-MHD: update global solution. - update the magnetic field components and scalar potential in the Euler and RK2 methods, evolve_euler() and evolve_rk2() subroutines, respectively;
2010-12-01 10:53:21 -02:00
! update the solution for the fluid variables
!
pblock%u(1:nfl,:,:,:) = 0.5d0 * (pblock%u(1:nfl,:,:,:) &
+ u1(1:nfl,:,:,:) + dt * du(1:nfl,:,:,:))
#ifdef MHD
! update the solution for the magnetic variables
!
pblock%u(ibx:ibz,:,:,:) = 0.5d0 * (pblock%u(ibx:ibz,:,:,:) &
+ u1(ibx:ibz,:,:,:) + dt * du(ibx:ibz,:,:,:))
#ifdef GLM
! update the solution for the scalar potential Psi
Runge-Kutta 2nd order time integration implemented. In addition, I've done some fixes to the problem initialization, and I defined new variables igrids, jgrids, kgrids, which specify the dimensions of the block.
2008-12-08 16:21:59 -06:00
!
GLM-MHD: update global solution. - update the magnetic field components and scalar potential in the Euler and RK2 methods, evolve_euler() and evolve_rk2() subroutines, respectively;
2010-12-01 10:53:21 -02:00
pblock%u(iph,:,:,:) = 0.5d0 * (pblock%u(iph,:,:,:) &
+ u1(iph,:,:,:) + dt * du(iph,:,:,:))
#endif /* GLM */
#endif /* MHD */
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
!
Updated comments in the evolution module.
2008-12-08 21:07:10 -06:00
!-------------------------------------------------------------------------------
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
end subroutine evolve_rk2
Runge-Kutta 2nd order time integration implemented. In addition, I've done some fixes to the problem initialization, and I defined new variables igrids, jgrids, kgrids, which specify the dimensions of the block.
2008-12-08 16:21:59 -06:00
#endif /* RK2 */
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
!
Updated comments in the evolution module.
2008-12-08 21:07:10 -06:00
!===============================================================================
New module 'evolution' for time integration. A new module for the time integration has been added. This module contains a set of subroutines to perform one step time integration of each leaf block using 2nd order Runge-Kutta method. More methods can be added later. Time 't', timestep 'dt' and iteration 'n' have been moved to this module as well.
2008-12-07 18:57:08 -06:00
!
end module
Reference in New Issue Copy Permalink