17 character(len=*),
parameter ::
fmt_r =
'es16.8' 18 character(len=*),
parameter ::
fmt_r2 =
'es10.2' 19 character(len=*),
parameter ::
fmt_i =
'i8' 29 integer :: len, ier, n
30 integer,
parameter :: max_files = 20
31 integer :: n_par_files
32 integer :: ibegin(max_files)
33 integer :: iterm(max_files)
34 character(len=max_files*std_len) :: all_par_files
35 character(len=std_len) :: tmp_files(max_files)
39 print *,
'-----------------------------------------------------------------------------' 40 print *,
'-----------------------------------------------------------------------------' 41 print *,
'| __ __ ____ ___ _ __ __ ______ ___ ____ |' 42 print *,
'| | \/ | _ \_ _| / \ | \/ | _ \ \ / / \ / ___| |' 43 print *,
'| | |\/| | |_) | |_____ / _ \ | |\/| | |_) \ \ / / _ \| | |' 44 print *,
'| | | | | __/| |_____/ ___ \| | | | _ < \ V / ___ \ |___ |' 45 print *,
'| |_| |_|_| |___| /_/ \_\_| |_|_| \_\ \_/_/ \_\____| |' 46 print *,
'-----------------------------------------------------------------------------' 47 print *,
'-----------------------------------------------------------------------------' 52 ' -slicenext -1 -collapsenext -1 -snapshotnext -1' // &
53 ' --help .false. -convert .false. -resume .false.')
56 call retrev(
'cmd_i', all_par_files, len, ier)
59 if (
lget(
'cmd_-help') .or. len == 0)
then 61 print *,
'Usage example:' 62 print *,
'mpirun -np 4 ./amrvac -i file.par [file2.par ...]' 63 print *,
' (later .par files override earlier ones)' 65 print *,
'Optional arguments:' 66 print *,
'-resume Resume previous run' 67 print *,
'-convert Convert snapshot files' 68 print *,
'-if file0001.dat Use this snapshot to restart from' 69 print *,
' (you can modify e.g. output names)' 70 print *,
'-resume Automatically resume previous run' 71 print *,
' (useful for long runs on HPC systems)' 72 print *,
'-snapshotnext N Manual index for next snapshot' 73 print *,
'-slicenext N Manual index for next slice output' 74 print *,
'-collapsenext N Manual index for next collapsed output' 83 tmp_files, n_par_files)
109 logical :: fileopen, file_exists
110 integer :: i, j, k, ifile, io_state
111 integer :: iB, isave, iw, level, idim, islice
112 integer :: nx_vec(^nd), block_nx_vec(^nd)
113 integer :: my_unit, iostate
115 double precision :: dx_vec(^nd)
118 character(len=80) :: fmt_string
119 character(len=std_len) :: err_msg, restart_from_file_arg
120 character(len=std_len) :: basename_full, basename_prev, dummy_file
121 character(len=std_len),
dimension(:),
allocatable :: &
122 typeboundary_min^D, typeboundary_max^D
123 character(len=std_len),
allocatable :: limiter(:)
124 character(len=std_len),
allocatable :: gradient_limiter(:)
125 character(len=name_len) :: stretch_dim(
ndim)
127 double precision,
dimension(nsavehi) :: tsave_log, tsave_dat, tsave_slice, &
128 tsave_collapsed, tsave_custom
129 double precision :: dtsave_log, dtsave_dat, dtsave_slice, &
130 dtsave_collapsed, dtsave_custom
131 integer :: ditsave_log, ditsave_dat, ditsave_slice, &
132 ditsave_collapsed, ditsave_custom
133 double precision :: tsavestart_log, tsavestart_dat, tsavestart_slice, &
134 tsavestart_collapsed, tsavestart_custom
135 integer :: windex, ipower
136 double precision :: sizeuniformpart^D
148 tsave_log, tsave_dat, tsave_slice, tsave_collapsed, tsave_custom, &
149 dtsave_log, dtsave_dat, dtsave_slice, dtsave_collapsed, dtsave_custom, &
150 ditsave_log, ditsave_dat, ditsave_slice, ditsave_collapsed, ditsave_custom,&
151 tsavestart_log, tsavestart_dat, tsavestart_slice, tsavestart_collapsed,&
213 allocate(typeboundary_min^d(nwfluxbc))
214 allocate(typeboundary_max^d(nwfluxbc))
310 tsave(isave,ifile) = bigdouble
311 itsave(isave,ifile) = biginteger
320 tsave_log = bigdouble
321 tsave_dat = bigdouble
322 tsave_slice = bigdouble
323 tsave_collapsed = bigdouble
324 tsave_custom = bigdouble
326 dtsave_log = bigdouble
327 dtsave_dat = bigdouble
328 dtsave_slice = bigdouble
329 dtsave_collapsed = bigdouble
330 dtsave_custom = bigdouble
332 ditsave_log = biginteger
333 ditsave_dat = biginteger
334 ditsave_slice = biginteger
335 ditsave_collapsed = biginteger
336 ditsave_custom = biginteger
338 tsavestart_log = bigdouble
339 tsavestart_dat = bigdouble
340 tsavestart_slice = bigdouble
341 tsavestart_collapsed = bigdouble
342 tsavestart_custom = bigdouble
382 limiter(level) =
'minmod' 383 gradient_limiter(level) =
'minmod' 415 if(i==j.or.j==k.or.k==i)
then 417 else if(i+1==j.or.i-2==j)
then 434 inquire(file=trim(
par_files(i)), exist=file_exists)
436 if (.not. file_exists)
then 437 write(err_msg, *)
"The parameter file " // trim(
par_files(i)) // &
447 read(
unitpar, filelist, end=101)
450 read(
unitpar, savelist, end=102)
453 read(
unitpar, stoplist, end=103)
456 read(
unitpar, methodlist, end=104)
459 read(
unitpar, boundlist, end=105)
462 read(
unitpar, meshlist, end=106)
465 read(
unitpar, paramlist, end=107)
468 read(
unitpar, euvlist, end=108)
483 open(newunit=my_unit, file=trim(dummy_file), iostat=iostate)
484 if (iostate /= 0)
then 485 call mpistop(
"Can't write to output directory (" // &
488 close(my_unit, status=
'delete')
515 if(
mype==0)
write(*,*)
"No snapshots found to resume from, start a new run..." 528 call mpistop(
"Please restart from a snapshot when firstprocess=T")
530 call mpistop(
'Change convert to .false. for a new run!')
540 where (tsave_log < bigdouble)
tsave(:, 1) = tsave_log
541 where (tsave_dat < bigdouble)
tsave(:, 2) = tsave_dat
542 where (tsave_slice < bigdouble)
tsave(:, 3) = tsave_slice
543 where (tsave_collapsed < bigdouble)
tsave(:, 4) = tsave_collapsed
544 where (tsave_custom < bigdouble)
tsave(:, 5) = tsave_custom
546 if (dtsave_log < bigdouble)
dtsave(1) = dtsave_log
547 if (dtsave_dat < bigdouble)
dtsave(2) = dtsave_dat
548 if (dtsave_slice < bigdouble)
dtsave(3) = dtsave_slice
549 if (dtsave_collapsed < bigdouble)
dtsave(4) = dtsave_collapsed
550 if (dtsave_custom < bigdouble)
dtsave(5) = dtsave_custom
552 if (tsavestart_log < bigdouble)
tsavestart(1) = tsavestart_log
553 if (tsavestart_dat < bigdouble)
tsavestart(2) = tsavestart_dat
554 if (tsavestart_slice < bigdouble)
tsavestart(3) = tsavestart_slice
555 if (tsavestart_collapsed < bigdouble)
tsavestart(4) = tsavestart_collapsed
556 if (tsavestart_custom < bigdouble)
tsavestart(5) = tsavestart_custom
558 if (ditsave_log < bigdouble)
ditsave(1) = ditsave_log
559 if (ditsave_dat < bigdouble)
ditsave(2) = ditsave_dat
560 if (ditsave_slice < bigdouble)
ditsave(3) = ditsave_slice
561 if (ditsave_collapsed < bigdouble)
ditsave(4) = ditsave_collapsed
562 if (ditsave_custom < bigdouble)
ditsave(5) = ditsave_custom
568 write(
unitterm, *)
'Output type | tsavestart | dtsave | ditsave | itsave(1) | tsave(1)' 569 write(fmt_string, *)
'(A12," | ",E9.3E2," | ",E9.3E2," | ",I6," | "'//&
582 write(
uniterr,*)
'Warning in read_par_files: ', &
583 'Slice ', islice,
' direction',
slicedir(islice),
'larger than ndim=',
ndim 585 write(
uniterr,*)
'Warning in read_par_files: ', &
586 'Slice ', islice,
' direction',
slicedir(islice),
'too small, should be [',1,
ndim,
']' 590 'Warning in read_par_files: it_max or time_max not given!' 594 call mpistop(
" tvd is onestep method, reset time_integrator='onestep'")
597 'Warning: setting dimsplit=T for tvd, as used for level=',level
601 call mpistop(
"Cannot use hlld flux if not using MHD physics!")
611 case (
'tvdlf',
'tvdmu')
621 case (
'nul',
'source',
'tvd')
624 call mpistop(
"No default predictor for this full step")
635 case (
"twostep",
"twostep_trapezoidal")
639 case (
"fourstep",
"rk4",
"jameson",
"ssprk43")
644 call mpistop(
"Unknown time_integrator")
648 select case (stretch_dim(i))
652 case (
'uni',
'uniform')
655 case (
'symm',
'symmetric')
662 call mpistop(
'Unknown stretch type')
674 write(*,*)
'Warning: coordinate system is not specified!' 675 write(*,*)
'call set_coordinate_system in usr_init in mod_usr.t' 676 write(*,*)
'Now use Cartesian coordinate' 694 if(
mype==0)print *,
'Warning: spherical symmetry needs dimsplit=F, resetting' 712 call mpistop(
" PPM with flatsh=.true. can not be used with physics_type='rho'!")
717 if (any(typeboundary_min^d /=
undefined))
then 718 typeboundary(1:nwfluxbc, 2*^d-1) = typeboundary_min^d(1:nwfluxbc)
721 if (any(typeboundary_max^d /=
undefined))
then 722 typeboundary(1:nwfluxbc, 2*^d) = typeboundary_max^d(1:nwfluxbc)
727 if (nwfluxbc<nwflux)
then 728 do iw = nwfluxbc+1, nwflux
734 call mpistop(
"Not all boundary conditions have been defined")
743 call mpistop(
"Wrong counterpart in periodic boundary")
747 call mpistop(
"Each dimension should either have all "//&
748 "or no variables periodic, some can be aperiodic")
772 call mpistop(
'Pole is in cylindrical, polar, spherical coordinates!')
793 call mpistop(
'Pole is in cylindrical, polar, spherical coordinates!')
800 if(any(limiter(1:
nlevelshi)==
'mp5'))
then 804 if(any(limiter(1:
nlevelshi)==
'weno5'))
then 808 if(any(limiter(1:
nlevelshi)==
'wenoz5'))
then 812 if(any(limiter(1:
nlevelshi)==
'wenozp5'))
then 816 if(any(limiter(1:
nlevelshi)==
'ppm'))
then 820 if(any(limiter(1:
nlevelshi)==
'weno7'))
then 824 if(any(limiter(1:
nlevelshi)==
'mpweno7'))
then 828 if(any(limiter(1:
nlevelshi)==
'exeno7'))
then 860 if (any(nx_vec < 4) .or. any(mod(nx_vec, 2) == 1)) &
861 call mpistop(
'Grid size (domain_nx^D) has to be even and >= 4')
863 if (any(block_nx_vec < 4) .or. any(mod(block_nx_vec, 2) == 1)) &
864 call mpistop(
'Block size (block_nx^D) has to be even and >= 4')
867 print *,
"TODO: possible bug when domain_nx^D/block_nx^D == 1" 871 call mpistop(
'Grid (domain_nx^D) and block (block_nx^D) must be consistent') \}
875 call mpistop(
"Reset nlevelshi and recompile!")
889 write(*,*)
'stretched grid needs finite qstretch_baselevel>1' 890 write(*,*)
'will try default value for qstretch_baselevel in dimension', ^d
892 if(xprobmin^d>smalldouble)
then 895 call mpistop(
"can not set qstretch_baselevel automatically")
899 call mpistop(
"stretched grid needs even block size block_nxD")
901 call mpistop(
"number level 1 blocks in D must be even")
903 dxfirst(1,^d)=(xprobmax^d-xprobmin^d) &
917 write(*,*)
'Stretched dimension ', ^d
922 {
if(stretch_type(^d) == stretch_symm)
then 924 write(*,*)
'will apply symmetric stretch in dimension', ^d
926 if(mod(block_nx^d,2)==1) &
927 call mpistop(
"stretched grid needs even block size block_nxD")
929 if(nstretchedblocks_baselevel(^d)==0) &
930 call mpistop(
"need finite even number of stretched blocks at baselevel")
931 if(mod(nstretchedblocks_baselevel(^d),2)==1) &
932 call mpistop(
"need even number of stretched blocks at baselevel")
933 if(qstretch_baselevel(^d)<1.0d0.or.qstretch_baselevel(^d)==bigdouble) &
934 call mpistop(
'stretched grid needs finite qstretch_baselevel>1')
936 ipower=(nstretchedblocks_baselevel(^d)/2)*block_nx^d
937 if(nstretchedblocks_baselevel(^d)==domain_nx^d/block_nx^d)
then 938 xstretch^d=0.5d0*(xprobmax^d-xprobmin^d)
940 xstretch^d=(xprobmax^d-xprobmin^d) &
941 /(2.0d0+dble(domain_nx^d-nstretchedblocks_baselevel(^d)*block_nx^d) &
942 *(1.0d0-qstretch_baselevel(^d))/(1.0d0-qstretch_baselevel(^d)**ipower))
944 if(xstretch^d>(xprobmax^d-xprobmin^d)*0.5d0) &
945 call mpistop(
" stretched grid part should not exceed full domain")
946 dxfirst(1,^d)=xstretch^d*(1.0d0-qstretch_baselevel(^d)) &
947 /(1.0d0-qstretch_baselevel(^d)**ipower)
948 nstretchedblocks(1,^d)=nstretchedblocks_baselevel(^d)
949 qstretch(1,^d)=qstretch_baselevel(^d)
950 qstretch(0,^d)=qstretch(1,^d)**2
951 dxfirst(0,^d)=dxfirst(1,^d)*(1.0d0+qstretch(1,^d))
952 dxmid(1,^d)=dxfirst(1,^d)
953 dxmid(0,^d)=dxfirst(1,^d)*2.0d0
954 if(refine_max_level>1)
then 955 do ilev=2,refine_max_level
956 nstretchedblocks(ilev,^d)=2*nstretchedblocks(ilev-1,^d)
957 qstretch(ilev,^d)=dsqrt(qstretch(ilev-1,^d))
958 dxfirst(ilev,^d)=dxfirst(ilev-1,^d) &
959 /(1.0d0+dsqrt(qstretch(ilev-1,^d)))
960 dxmid(ilev,^d)=dxmid(ilev-1,^d)/2.0d0
964 sizeuniformpart^d=dxfirst(1,^d) &
965 *(domain_nx^d-nstretchedblocks_baselevel(^d)*block_nx^d)
967 print *,
'uniform part of size=',sizeuniformpart^d
968 print *,
'setting of domain is then=',2*xstretch^d+sizeuniformpart^d
969 print *,
'versus=',xprobmax^d-xprobmin^d
971 if(dabs(xprobmax^d-xprobmin^d-2*xstretch^d-sizeuniformpart^d)>smalldouble)
then 972 call mpistop(
'mismatch in domain size!')
975 dxfirst_1mq(0:refine_max_level,1:ndim)=dxfirst(0:refine_max_level,1:ndim) &
976 /(1.0d0-qstretch(0:refine_max_level,1:ndim))
979 dx_vec = [{xprobmax^d-xprobmin^d|, }] / nx_vec
982 write(c_ndim,
'(I1)') ^nd
983 write(unitterm,
'(A30,' // c_ndim //
'(I0," "))') &
984 ' Domain size (cells): ', nx_vec
985 write(unitterm,
'(A30,' // c_ndim //
'(E9.3," "))') &
986 ' Level one dx: ', dx_vec
989 if (any(dx_vec < smalldouble)) &
990 call mpistop(
"Incorrect domain size (too small grid spacing)")
994 if(sum(w_refine_weight(:))==0) w_refine_weight(1) = 1.d0
995 if(dabs(sum(w_refine_weight(:))-1.d0)>smalldouble)
then 996 write(unitterm,*)
"Sum of all elements in w_refine_weight be 1.d0" 997 call mpistop(
"Reset w_refine_weight so the sum is 1.d0")
1000 if (mype==0)
write(unitterm,
'(A30)', advance=
'no')
'Refine estimation: ' 1002 select case (refine_criterion)
1004 if (mype==0)
write(unitterm,
'(A)')
"user defined" 1006 if (mype==0)
write(unitterm,
'(A)')
"relative error" 1008 if (mype==0)
write(unitterm,
'(A)')
"Lohner's original scheme" 1010 if (mype==0)
write(unitterm,
'(A)')
"Lohner's scheme" 1012 call mpistop(
"Unknown error estimator, change refine_criterion")
1015 if (tfixgrid<bigdouble/2.0d0)
then 1016 if(mype==0)print*,
'Warning, at time=',tfixgrid,
'the grid will be fixed' 1018 if (itfixgrid<biginteger/2)
then 1019 if(mype==0)print*,
'Warning, at iteration=',itfixgrid,
'the grid will be fixed' 1021 if (ditregrid>1)
then 1022 if(mype==0)print*,
'Note, Grid is reconstructed once every',ditregrid,
'iterations' 1027 select case(slicedir(islice))
1029 if(slicecoord(islice)<xprobmin^d.or.slicecoord(islice)>xprobmax^d) &
1030 write(uniterr,*)
'Warning in read_par_files: ', &
1031 'Slice ', islice,
' coordinate',slicecoord(islice),
'out of bounds for dimension ',slicedir(islice)
1037 write(unitterm,
'(A30,A,A)')
'restart_from_file: ',
' ', trim(restart_from_file)
1038 write(unitterm,
'(A30,L1)')
'converting: ', convert
1039 write(unitterm,
'(A)')
'' 1047 character(len=*),
intent(in) :: line
1049 character(len=*),
intent(in) :: delims
1051 integer,
intent(in) :: n_max
1053 integer,
intent(inout) :: n_found
1055 character(len=*),
intent(inout) :: fields(n_max)
1056 logical,
intent(out),
optional :: fully_read
1058 integer :: ixs_start(n_max)
1059 integer :: ixs_end(n_max)
1060 integer :: ix, ix_prev
1065 do while (n_found < n_max)
1067 ix = verify(line(ix_prev+1:), delims)
1070 n_found = n_found + 1
1071 ixs_start(n_found) = ix_prev + ix
1074 ix = scan(line(ixs_start(n_found)+1:), delims) - 1
1077 ixs_end(n_found) = len(line)
1079 ixs_end(n_found) = ixs_start(n_found) + ix
1082 fields(n_found) = line(ixs_start(n_found):ixs_end(n_found))
1083 ix_prev = ixs_end(n_found)
1086 if (
present(fully_read))
then 1087 ix = verify(line(ix_prev+1:), delims)
1088 fully_read = (ix == 0)
1121 case (
'regression_test')
1125 call mpistop(
"usr_print_log not defined")
1130 call mpistop(
"Error in SaveFile: Unknown typefilelog")
1137 write(*,*)
'No save method is defined for ifile=',ifile
1149 integer,
intent(out) :: fh
1150 integer,
intent(in) :: ix
1151 character(len=*),
intent(in) :: extension
1152 character(len=*),
intent(in),
optional :: suffix
1153 character(len=std_len) :: filename
1156 if (ix >= 10000)
then 1157 call mpistop(
"Number of output files is limited to 10000 (0...9999)")
1160 if (
present(suffix))
then 1162 trim(suffix), ix, extension
1164 write(filename,
"(a,i4.4,a)") trim(
base_filename), ix, extension
1171 amode = ior(mpi_mode_create, mpi_mode_wronly)
1172 call mpi_file_open(mpi_comm_self,filename,amode, &
1176 print *,
"Error, cannot create file ", trim(filename)
1185 integer,
intent(in) :: ix
1186 character(len=std_len) :: filename
1188 write(filename,
"(a,i4.4,a)") trim(
base_filename), ix,
".dat" 1193 character(len=*),
intent(in) :: filename
1197 i = len_trim(filename) - 7
1210 integer,
intent(in) :: fh
1211 integer(kind=MPI_OFFSET_KIND),
intent(in) :: offset_tree
1212 integer(kind=MPI_OFFSET_KIND),
intent(in) :: offset_block
1213 integer,
dimension(MPI_STATUS_SIZE) :: st
1217 call mpi_file_write(fh, int(offset_tree), 1, mpi_integer, st, er)
1218 call mpi_file_write(fh, int(offset_block), 1, mpi_integer, st, er)
1219 call mpi_file_write(fh, nw, 1, mpi_integer, st, er)
1220 call mpi_file_write(fh,
ndir, 1, mpi_integer, st, er)
1221 call mpi_file_write(fh,
ndim, 1, mpi_integer, st, er)
1222 call mpi_file_write(fh,
levmax, 1, mpi_integer, st, er)
1223 call mpi_file_write(fh,
nleafs, 1, mpi_integer, st, er)
1224 call mpi_file_write(fh,
nparents, 1, mpi_integer, st, er)
1225 call mpi_file_write(fh,
it, 1, mpi_integer, st, er)
1228 call mpi_file_write(fh,
global_time, 1, mpi_double_precision, st, er)
1230 call mpi_file_write(fh, [ xprobmin^
d ],
ndim, &
1231 mpi_double_precision, st, er)
1232 call mpi_file_write(fh, [ xprobmax^
d ],
ndim, &
1233 mpi_double_precision, st, er)
1235 mpi_integer, st, er)
1237 mpi_integer, st, er)
1240 call mpi_file_write(fh,
periodb,
ndim, mpi_logical, st, er)
1244 name_len, mpi_character, st, er)
1247 call mpi_file_write(fh,
stagger_grid, 1, mpi_logical, st, er)
1250 call mpi_file_write(fh, cons_wnames(iw), name_len, mpi_character, st, er)
1254 call mpi_file_write(fh,
physics_type, name_len, mpi_character, st, er)
1265 call mpi_file_write(fh,
snapshotnext, 1, mpi_integer, st, er)
1267 call mpi_file_write(fh,
snapshotnext+1, 1, mpi_integer, st, er)
1269 call mpi_file_write(fh,
slicenext, 1, mpi_integer, st, er)
1270 call mpi_file_write(fh,
collapsenext, 1, mpi_integer, st, er)
1283 integer,
intent(in) :: fh
1284 integer(MPI_OFFSET_KIND),
intent(out) :: offset_tree
1285 integer(MPI_OFFSET_KIND),
intent(out) :: offset_block
1286 integer :: i, version
1287 integer :: ibuf(
ndim), iw
1288 double precision :: rbuf(
ndim)
1289 integer,
dimension(MPI_STATUS_SIZE) :: st
1290 character(len=name_len),
allocatable :: var_names(:), param_names(:)
1291 double precision,
allocatable :: params(:)
1292 character(len=name_len) :: phys_name, geom_name
1293 integer :: er, n_par, tmp_int
1294 logical :: stagger_mark_dat, periodic(
ndim)
1297 call mpi_file_read(fh, version, 1, mpi_integer, st, er)
1299 call mpistop(
"Incompatible file version (maybe old format?)")
1303 call mpi_file_read(fh, ibuf(1), 1, mpi_integer, st, er)
1304 offset_tree = ibuf(1)
1307 call mpi_file_read(fh, ibuf(1), 1, mpi_integer, st, er)
1308 offset_block = ibuf(1)
1311 call mpi_file_read(fh, ibuf(1), 1, mpi_integer, st, er)
1313 if (nw /= ibuf(1))
then 1314 write(*,*)
"nw=",nw,
" and nw found in restart file=",ibuf(1)
1315 write(*,*)
"Please be aware of changes in w at restart." 1320 call mpi_file_read(fh, ibuf(1), 1, mpi_integer, st, er)
1321 if (ibuf(1) /=
ndir)
then 1322 write(*,*)
"ndir in restart file = ",ibuf(1)
1323 write(*,*)
"ndir = ",
ndir 1324 call mpistop(
"reset ndir to ndir in restart file")
1328 call mpi_file_read(fh, ibuf(1), 1, mpi_integer, st, er)
1329 if (ibuf(1) /=
ndim)
then 1330 write(*,*)
"ndim in restart file = ",ibuf(1)
1331 write(*,*)
"ndim = ",
ndim 1332 call mpistop(
"reset ndim to ndim in restart file")
1336 call mpi_file_read(fh, ibuf(1), 1, mpi_integer, st, er)
1338 write(*,*)
"number of levels in restart file = ",ibuf(1)
1340 call mpistop(
"refine_max_level < num. levels in restart file")
1344 call mpi_file_read(fh,
nleafs, 1, mpi_integer, st, er)
1347 call mpi_file_read(fh,
nparents, 1, mpi_integer, st, er)
1350 call mpi_file_read(fh,
it, 1, mpi_integer, st, er)
1353 call mpi_file_read(fh,
global_time, 1, mpi_double_precision, st, er)
1356 call mpi_file_read(fh,rbuf(1:
ndim),
ndim,mpi_double_precision,st,er)
1357 if (maxval(abs(rbuf(1:
ndim) - [ xprobmin^
d ])) > 0)
then 1358 write(*,*)
"Error: xprobmin differs from restart data: ", rbuf(1:
ndim)
1359 call mpistop(
"change xprobmin^D in par file")
1363 call mpi_file_read(fh,rbuf(1:
ndim),
ndim,mpi_double_precision,st,er)
1364 if (maxval(abs(rbuf(1:
ndim) - [ xprobmax^
d ])) > 0)
then 1365 write(*,*)
"Error: xprobmax differs from restart data: ", rbuf(1:
ndim)
1366 call mpistop(
"change xprobmax^D in par file")
1370 call mpi_file_read(fh,ibuf(1:
ndim),
ndim, mpi_integer,st,er)
1372 write(*,*)
"Error: mesh size differs from restart data: ", ibuf(1:
ndim)
1373 call mpistop(
"change domain_nx^D in par file")
1377 call mpi_file_read(fh,ibuf(1:
ndim),
ndim, mpi_integer,st,er)
1379 write(*,*)
"Error: block size differs from restart data:", ibuf(1:
ndim)
1380 call mpistop(
"change block_nx^D in par file")
1384 if (version > 4)
then 1385 call mpi_file_read(fh, periodic,
ndim, mpi_logical, st, er)
1386 if (any(periodic .neqv.
periodb)) &
1387 call mpistop(
"change in periodicity in par file")
1389 call mpi_file_read(fh, geom_name, name_len, mpi_character, st, er)
1392 write(*,*)
"type of coordinates in data is: ", geom_name
1393 call mpistop(
"select the correct coordinates in mod_usr.t file")
1396 call mpi_file_read(fh, stagger_mark_dat, 1, mpi_logical, st, er)
1398 write(*,*)
"Error: stagger grid flag differs from restart data:", stagger_mark_dat
1399 call mpistop(
"change parameter to use stagger grid")
1404 if (version > 3)
then 1408 call mpi_file_read(fh, var_names(iw), name_len, mpi_character, st, er)
1412 call mpi_file_read(fh, phys_name, name_len, mpi_character, st, er)
1415 call mpistop(
"Cannot restart with a different physics type")
1418 call mpi_file_read(fh, n_par, 1, mpi_integer, st, er)
1419 allocate(params(n_par))
1420 allocate(param_names(n_par))
1421 call mpi_file_read(fh, params, n_par, mpi_double_precision, st, er)
1422 call mpi_file_read(fh, param_names, name_len * n_par, mpi_character, st, er)
1425 call mpi_file_read(fh, tmp_int, 1, mpi_integer, st, er)
1430 call mpi_file_read(fh, tmp_int, 1, mpi_integer, st, er)
1433 call mpi_file_read(fh, tmp_int, 1, mpi_integer, st, er)
1450 pure integer function count_ix(ixO^L)
1451 integer,
intent(in) :: ixO^L
1453 count_ix = product([ ixomax^d ] - [ ixomin^d ] + 1)
1461 integer,
intent(in) :: igrid
1464 integer,
intent(out) :: n_ghost(2*
ndim)
1466 integer,
intent(out) :: ixO^L
1468 integer,
intent(out) :: n_values
1477 if(ps(igrid)%is_physical_boundary(2*idim-1)) n_ghost(idim)=
nghostcells 1479 if(ps(igrid)%is_physical_boundary(2*idim)) n_ghost(
ndim+idim)=
nghostcells 1483 {ixomin^
d = ixmlo^
d - n_ghost(^
d)\}
1484 {ixomax^
d = ixmhi^
d + n_ghost(
ndim+^
d)\}
1495 integer :: file_handle, igrid, Morton_no, iwrite
1496 integer :: ipe, ix_buffer(2*
ndim+1), n_values
1497 integer :: ixO^L, n_ghost(2*
ndim)
1498 integer :: ixOs^L,n_values_stagger
1499 integer :: iorecvstatus(mpi_status_size)
1500 integer :: ioastatus(mpi_status_size)
1501 integer :: igrecvstatus(mpi_status_size)
1502 integer :: istatus(mpi_status_size)
1504 integer(kind=MPI_OFFSET_KIND) :: offset_tree_info
1505 integer(kind=MPI_OFFSET_KIND) :: offset_block_data
1506 integer(kind=MPI_OFFSET_KIND) :: offset_offsets
1507 double precision,
allocatable :: w_buffer(:)
1509 integer,
allocatable :: block_ig(:, :)
1510 integer,
allocatable :: block_lvl(:)
1511 integer(kind=MPI_OFFSET_KIND),
allocatable :: block_offset(:)
1518 n_values = n_values +
count_ix(ixgs^
ll) * nws
1520 allocate(w_buffer(n_values))
1524 allocate(block_lvl(
nleafs))
1525 allocate(block_offset(
nleafs+1))
1532 offset_tree_info = -1
1533 offset_block_data = -1
1537 call mpi_file_get_position(file_handle, offset_tree_info,
ierrmpi)
1544 igrid =
sfc(1, morton_no)
1545 ipe =
sfc(2, morton_no)
1548 block_ig(:, morton_no) = [ pnode%ig^
d ]
1549 block_lvl(morton_no) = pnode%level
1550 block_offset(morton_no) = 0
1553 call mpi_file_write(file_handle, block_lvl,
size(block_lvl), &
1554 mpi_integer, istatus,
ierrmpi)
1556 call mpi_file_write(file_handle, block_ig,
size(block_ig), &
1557 mpi_integer, istatus,
ierrmpi)
1560 call mpi_file_get_position(file_handle, offset_offsets,
ierrmpi)
1561 call mpi_file_write(file_handle, block_offset(1:
nleafs),
nleafs, &
1564 call mpi_file_get_position(file_handle, offset_block_data,
ierrmpi)
1567 if (offset_block_data - offset_tree_info /= &
1569 nleafs * ((1+
ndim) * size_int + 2 * size_int))
then 1571 print *,
"Warning: MPI_OFFSET type /= 8 bytes" 1572 print *,
"This *could* cause problems when reading .dat files" 1576 block_offset(1) = offset_block_data
1592 ixm^
ll^ladd1,
"write_snapshot")
1597 w_buffer(1:n_values) = pack(ps(igrid)%w(ixo^s, 1:nw), .true.)
1598 {ixosmin^
d = ixomin^
d -1\}
1599 {ixosmax^
d = ixomax^
d \}
1600 n_values_stagger=
count_ix(ixos^l)*nws
1601 w_buffer(n_values+1:n_values+n_values_stagger) = pack(ps(igrid)%ws(ixos^s, 1:nws), .true.)
1602 n_values=n_values+n_values_stagger
1604 w_buffer(1:n_values) = pack(ps(igrid)%w(ixo^s, 1:nw), .true.)
1606 ix_buffer(1) = n_values
1607 ix_buffer(2:) = n_ghost
1610 call mpi_send(ix_buffer, 2*
ndim+1, &
1612 call mpi_send(w_buffer, n_values, &
1616 call mpi_file_write(file_handle, ix_buffer(2:), &
1618 call mpi_file_write(file_handle, w_buffer, &
1619 n_values, mpi_double_precision, istatus,
ierrmpi)
1622 block_offset(iwrite+1) = block_offset(iwrite) + &
1623 int(n_values, mpi_offset_kind) * size_double + &
1635 call mpi_recv(ix_buffer, 2*
ndim+1, mpi_integer, ipe,
itag,
icomm,&
1637 n_values = ix_buffer(1)
1639 call mpi_recv(w_buffer, n_values, mpi_double_precision,&
1642 call mpi_file_write(file_handle, ix_buffer(2:), &
1644 call mpi_file_write(file_handle, w_buffer, &
1645 n_values, mpi_double_precision, istatus,
ierrmpi)
1648 block_offset(iwrite+1) = block_offset(iwrite) + &
1649 int(n_values, mpi_offset_kind) * size_double + &
1655 call mpi_file_seek(file_handle, offset_offsets, mpi_seek_set,
ierrmpi)
1656 call mpi_file_write(file_handle, block_offset(1:
nleafs),
nleafs, &
1660 call mpi_file_seek(file_handle, 0_mpi_offset_kind, mpi_seek_set,
ierrmpi)
1664 call mpi_file_close(file_handle,
ierrmpi)
1679 integer :: ix_buffer(2*
ndim+1), n_values, n_values_stagger
1680 integer :: ixO^L, ixOs^L
1681 integer :: file_handle, amode, igrid, Morton_no, iread
1682 integer :: istatus(mpi_status_size)
1683 integer :: iorecvstatus(mpi_status_size)
1684 integer :: ipe,inrecv,nrecv, file_version
1686 integer(MPI_OFFSET_KIND) :: offset_tree_info
1687 integer(MPI_OFFSET_KIND) :: offset_block_data
1688 double precision,
allocatable :: w_buffer(:)
1689 double precision,
dimension(:^D&,:),
allocatable :: w, ws
1696 mpi_info_null,file_handle,
ierrmpi)
1697 call mpi_file_read(file_handle, file_version, 1, mpi_integer, &
1701 call mpi_bcast(file_version,1,mpi_integer,0,
icomm,
ierrmpi)
1704 if (
mype == 0) print *,
"Unknown version, trying old snapshot reader..." 1705 call mpi_file_close(file_handle,
ierrmpi)
1719 else if (
mype == 0)
then 1720 call mpi_file_seek(file_handle, 0_mpi_offset_kind, mpi_seek_set,
ierrmpi)
1739 n_values = n_values +
count_ix(ixgs^
ll) * nws
1740 allocate(ws(ixgs^t,1:nws))
1742 allocate(w_buffer(n_values))
1748 call mpi_file_seek(file_handle, offset_tree_info, &
1760 call mpi_file_seek(file_handle, offset_block_data, mpi_seek_set,
ierrmpi)
1768 call mpi_file_read(file_handle,ix_buffer(1:2*
ndim), 2*
ndim, &
1772 {ixomin^
d = ixmlo^
d - ix_buffer(^
d)\}
1773 {ixomax^
d = ixmhi^
d + ix_buffer(
ndim+^
d)\}
1776 {ixosmin^
d = ixomin^
d - 1\}
1777 {ixosmax^
d = ixomax^
d\}
1778 n_values_stagger = n_values
1779 n_values = n_values +
count_ix(ixos^l) * nws
1782 call mpi_file_read(file_handle, w_buffer, n_values, &
1783 mpi_double_precision, istatus,
ierrmpi)
1785 if (
mype == ipe)
then 1788 w(ixo^s, 1:
nw_found) = reshape(w_buffer(1:n_values_stagger), &
1790 ps(igrid)%ws(ixos^s,1:nws)=reshape(w_buffer(n_values_stagger+1:n_values), &
1791 shape(ws(ixos^s, 1:nws)))
1793 w(ixo^s, 1:
nw_found) = reshape(w_buffer(1:n_values), &
1806 ps(igrid)%w(ixo^s,1:nw)=w(ixo^s,1:nw)
1809 ps(igrid)%w(ixo^s,1:nw)=w(ixo^s,1:nw)
1812 call mpi_send([ ixo^l, n_values ], 2*
ndim+1, &
1814 call mpi_send(w_buffer, n_values, &
1820 call mpi_file_close(file_handle,
ierrmpi)
1828 call mpi_recv(ix_buffer, 2*
ndim+1, mpi_integer, 0,
itag,
icomm,&
1830 {ixomin^
d = ix_buffer(^
d)\}
1831 {ixomax^
d = ix_buffer(
ndim+^
d)\}
1832 n_values = ix_buffer(2*
ndim+1)
1834 call mpi_recv(w_buffer, n_values, mpi_double_precision,&
1839 {ixosmin^
d = ixomin^
d - 1\}
1840 {ixosmax^
d = ixomax^
d\}
1841 w(ixo^s, 1:
nw_found) = reshape(w_buffer(1:n_values_stagger), &
1843 ps(igrid)%ws(ixos^s,1:nws)=reshape(w_buffer(n_values_stagger+1:n_values), &
1844 shape(ws(ixos^s, 1:nws)))
1846 w(ixo^s, 1:
nw_found) = reshape(w_buffer(1:n_values), &
1859 ps(igrid)%w(ixo^s,1:nw)=w(ixo^s,1:nw)
1862 ps(igrid)%w(ixo^s,1:nw)=w(ixo^s,1:nw)
1875 double precision :: wio(ixg^t,1:nw)
1876 integer :: fh, igrid, Morton_no, iread
1877 integer :: levmaxini, ndimini, ndirini
1878 integer :: nwini, neqparini, nxini^D
1879 integer(kind=MPI_OFFSET_KIND) :: offset
1880 integer :: istatus(mpi_status_size)
1881 integer,
allocatable :: iorecvstatus(:,:)
1882 integer :: ipe,inrecv,nrecv
1883 integer :: sendini(7+^nd)
1884 character(len=80) :: filename
1886 double precision :: eqpar_dummy(100)
1890 mpi_mode_rdonly,mpi_info_null,fh,
ierrmpi)
1892 offset=-int(7*size_int+size_double,kind=mpi_offset_kind)
1893 call mpi_file_seek(fh,offset,mpi_seek_end,
ierrmpi)
1897 call mpi_file_read(fh,levmaxini,1,mpi_integer,istatus,
ierrmpi)
1898 call mpi_file_read(fh,ndimini,1,mpi_integer,istatus,
ierrmpi)
1899 call mpi_file_read(fh,ndirini,1,mpi_integer,istatus,
ierrmpi)
1900 call mpi_file_read(fh,nwini,1,mpi_integer,istatus,
ierrmpi)
1901 call mpi_file_read(fh,neqparini,1,mpi_integer,istatus,
ierrmpi)
1902 call mpi_file_read(fh,
it,1,mpi_integer,istatus,
ierrmpi)
1907 write(*,*)
"number of levels in restart file = ",levmaxini
1909 call mpistop(
"refine_max_level < number of levels in restart file")
1911 if (ndimini/=
ndim)
then 1912 write(*,*)
"ndim in restart file = ",ndimini
1913 write(*,*)
"ndim = ",
ndim 1914 call mpistop(
"reset ndim to ndim in restart file")
1916 if (ndirini/=
ndir)
then 1917 write(*,*)
"ndir in restart file = ",ndirini
1918 write(*,*)
"ndir = ",
ndir 1919 call mpistop(
"reset ndir to ndir in restart file")
1922 write(*,*)
"nw=",nw,
" and nw in restart file=",nwini
1923 call mpistop(
"currently, changing nw at restart is not allowed")
1926 offset=offset-int(ndimini*size_int+neqparini*size_double,kind=mpi_offset_kind)
1927 call mpi_file_seek(fh,offset,mpi_seek_end,
ierrmpi)
1929 {
call mpi_file_read(fh,nxini^d,1,mpi_integer,istatus,
ierrmpi)\}
1931 write(*,*)
"Error: reset resolution to ",nxini^d+2*
nghostcells 1932 call mpistop(
"change with setamrvac")
1935 call mpi_file_read(fh,eqpar_dummy,neqparini, &
1936 mpi_double_precision,istatus,
ierrmpi)
1942 sendini=(/
nleafs,levmaxini,ndimini,ndirini,nwini,neqparini,
it ,^d&nxini^d /)
1944 call mpi_bcast(sendini,7+^nd,mpi_integer,0,
icomm,
ierrmpi)
1945 nleafs=sendini(1);levmaxini=sendini(2);ndimini=sendini(3);
1946 ndirini=sendini(4);nwini=sendini(5);
1947 neqparini=sendini(6);
it=sendini(7);
1948 nxini^d=sendini(7+^d);
1955 int(
nleafs,kind=mpi_offset_kind)
1956 call mpi_file_seek(fh,offset,mpi_seek_set,
ierrmpi)
1973 *int(morton_no-1,kind=mpi_offset_kind)
1974 call mpi_file_read_at(fh,offset,ps(igrid)%w,1,
type_block_io, &
1983 *int(morton_no-1,kind=mpi_offset_kind)
1990 call mpi_file_close(fh,
ierrmpi)
1993 allocate(iorecvstatus(mpi_status_size,nrecv))
2000 iorecvstatus(:,inrecv),
ierrmpi)
2002 deallocate(iorecvstatus)
2017 integer :: i, iw, level
2018 double precision :: wmean(1:nw), total_volume
2020 integer :: nx^D, nc, ncells, dit
2021 double precision :: dtTimeLast, now, cellupdatesPerSecond
2022 double precision :: activeBlocksPerCore, wctPerCodeTime, timeToFinish
2023 character(len=40) :: fmt_string
2024 character(len=80) :: filename
2025 character(len=2048) :: line
2026 logical,
save :: opened = .false.
2027 integer :: amode, istatus(mpi_status_size)
2028 integer,
parameter :: my_unit = 20
2039 nx^d=ixmhi^d-ixmlo^d+1;
2049 cellupdatespersecond = dble(ncells) * dble(
nstep) * &
2050 dble(dit) / (dttimelast * dble(
npe))
2056 wctpercodetime = dttimelast / max(dit *
dt, epsilon(1.0d0))
2062 if (.not. opened)
then 2068 open(unit=my_unit,file=trim(filename),status=
'replace')
2069 close(my_unit, status=
'delete')
2072 amode = ior(mpi_mode_create,mpi_mode_wronly)
2073 amode = ior(amode,mpi_mode_append)
2075 call mpi_file_open(mpi_comm_self, filename, amode, &
2081 line =
"it global_time dt" 2083 i = len_trim(line) + 2
2084 write(line(i:),
"(a,a)") trim(cons_wnames(level)),
" " 2089 i = len_trim(line) + 2
2090 write(line(i:),
"(a,i0)")
"c", level
2095 i = len_trim(line) + 2
2096 write(line(i:),
"(a,i0)")
"n", level
2100 line = trim(line) //
" | Xload Xmemory 'Cell_Updates /second/core'" 2101 line = trim(line) //
" 'Active_Blocks/Core' 'Wct Per Code Time [s]'" 2102 line = trim(line) //
" 'TimeToFinish [hrs]'" 2106 call mpi_file_write(
log_fh, trim(line) // new_line(
'a'), &
2107 len_trim(line)+1, mpi_character, istatus,
ierrmpi)
2113 fmt_string =
'(' //
fmt_i //
',2' //
fmt_r //
')' 2115 i = len_trim(line) + 2
2117 write(fmt_string,
'(a,i0,a)')
'(', nw,
fmt_r //
')' 2118 write(line(i:), fmt_string) wmean(1:nw)
2119 i = len_trim(line) + 2
2123 i = len_trim(line) + 2
2127 i = len_trim(line) + 2
2129 fmt_string =
'(a,6' //
fmt_r2 //
')' 2130 write(line(i:), fmt_string)
'| ',
xload,
xmemory, cellupdatespersecond, &
2131 activeblockspercore, wctpercodetime, timetofinish
2133 call mpi_file_write(
log_fh, trim(line) // new_line(
'a') , &
2134 len_trim(line)+1, mpi_character, istatus,
ierrmpi)
2144 integer,
parameter :: n_modes = 2
2145 integer,
parameter :: my_unit = 123
2146 character(len=40) :: fmt_string
2147 logical,
save :: file_open = .false.
2149 double precision :: modes(nw, n_modes), volume
2151 do power = 1, n_modes
2156 if (.not. file_open)
then 2160 write(my_unit, *)
"# time mean(w) mean(w**2)" 2163 write(fmt_string,
"(a,i0,a)")
"(", nw * n_modes + 1,
fmt_r //
")" 2174 integer,
intent(in) :: power
2175 double precision,
intent(out) :: mode(nw)
2176 double precision,
intent(out) :: volume
2177 integer :: iigrid, igrid, iw
2178 double precision :: wsum(nw+1)
2179 double precision :: dsum_recv(1:nw+1)
2184 do iigrid = 1, igridstail
2185 igrid = igrids(iigrid)
2188 wsum(nw+1) = wsum(nw+1) + sum(ps(igrid)%dvolume(
ixm^t))
2192 wsum(iw) = wsum(iw) + &
2193 sum(ps(igrid)%dvolume(
ixm^t)*ps(igrid)%w(
ixm^t,iw)**power)
2198 call mpi_allreduce(wsum, dsum_recv, nw+1, mpi_double_precision, &
2202 volume = dsum_recv(nw+1)
2203 mode = dsum_recv(1:nw) / volume
2214 integer :: iigrid, igrid, iw, level
2219 do iigrid = 1, igridstail
2220 igrid = igrids(iigrid);
2222 vol_cov(level) = vol_cov(level)+ &
2227 call mpi_allreduce(vol_cov, dsum_recv,
refine_max_level, mpi_double_precision, &
2231 vol_cov = dsum_recv / sum(dsum_recv)
2239 pure function func(w_vec, w_size)
result(val)
2240 integer,
intent(in) :: w_size
2241 double precision,
intent(in) :: w_vec(w_size)
2242 double precision :: val
2245 double precision,
intent(out) :: f_avg
2246 double precision,
intent(out) :: volume
2247 integer :: iigrid, igrid, i^D
2248 double precision :: wsum(2)
2249 double precision :: dsum_recv(2)
2254 do iigrid = 1, igridstail
2255 igrid = igrids(iigrid)
2258 wsum(2) = wsum(2) + sum(ps(igrid)%dvolume(
ixm^t))
2261 {
do i^d = ixmlo^d, ixmhi^d\}
2262 wsum(1) = wsum(1) + ps(igrid)%dvolume(i^d) * &
2263 func(ps(igrid)%w(i^d, :), nw)
2268 call mpi_allreduce(wsum, dsum_recv, 2, mpi_double_precision, &
2272 volume = dsum_recv(2)
2273 f_avg = dsum_recv(1) / volume
2281 double precision,
intent(out) :: wmax(nw)
2283 integer :: iigrid, igrid, iw
2284 double precision :: wmax_mype(nw),wmax_recv(nw)
2286 wmax_mype(1:nw) = -bigdouble
2289 do iigrid = 1, igridstail
2290 igrid = igrids(iigrid)
2292 wmax_mype(iw)=max(wmax_mype(iw),maxval(ps(igrid)%w(
ixm^t,iw)))
2297 call mpi_allreduce(wmax_mype, wmax_recv, nw, mpi_double_precision, &
2300 wmax(1:nw)=wmax_recv(1:nw)
2308 double precision,
intent(out) :: wmin(nw)
2310 integer :: iigrid, igrid, iw
2311 double precision :: wmin_mype(nw),wmin_recv(nw)
2313 wmin_mype(1:nw) = bigdouble
2316 do iigrid = 1, igridstail
2317 igrid = igrids(iigrid)
2319 wmin_mype(iw)=min(wmin_mype(iw),minval(ps(igrid)%w(
ixm^t,iw)))
2324 call mpi_allreduce(wmin_mype, wmin_recv, nw, mpi_double_precision, &
2327 wmin(1:nw)=wmin_recv(1:nw)
integer, parameter cylindrical
This module contains definitions of global parameters and variables and some generic functions/subrou...
character(len=std_len) prolongation_method
integer, parameter cartesian_stretched
integer direction_los
direction of light of sight
character(len=std_len) time_integrator
Which time integrator to use.
double precision, dimension(:), allocatable refine_threshold
Error tolerance for refinement decision.
character(len=std_len), dimension(:), allocatable typepred1
The spatial dicretization for the predictor step when using a two step method.
logical, dimension(:), allocatable w_write
logical small_values_use_primitive
Use primitive variables when correcting small values.
integer domain_nx
number of cells for each dimension in level-one mesh
double precision time_max
End time for the simulation.
double precision, dimension(:), allocatable w_refine_weight
Weights of variables used to calculate error for mesh refinement.
character(len=std_len) typetvd
Which type of TVD method to use.
logical saveprim
If true, convert from conservative to primitive variables in output.
double precision, dimension(ndim) qstretch_baselevel
stretch factor between cells at AMR level 1, per dimension
integer max_blocks
The maximum number of grid blocks in a processor.
The data structure that contains information about a tree node/grid block.
type(tree_node_ptr), dimension(:,:), allocatable, save igrid_to_node
Array to go from an [igrid, ipe] index to a node pointer.
character(len=name_len) physics_type
String describing the physics type of the simulation.
logical slab_uniform
uniform Cartesian geometry or not (stretched Cartesian)
integer, parameter stretch_uni
Unidirectional stretching from a side.
logical, dimension(ndim) collapse
If collapse(DIM) is true, generate output integrated over DIM.
double precision, dimension(:,:), allocatable dxmid
integer, parameter filecollapse_
Constant indicating collapsed output.
integer, dimension(:), allocatable type_gradient_limiter
Type of slope limiter used for computing gradients or divergences, when typegrad or typediv are set t...
double precision xprob
minimum and maximum domain boundaries for each dimension
double precision, dimension(:), allocatable dg
extent of grid blocks in domain per dimension, in array over levels
double precision, dimension(ndim, 2) writespshift
double precision time_convert_factor
Conversion factor for time unit.
logical need_global_cmax
need global maximal wave speed
character(len=std_len) convert_type
Which format to use when converting.
Module with geometry-related routines (e.g., divergence, curl)
integer collapselevel
The level at which to produce line-integrated / collapsed output.
integer, parameter plevel_
subroutine, public kracken(verb, string)
integer ndir
Number of spatial dimensions (components) for vector variables.
character(len=std_len) collapse_type
Writes D-1 slice, can do so in various formats, depending on slice_type.
character(len=std_len) typedimsplit
integer nstep
How many sub-steps the time integrator takes.
integer, dimension(:), allocatable type_limiter
Type of slope limiter used for reconstructing variables on cell edges.
double precision, dimension(:), allocatable amr_wavefilter
refinement: lohner estimate wavefilter setting
logical resume_previous_run
If true, restart a previous run from the latest snapshot.
double precision, dimension(:), allocatable entropycoef
double precision wall_time_max
Ending wall time (in hours) for the simulation.
integer it_init
initial iteration count
integer it_max
Stop the simulation after this many time steps have been taken.
double precision dtmin
Stop the simulation when the time step becomes smaller than this value.
character(len=std_len) base_filename
Base file name for simulation output, which will be followed by a number.
integer direction_slit
direction of slit (for spectrum)
Module with basic grid data structures.
character(len= *), parameter undefined
integer itag
MPI recv send variables for AMR.
character(len=std_len) usr_filename
User parameter file.
integer, parameter nsavehi
Maximum number of saves that can be defined by tsave or itsave.
character(len=std_len) typeboundspeed
Which type of TVDLF method to use.
character(len=std_len) typeprolonglimit
Limiter used for prolongation to refined grids and ghost cells.
subroutine, public retrev(name, val, len, ier)
Collapses D-dimensional output to D-1 view by line-of-sight integration.
double precision timelast
integer npe
The number of MPI tasks.
logical, dimension(:), allocatable writelevel
double precision courantpar
The Courant (CFL) number used for the simulation.
integer, dimension(:,:), allocatable, save sfc
Array to go from a Morton number to an igrid and processor index. Sfc(1:3, MN) contains [igrid...
character(len=std_len), dimension(:), allocatable flux_scheme
Which spatial discretization to use (per grid level)
integer, parameter fileanalysis_
Constant indicating analysis output (see Writing a custom analysis subroutine)
integer, dimension(3, 3, 3) lvc
Levi-Civita tensor.
double precision small_density
logical, dimension(ndim) stretched_dim
True if a dimension is stretched.
logical, dimension(ndim) aperiodb
True for dimensions with aperiodic boundaries.
logical convert
If true and restart_from_file is given, convert snapshots to other file formats.
integer, public small_values_daverage
Average over this many cells in each direction.
integer, dimension(:), allocatable ng
number of grid blocks in domain per dimension, in array over levels
integer, dimension(ndim) stretch_type
What kind of stretching is used per dimension.
integer, dimension(nfile) isavet
Module with slope/flux limiters.
subroutine write_forest(file_handle)
logical pass_wall_time
If true, wall time is up, modify snapshotnext for later overwrite.
integer nghostcells
Number of ghost cells surrounding a grid.
integer nslices
Number of slices to output.
double precision dtdiffpar
For resistive MHD, the time step is also limited by the diffusion time: .
procedure(p_no_args), pointer usr_print_log
Module with all the methods that users can customize in AMRVAC.
integer, dimension(:), allocatable, save sfc_to_igrid
Go from a Morton number to an igrid index (for a single processor)
logical, dimension(:), allocatable loglimit
integer ixghi
Upper index of grid block arrays.
integer type_block_io
MPI type for IO: block excluding ghost cells.
integer function limiter_type(namelim)
character(len=std_len) typeghostfill
double precision xload
Stores the memory and load imbalance, used in printlog.
character(len=std_len) filename_euv
Base file name for synthetic EUV emission output.
integer ditregrid
Reconstruct the AMR grid once every ditregrid iteration(s)
character(len=std_len) geometry_name
double precision cada3_radius
radius of the asymptotic region [0.001, 10], larger means more accurate in smooth region but more ove...
logical angmomfix
Enable to strictly conserve the angular momentum (works both in cylindrical and spherical coordinates...
logical, dimension(:), allocatable small_values_fix_iw
Whether to apply small value fixes to certain variables.
double precision small_pressure
character(len=std_len) typesourcesplit
How to apply dimensional splitting to the source terms, see disretization.md.
integer, parameter fileslice_
Constant indicating slice output.
logical stagger_grid
True for using stagger grid.
logical save_physical_boundary
True for save physical boundary cells in dat files.
integer, parameter cartesian
character(len=std_len) resolution_euv
resolution of the output
logical nocartesian
IO switches for conversion.
integer ierrmpi
A global MPI error return code.
integer ixm
the mesh range (within a block with ghost cells)
integer snapshotnext
IO: snapshot and collapsed views output numbers/labels.
character(len=std_len), dimension(:, :), allocatable typeboundary
Array indicating the type of boundary condition per variable and per physical boundary.
logical solve_internal_e
Solve polytropic process instead of solving total energy.
character(len=std_len), dimension(:), allocatable typeentropy
Which type of entropy fix to use with Riemann-type solvers.
double precision dtpar
If dtpar is positive, it sets the timestep dt, otherwise courantpar is used to limit the time step ba...
character(len=std_len) restart_from_file
If not 'unavailable', resume from snapshot with this base file name.
logical image
output image
double precision, dimension(:), allocatable w_convert_factor
Conversion factors the primitive variables.
character(len=std_len) typefilelog
Which type of log to write: 'normal', 'special', 'regression_test'.
integer, dimension(:), allocatable, save morton_start
First Morton number per processor.
procedure(p_no_args), pointer usr_write_analysis
subroutine alloc_node(igrid)
allocate arrays on igrid node
integer, parameter unitterm
Unit for standard output.
integer, parameter filelog_
Constant indicating log output.
integer, parameter unitpar
integer nbufferx
Number of cells as buffer zone.
integer, dimension(3, 3) kr
Kronecker delta tensor.
double precision, dimension(:,:), allocatable dx
character(len=std_len) typegrad
logical check_small_values
check and optionally fix unphysical small values (density, gas pressure)
double precision time_between_print
to monitor timeintegration loop at given wall-clock time intervals
integer, dimension(:), allocatable, parameter d
integer, dimension(:), allocatable, save morton_stop
Last Morton number per processor.
logical reset_it
If true, reset iteration count to 0.
subroutine write_collapsed
character(len=40), dimension(nfile), parameter output_names
Names of the output methods.
integer mype
The rank of the current MPI task.
subroutine read_forest(file_handle)
double precision global_time
The global simulation time.
integer, dimension(:,:), allocatable nstretchedblocks
(even) number of (symmetrically) stretched blocks per level and dimension
integer block_nx
number of cells for each dimension in grid block excluding ghostcells
integer, parameter stretch_symm
Symmetric stretching around the center.
logical reset_time
If true, reset iteration count and global_time to original values, and start writing snapshots at ind...
integer, parameter unitsnapshot
logical function, public lget(keyword)
character(len=std_len), dimension(:), allocatable par_files
Which par files are used as input.
double precision, dimension(nfile) dtsave
Repeatedly save output of type N when dtsave(N) simulation time has passed.
character(len=std_len) slice_type
choose data type of slice: vtu, vtuCC, dat, or csv
Module for handling problematic values in simulations, such as negative pressures.
logical use_particles
Use particles module or not.
integer, dimension(:), allocatable, save nleafs_level
How many leaves are present per refinement level.
double precision, dimension(nfile) tsavestart
Start of read out (not counting specified read outs)
double precision, dimension(:,:), allocatable qstretch
Stretching factors and first cell size for each AMR level and dimension.
integer, parameter uniterr
Unit for error messages.
Module containing all the particle routines.
subroutine mpistop(message)
Exit MPI-AMRVAC with an error message.
double precision, dimension(:,:), allocatable dxfirst_1mq
logical firstprocess
If true, call initonegrid_usr upon restarting.
double precision tfixgrid
Fix the AMR grid after this time.
double precision length_convert_factor
integer iprob
problem switch allowing different setups in same usr_mod.t
double precision, dimension(ndim) dxlevel
double precision, dimension(nsavehi, nfile) tsave
Save output of type N on times tsave(:, N)
integer, dimension(nfile) isaveit
integer snapshotini
Resume from the snapshot with this index.
integer, parameter rpxmax
integer function, public iget(keyword)
integer, dimension(nslicemax) slicedir
The slice direction for each slice.
integer, parameter ndim
Number of spatial dimensions for grid variables.
integer phys_wider_stencil
To use wider stencils in flux calculations. A value of 1 will extend it by one cell in both direction...
logical stretch_uncentered
If true, adjust mod_geometry routines to account for grid stretching (but the flux computation will n...
subroutine generate_plotfile
logical slab
Cartesian geometry or not.
double precision, dimension(nslicemax) slicecoord
Slice coordinates, see Slice output.
integer slowsteps
If > 1, then in the first slowsteps-1 time steps dt is reduced by a factor .
integer, parameter stretch_none
No stretching.
procedure(transform_w), pointer usr_transform_w
integer nwauxio
Number of auxiliary variables that are only included in output.
logical, dimension(:), allocatable logflag
integer icomm
The MPI communicator.
double precision small_temperature
error handling
character(len=std_len) typediv
integer, parameter nlevelshi
The maximum number of levels in the grid refinement.
integer, save nparents
Number of parent blocks.
integer refine_max_level
Maximal number of AMR levels.
This module defines the procedures of a physics module. It contains function pointers for the various...
logical, dimension(ndim) periodb
True for dimensions with periodic boundaries.
integer, parameter nfile
Number of output methods.
integer log_fh
MPI file handle for logfile.
double precision location_slit
location of the slit
logical reset_grid
If true, rebuild the AMR grid upon restarting.
logical source_split_usr
Use split or unsplit way to add user's source terms, default: unsplit.
integer, dimension(:,:), allocatable node
procedure(sub_get_aux), pointer phys_get_aux
integer, parameter spherical
integer itfixgrid
Fix the AMR grid after this many time steps.
character(len=std_len) typecourant
How to compute the CFL-limited time step.
double precision, dimension(:,:), allocatable dxfirst
integer, save nleafs
Number of leaf block.
logical phys_energy
Solve energy equation or not.
integer it
Number of time steps taken.
integer, dimension(nfile) ditsave
Repeatedly save output of type N when ditsave(N) time steps have passed.
character(len=20), public small_values_method
How to handle small values.
double precision, dimension(:,:), allocatable rnode
Corner coordinates.
double precision, dimension(:), allocatable derefine_ratio
integer, dimension(ndim) nstretchedblocks_baselevel
(even) number of (symmetrically) stretched blocks at AMR level 1, per dimension
double precision time_init
Start time for the simulation.
character(len=std_len) typeaverage
integer ixgshi
Upper index of stagger grid block arrays.
Module for reading command line arguments.
integer, parameter fileout_
Constant indicating regular output.
integer, dimension(nsavehi, nfile) itsave
Save output of type N on iterations itsave(:, N)
double precision tvdlfeps
integer slicenext
the file number of slices
logical spectrum
output spectrum
logical autoconvert
If true, already convert to output format during the run.
character(len=std_len) typecurl
procedure(sub_write_info), pointer phys_write_info
integer, parameter rpxmin