[FLASH-USERS] 3DMHD +usm, jumps of divb at refinement jumps
Martin Huarte-Espinosa
mh475 at cam.ac.uk
Wed Mar 11 07:43:13 EDT 2009
Good day Flash users.
I've fixed the mhd problem. The solution:
At Simulation_initBlock I read the magnetic vector potential and both, the
vector and the code's grid, should have resolution. This must be flash's
coarse gird for nblockx = 1, nblocky = 1, nblockz = 1 and
lrefine_max=lrefine_min=4, say. Then, I run the code for a few timesteps,
stop it and restart from the produce chk file, allowing lrefine_max>4 ONLY.
This maintains a dvib within ~ +- 1.5e-11.
Cheers.
Best,
Martin HE.
On Fri, Feb 20, 2009 at 4:26 PM, Anshu Dubey <dubey at flash.uchicago.edu>wrote:
> Non fixed blocksize UG mode by default uses parallel IO. The output is
> written as a
> single large block, and that is the only way to restart on a different
> number of
> processors, and that mode has to be necessarily parallel. You can
> either use parallel
> hdf5, or switch to using fixed blocksize UG, which does have serial IO
> support.
> In principle there is nothing that prevents serial IO from being used
> with nonfixedblocksize
> mode, but some Config files may need tweaking to enable that. We will
> look into it
> and get back to you.
>
> You have to keep in mind that if you use serial IO, then for all
> practical purposes
> your mode reduces to fixed blocksize mode if you wish to restart. You
> can restart
> on exactly the same number of processors, and in exactly the same
> configuration
> of those processors, as the original from_scratch run.
>
> Anshu
>
> On Fri, Feb 20, 2009 at 9:59 AM, Martin Huarte-Espinosa <mh475 at cam.ac.uk>
> wrote:
> > Hi Chris and thanks for your answer. I've tried the following,
> > unsuccessfully:
> >
> > ./setup /Sysims/mhd_ug_nofbs -3d +usm -auto -opt +nofbs +serialIO
> > -objdir=mhd_ug_nofbs -site=apgrid && cd mhd_ug_nofbs/ && make
> >
> > Best,
> >
> > Martin HE.
> >
> >
> > On Fri, Feb 20, 2009 at 3:41 PM, Chris Daley <cdaley at flash.uchicago.edu>
> > wrote:
> >>
> >> This is only a response to your first problem. I think FLASH is
> >> failing to link because your HDF5 build does not have parallel IO
> >> support. If you would like to use parallel IO, re-build HDF5 with the
> >> additional configure options "--enable-parallel CC=mpicc". If not,
> >> then simply add the shortcut +serialIO during FLASH setup for serial IO.
> >>
> >> Regards,
> >> Chris
> >>
> >> Martin Huarte-Espinosa wrote:
> >>>
> >>> Good day Flash community:
> >>>
> >>> Two questions. I'll be really thankful if you had any hints about them.
> >>>
> >>> 1) I'm trying to complie flash3.1 for a uniform grid with no fixed
> block
> >>> size:
> >>>
> >>> ./setup mhd_ug_nofbs -3d +usm -auto -opt +nofbs -site=apgrid
> >>>
> >>> and I get:
> >>>
> >>> /-L/mraosw/data1/mh475/krause/lib/hdf/5-1.6.5-amd-icc/lib -lhdf5 -lz
> >>> -lhdf5_fortran -L/mraosw/data1/mh475/krause/lib/mpich-1.2.6/lib -lmpich
> >>>
> /home/krause/dataw/lib/mpich-1.2.4/lib/libmpich.a(p4_secure.o)(.text+0x91):
> >>> In function `start_slave':
> >>> : warning: Using 'getpwuid' in statically linked applications requires
> at
> >>> runtime the shared libraries from the glibc version used for linking
> >>>
> >>>
> /mraosw/data1/mh475/krause/lib/hdf/5-1.6.5-amd-icc/lib/libhdf5.a(H5FDstream.o)(.text+0x723):
> >>> In function `H5FD_stream_open_socket':
> >>> : warning: Using 'gethostbyname' in statically linked applications
> >>> requires at runtime the shared libraries from the glibc version used
> for
> >>> linking
> >>> io_h5file_interface.o(.text+0x6d): In function `io_h5init_file_':
> >>> : undefined reference to `H5Pset_fapl_mpio'
> >>> io_h5file_interface.o(.text+0x12f): In function
> >>> `io_h5open_file_for_read_':
> >>> : undefined reference to `H5Pset_fapl_mpio'
> >>> make: *** [flash3] Error 1/
> >>>
> >>> I've tried, unsuccessfully, to edit some parts of the cluster's
> >>> Makefile.h.
> >>>
> >>>
> >>> 2) I'm implementing a gas with a random magnetic distribution. I
> generate
> >>> the magnetic fields outside flash, making sure their divb~1.e-14. I
> then
> >>> read these fields into Flash3.1 and they work well for a uniform grid
> or
> >>> with the AMR with lrefine_max=lrefine_min. However, if I give
> lrefine_max
> >>> different from lrefine_min, divb appears to be fine at time=0, but
> after the
> >>> first timestep it gets jumps up to ~ 0.1 at cells adjacent to
> refinement
> >>> jumps only. I'm attaching important bits of info below.
> >>>
> >>> Thanks a lot.
> >>>
> >>> ./setup MySims/mhd_01 -3d +usm -auto -opt -maxblocks=400 -site=darwin
> >>>
> >>> ------------------------
> >>> /subroutine Simulation_initBlock(blockID, myPE, F) ! following the
> setup
> >>> from the Fields loop test problem/
> >>>
> >>> / use Simulation_data, ONLY : sim_gCell, sim_gamma, &/
> >>> / sim_smallX, sim_smallP, &/
> >>> / sim_beta, sim_B_cluster, &/
> >>> / sim_killdivb, sim_rc, &/
> >>> /sim_xMin, sim_xMax, sim_yMin, &/
> >>> /sim_yMax, sim_zMin, sim_zMax, &/
> >>> /sim_n_cube/
> >>>
> >>> /! use Grid_data, ONLY : gr_nBlockX, gr_nBlockY, gr_nBlockZ/
> >>>
> >>> /! use tree, ONLY : lrefine_max, lrefine_min/
> >>>
> >>> / use Grid_interface, ONLY : Grid_getBlkIndexLimits, &/
> >>> / Grid_getCellCoords, &/
> >>> / Grid_getBlkPtr, &/
> >>> / Grid_releaseBlkPtr/
> >>>
> >>> / use Driver_interface, ONLY : Driver_abortFlash/
> >>> / /
> >>> / implicit none/
> >>>
> >>> /#include "constants.h"/
> >>> /#include "Flash.h"/
> >>>
> >>> / !!$ Arguments -----------------------/
> >>> / integer, intent(in) :: blockID, myPE/
> >>> / !!$ ---------------------------------/
> >>>
> >>> / integer :: i, j, k, n, istat, sizeX, sizeY, sizeZ/
> >>> / integer, dimension(2,MDIM) :: blkLimits, blkLimitsGC/
> >>> / real :: enerZone, ekinZone, eintZone/
> >>> / real :: rot, radius, dx, dy, dz, r0, taper, vel_factor/
> >>> / real, allocatable,dimension(:) :: xCoord,xCoordL,xCoordR,&/
> >>> / yCoord,yCoordL,yCoordR,&/
> >>> / zCoord,zCoordL,zCoordR/
> >>> / real, dimension(MDIM) :: del/
> >>> / real, pointer, dimension(:,:,:,:) :: solnData, facexData, faceyData,
> >>> facezData/
> >>> / real :: xx,yy,zz/
> >>> /#ifdef FIXEDBLOCKSIZE/
> >>> / real, dimension(GRID_IHI_GC+1,GRID_JHI_GC+1,GRID_KHI_GC+1) ::
> >>> Az,Ax,Ay/
> >>> / //#else /
> >>> / real, allocatable, dimension(:,:,:) :: Az,Ax,Ay/
> >>> / //#endif /
> >>>
> >>> /logical, save :: once=.true., once2=.true., VecPotA=.true./
> >>> / integer :: ii, jj, kk/
> >>> / real :: B0, x_slope, y_slope, z_slope, &/
> >>> / idl_x_ini, idl_x_end, &/
> >>> / idl_y_ini, idl_y_end, &/
> >>> / idl_z_ini, idl_z_end, &/
> >>> /largestCell, minimumX, maximumX, &/
> >>> / minimumY, maximumY ,&/
> >>> / minimumZ, maximumZ, &/
> >>> / stdev_b, max_b, mean_pres, mean_b, norm_b
> >>>
> >>> // real, dimension(3,sim_n_cube,sim_n_cube,sim_n_cube),
> intent(in)
> >>> :: F
> >>> !contains the previously-generated magnetic fields
> >>> //!!/
> >>>
> >>>
> >>> / ! dump some output to stdout listing the paramters/
> >>> / if (myPE == MASTER_PE) then/
> >>> /1 format (1X, 1P, 4(A7, E13.7, :, 1X))/
> >>> /2 format (1X, 1P, 2(A7, E13.7, 1X), A7, I13)/
> >>> / endif/
> >>>
> >>> / call Grid_getBlkIndexLimits(blockId,blkLimits,blkLimitsGC)/
> >>>
> >>> / sizeX = blkLimitsGC(HIGH,IAXIS)-blkLimitsGC(LOW,IAXIS)+1/
> >>> / sizeY = blkLimitsGC(HIGH,JAXIS)-blkLimitsGC(LOW,JAXIS)+1/
> >>> / sizeZ = blkLimitsGC(HIGH,KAXIS)-blkLimitsGC(LOW,KAXIS)+1/
> >>>
> >>> / allocate(xCoord(sizeX), stat=istat)/
> >>> / allocate(xCoordL(sizeX),stat=istat)/
> >>> / allocate(xCoordR(sizeX),stat=istat)/
> >>>
> >>> / allocate(yCoord(sizeY), stat=istat)/
> >>> / allocate(yCoordL(sizeY),stat=istat)/
> >>> / allocate(yCoordR(sizeY),stat=istat)/
> >>>
> >>> / allocate(zCoord(sizeZ), stat=istat)/
> >>> / allocate(zCoordL(sizeZ),stat=istat)/
> >>> / allocate(zCoordR(sizeZ),stat=istat)/
> >>>
> >>> / xCoord = 0.0/
> >>> / xCoordL = 0.0/
> >>> / xCoordR = 0.0/
> >>>
> >>> / yCoord = 0.0/
> >>> / yCoordL = 0.0/
> >>> / yCoordR = 0.0/
> >>>
> >>> / zCoord = 0.0/
> >>> / zCoordL = 0.0/
> >>> / zCoordR = 0.0/
> >>>
> >>> /#ifndef FIXEDBLOCKSIZE/
> >>> / if (NDIM == 2) then/
> >>> / allocate(Ax(sizeX+1,sizeY+1,1),stat=istat)/
> >>> / allocate(Ay(sizeX+1,sizeY+1,1),stat=istat)/
> >>> / allocate(Az(sizeX+1,sizeY+1,1),stat=istat)/
> >>> / // elseif (NDIM == 3) then/
> >>> / allocate(Ax(sizeX+1,sizeY+1,sizeZ+1),stat=istat)/
> >>> / allocate(Ay(sizeX+1,sizeY+1,sizeZ+1),stat=istat)/
> >>> / allocate(Az(sizeX+1,sizeY+1,sizeZ+1),stat=istat)/
> >>> / // endif/
> >>> /#endif/
> >>>
> >>>
> >>> / if (NDIM == 3) then/
> >>> / call Grid_getCellCoords(KAXIS,blockId,CENTER, sim_gCell,zCoord,
> >>> sizeZ)/
> >>> / call Grid_getCellCoords(KAXIS,blockId,LEFT_EDGE,
> >>> sim_gCell,zCoordL,sizeZ)/
> >>> / call
> >>> Grid_getCellCoords(KAXIS,blockId,RIGHT_EDGE,sim_gCell,zCoordR,sizeZ)/
> >>> / endif/
> >>> / if (NDIM >= 2) then/
> >>> / call Grid_getCellCoords(JAXIS,blockId,CENTER,
> sim_gCell,yCoord,
> >>> sizeY)/
> >>> / call Grid_getCellCoords(JAXIS,blockId,LEFT_EDGE,
> >>> sim_gCell,yCoordL,sizeY)/
> >>> / call
> >>> Grid_getCellCoords(JAXIS,blockId,RIGHT_EDGE,sim_gCell,yCoordR,sizeY)/
> >>> / endif/
> >>>
> >>> / call Grid_getCellCoords(IAXIS,blockId,CENTER, sim_gCell,xCoord,
> >>> sizeX)/
> >>> / call Grid_getCellCoords(IAXIS,blockId,LEFT_EDGE,
> >>> sim_gCell,xCoordL,sizeX)/
> >>> / call
> >>> Grid_getCellCoords(IAXIS,blockId,RIGHT_EDGE,sim_gCell,xCoordR,sizeX)/
> >>>
> >>> / call Grid_getDeltas(blockID,del)/
> >>> / dx = del(1)/
> >>> / dy = del(2)/
> >>> / dz = del(3)/
> >>>
> >>> /
> >>>
> !------------------------------------------------------------------------------/
> >>> / ! Construct Az at each cell corner/
> >>> / ! Bx = dAz/dy - dAy/dz/
> >>> / ! By = dAx/dz - dAz/dx/
> >>> / ! Bz = dAy/dx - dAx/dy/
> >>> / Az = 0./
> >>> / Ax = 0./
> >>> / Ay = 0.
> >>>
> >>> x_ini = 1.
> >>> y_ini = 1. z_ini = 1.
> >>> x_end = real(sim_n_cube)
> >>> y_end = real(sim_n_cube)
> >>> z_end = real(sim_n_cube)
> >>> minimumX = sim_xMin - 4.d0*dx
> >>> minimumY = sim_yMin - 4.d0*dy
> >>> minimumZ = sim_zMin - 4.d0*dz
> >>> maximumX = sim_xMax + 4.d0*dx
> >>> maximumY = sim_yMax + 4.d0*dy
> >>> maximumZ = sim_zMax + 4.d0*dz /
> >>> / /
> >>> / x_slope = (x_end-x_ini)/(maximumX-minimumX)/
> >>> / y_slope = (y_end-y_ini)/(maximumY-minimumY) /
> >>> / z_slope = (z_end-z_ini)/(maximumZ-minimumZ) /
> >>> / /
> >>> / do k = blkLimitsGC(LOW,KAXIS),blkLimitsGC(HIGH,KAXIS)+1/
> >>> / do j = blkLimitsGC(LOW,JAXIS),blkLimitsGC(HIGH,JAXIS)+1/
> >>> / do i = blkLimitsGC(LOW,IAXIS),blkLimitsGC(HIGH,IAXIS)+1/
> >>>
> >>>
> >>> / ! x Coord at cell corner/
> >>> / if (i <=blkLimitsGC(HIGH,IAXIS)) then/
> >>> / xx = xCoordL(i)/
> >>> / else/
> >>> / xx = xCoordR(i-1)/
> >>> / endif/
> >>>
> >>> / ! y Coord at cell corner/
> >>> / if (j <=blkLimitsGC(HIGH,JAXIS)) then/
> >>> / yy = yCoordL(j)/
> >>> / else/
> >>> / yy = yCoordR(j-1)/
> >>> / endif/
> >>>
> >>> / ! z Coord at cell corner/
> >>> / if (k <=blkLimitsGC(HIGH,KAXIS)) then/
> >>> / zz = zCoordL(k)/
> >>> / else/
> >>> / zz = zCoordR(k-1)/
> >>> / endif/
> >>>
> >>>
> >>> / ii = nint( x_slope*(xx-minimumX)+idl_x_ini ) /
> >>> / jj = nint( y_slope*(yy-minimumY)+idl_y_ini )/
> >>> / kk = nint( z_slope*(zz-minimumZ)+idl_z_ini )/
> >>>
> >>> /!--------------------------------------------------------------/
> >>> /if ( (ii.lt.idl_x_ini).or.(ii.gt.idl_x_end).or.&/
> >>> / (jj.lt.idl_y_ini).or.(jj.gt.idl_y_end).or.& /
> >>> / (kk.lt.idl_z_ini).or.(kk.gt.idl_z_end) ) &/
> >>> /call Driver_abortFlash("*** init_block, IDL-Flash coords. error
> ***")/
> >>>
> >>> /!!--------------------------------------------------------------/
> >>>
> >>> !Read the outise-fields into flash
> >>> / Ax(i,j,k) = F(1,ii,jj,kk)/
> >>> / Ay(i,j,k) = F(2,ii,jj,kk)/
> >>> / Az(i,j,k) = F(3,ii,jj,kk)/
> >>> / /
> >>> / enddo/
> >>> / enddo/
> >>> / enddo/
> >>>
> >>>
> >>> /!Initial conditions:/
> >>>
> >>> / call Grid_getBlkPtr(blockID,solnData,CENTER)/
> >>>
> >>> /#if NFACE_VARS > 0/
> >>> / if (sim_killdivb) then/
> >>> / call Grid_getBlkPtr(blockID,facexData,FACEX)/
> >>> / call Grid_getBlkPtr(blockID,faceyData,FACEY)/
> >>> / if (NDIM == 3) call Grid_getBlkPtr(blockID,facezData,FACEZ)/
> >>> / endif/
> >>> /#endif/
> >>>
> >>>
> >>> / ! Loop over cells within the block./
> >>> / do k = blkLimitsGC(LOW,KAXIS),blkLimitsGC(HIGH,KAXIS)/
> >>> / do j = blkLimitsGC(LOW,JAXIS),blkLimitsGC(HIGH,JAXIS)/
> >>> / do i = blkLimitsGC(LOW,IAXIS),blkLimitsGC(HIGH,IAXIS)/
> >>>
> >>> /
> solnData(SPECIES_BEGIN,i,j,k)=1.0e0-(NSPECIES-1)*sim_smallX/
> >>> / do n=SPECIES_BEGIN,SPECIES_END/
> >>> / solnData(n,i,j,k)=sim_smallX/
> >>> / enddo/
> >>> / /
> >>>
> >>> / solnData(DENS_VAR,i,j,k)= 1./
> >>> / solnData(PRES_VAR,i,j,k)=
> solnData(DENS_VAR,i,j,k)/sim_gamma
> >>> /
> >>>
> >>>
> >>> / solnData(VELX_VAR,i,j,k)= 0.d0/
> >>> / solnData(VELY_VAR,i,j,k)= 0.d0/
> >>> / solnData(VELZ_VAR,i,j,k)= 0.d0/
> >>>
> >>> / /
> >>> / /
> >>>
> >>> / ! Compute the gas energy and set the gamma-values needed
> for
> >>> the EOS/
> >>> / ekinZone = 0.5 *
> >>> dot_product(solnData(VELX_VAR:VELZ_VAR,i,j,k),&/
> >>> /
> >>> solnData(VELX_VAR:VELZ_VAR,i,j,k))/
> >>>
> >>> / ! specific internal energy/
> >>> / eintZone =
> >>> solnData(PRES_VAR,i,j,k)/(sim_gamma-1.)/solnData(DENS_VAR,i,j,k)/
> >>>
> >>> / ! total specific gas energy/
> >>> / enerZone = eintZone + ekinZone/
> >>>
> >>> / ! Take a limit value/
> >>> / enerZone = max(enerZone, sim_smallP)/
> >>>
> >>> / solnData(ENER_VAR,i,j,k)=enerZone/
> >>> / solnData(EINT_VAR,i,j,k)=eintZone/
> >>> / solnData(GAMC_VAR,i,j,k)=sim_gamma/
> >>> / solnData(GAME_VAR,i,j,k)=sim_gamma/
> >>>
> >>>
> >>>
> >>> / enddo/
> >>> / enddo/
> >>> / enddo/
> >>>
> >>>
> >>> /!! CURL:/
> >>> / do k = blkLimitsGC(LOW,KAXIS),blkLimitsGC(HIGH,KAXIS)+1/
> >>> / do j = blkLimitsGC(LOW,JAXIS),blkLimitsGC(HIGH,JAXIS)+1/
> >>> / do i = blkLimitsGC(LOW,IAXIS),blkLimitsGC(HIGH,IAXIS)+1/
> >>>
> >>>
> >>> / if ( (j <=blkLimitsGC(HIGH,JAXIS)).and.&/
> >>> / (k <=blkLimitsGC(HIGH,KAXIS)) ) then/
> >>> / facexData(MAG_FACE_VAR,i,j,k)= -(Ay(i ,j
> >>> ,k+1)-Ay(i,j,k))/dz &/
> >>> /+(Az(i ,j+1,k )-Az(i,j,k))/dy/
> >>> / end if/
> >>>
> >>> / if ( (i <=blkLimitsGC(HIGH,IAXIS)).and.&/
> >>> / (k <=blkLimitsGC(HIGH,KAXIS)) ) then/
> >>> / faceyData(MAG_FACE_VAR,i,j,k)= (Ax(i ,j
> >>> ,k+1)-Ax(i,j,k))/dz &/
> >>> /-(Az(i+1,j ,k )-Az(i,j,k))/dx/
> >>> / end if/
> >>>
> >>> / if ( (j <=blkLimitsGC(HIGH,JAXIS)).and.&/
> >>> / (i <=blkLimitsGC(HIGH,IAXIS)) ) then/
> >>> / facezData(MAG_FACE_VAR,i,j,k)= -(Ax(i ,j+1,k
> >>> )-Ax(i,j,k))/dy &/
> >>> /+(Ay(i+1,j ,k )-Ay(i,j,k))/dx/
> >>> / end if/
> >>> /!N end/
> >>>
> >>> / enddo/
> >>> / enddo/
> >>> / enddo/
> >>>
> >>> / /!!B, DIVB AND MAGP:
> >>> / do k=blkLimitsGC(LOW,KAXIS),blkLimitsGC(HIGH,KAXIS)/
> >>> / do j = blkLimitsGC(LOW,JAXIS),blkLimitsGC(HIGH,JAXIS)/
> >>> / do i = blkLimitsGC(LOW,IAXIS),blkLimitsGC(HIGH,IAXIS)
> >>>
> >>> /
> >>> / solnData(MAGX_VAR,i,j,k) =
> >>> 0.5*(facexData(MAG_FACE_VAR,i,j,k)+facexData(MAG_FACE_VAR,i+1,j,k))/
> >>> / solnData(MAGY_VAR,i,j,k) =
> >>> 0.5*(faceyData(MAG_FACE_VAR,i,j,k)+faceyData(MAG_FACE_VAR,i,j+1,k))/
> >>> / if (NDIM == 3) then/
> >>> / solnData(MAGZ_VAR,i,j,k) =
> >>> 0.5*(facezData(MAG_FACE_VAR,i,j,k)+facezData(MAG_FACE_VAR,i,j,k+1))/
> >>> / endif/
> >>>
> >>>
> >>> / /
> >>> / solnData(DIVB_VAR,i,j,k)= &/
> >>> / (facexData(MAG_FACE_VAR,i+1,j, k ) -
> >>> facexData(MAG_FACE_VAR,i,j,k))/dx &/
> >>> / + (faceyData(MAG_FACE_VAR,i, j+1,k ) -
> >>> faceyData(MAG_FACE_VAR,i,j,k))/dy/
> >>>
> >>> / solnData(DIVB_VAR,i,j,k)= solnData(DIVB_VAR,i,j,k) &/
> >>> / + (facezData(MAG_FACE_VAR,i, j, k+1) -
> >>> facezData(MAG_FACE_VAR,i,j,k))/dz/
> >>>
> >>>
> >>> / solnData(MAGP_VAR,i,j,k) =
> >>> .5*dot_product(solnData(MAGX_VAR:MAGZ_VAR,i,j,k),&/
> >>> /
> >>> solnData(MAGX_VAR:MAGZ_VAR,i,j,k))/
> >>>
> >>>
> >>> / enddo/
> >>> / enddo/
> >>> / enddo/
> >>>
> >>>
> >>>
> >>> / ! Release pointer/
> >>> / call Grid_releaseBlkPtr(blockID,solnData,CENTER)/
> >>>
> >>> /#if NFACE_VARS > 0/
> >>> / if (sim_killdivb) then/
> >>> / call Grid_releaseBlkPtr(blockID,facexData,FACEX)/
> >>> / call Grid_releaseBlkPtr(blockID,faceyData,FACEY)/
> >>> / if (NDIM == 3) call Grid_releaseBlkPtr(blockID,facezData,FACEZ)/
> >>> / endif/
> >>> /#endif/
> >>>
> >>> /deallocate(xCoord)/
> >>> /deallocate(xCoordL)/
> >>> /deallocate(xCoordR)/
> >>> /!/
> >>> /deallocate(yCoord)/
> >>> /deallocate(yCoordL)/
> >>> /deallocate(yCoordR)/
> >>>
> >>> /deallocate(zCoord)/
> >>> /deallocate(zCoordL)/
> >>> /deallocate(zCoordR)/
> >>>
> >>> /#ifndef FIXEDBLOCKSIZE/
> >>> / deallocate(Az)/
> >>> / deallocate(Ax)/
> >>> / deallocate(Ay)/
> >>> /#endif/
> >>>
> >>> /end subroutine Simulation_initBlock/
> >>>
> >>> ---------------------------------
> >>> flash.par:
> >>>
> >>>
> >>> sim_n_cube = 73 #= 64+8guard+1curl
> >>> nblockx = 1
> >>> nblocky = 1
> >>> nblockz = 1
> >>> lrefine_max = 5
> >>> lrefine_min = 3
> >>> refine_var_1 = "velx"
> >>> nrefs = 2
> >>>
> >>> run_comment = "14Feb09-1"
> >>> log_file = "14Feb09-1.log"
> >>> basenm = "14Feb09-1-"
> >>> restart = .false.
> >>> nend = 10
> >>> checkPointFileNumber = 1
> >>> tmax = 4.0
> >>> checkpointFileIntervalTime = 1.0
> >>> plotFileIntervalTime = 8.e-4 #2.5e-2
> >>> dtmax = 0.02 #0.01
> >>> plotFileNumber = 0
> >>>
> >>> sim_beta = 100.0 #Magnetic beta
> >>>
> >>> gamma = 1.666666666667
> >>>
> >>> geometry = "cartesian"
> >>>
> >>> xmin = -0.5
> >>> xmax = 0.5
> >>> ymin = -0.5
> >>> ymax = 0.5
> >>> zmin = -0.5
> >>> zmax = 0.5
> >>> xl_boundary_type = "outflow"
> >>> xr_boundary_type = "outflow"
> >>> yl_boundary_type = "outflow"
> >>> yr_boundary_type = "outflow"
> >>> zl_boundary_type = "outflow"
> >>> zr_boundary_type = "outflow"
> >>>
> >>> # Simulation (grid, time, I/O) parameters
> >>>
> >>> cfl = 0.3
> >>> dtini = 1.e-12
> >>> plot_var_1 = "dens"
> >>> plot_var_2 = "velx"
> >>> plot_var_3 = "vely"
> >>> plot_var_4 = "velz"
> >>> plot_var_5 = "pres"
> >>> plot_var_6 = "magx"
> >>> plot_var_7 = "magy"
> >>> plot_var_8 = "magz"
> >>> plot_var_9 = "divb"
> >>> plot_var_10 = "magp"
> >>>
> >>> convertToConsvdInMeshInterp = .true.
> >>>
> >>> eintSwitch = 1.e-6
> >>>
> >>> #MHD:
> >>> ForceHydroLimit = .false. #(set .true. when using hydro limit B=0)
> >>> sim_B_cluster = 1.0
> >>> UnitSystem = "none"
> >>> resistive_mhd = .false.
> >>> killdivb = .true.
> >>>
> >>> flux_correct = .true.
> >>>
> >>> order = 2 #(first / second order scheme)
> >>> slopeLimiter = "vanLeer" #(minmod, mc, vanLeer, hybrid, limited)
> >>> LimitedSlopeBeta= 1. # only needed for the limited slope by Toro
> >>> charLimiting = .true. #(.false. will give primitive limitings)
> >>> E_modification = .true. #(.false. will use simple arithmetic avg)
> >>> energyFix = .true. #(.false. will not fix total energy due to
> >>> div-free magnetic pressure)
> >>> facevar2ndOrder = .true. #(.false. will give less accurate
> >>> solution but fast performance)
> >>>
> >>> RiemannSolver = "hll"
> >>> # CTU integrator
> >>> CTU = .false. #(6-solve CTU scheme, not recommended)
> >>>
> >>> # Prolongation method of Facevars
> >>> prolMethod = "injection_prol" #(injecton_prol, balsara_prol)
> >>>
> >>> #ICM initial conditions with a central initial jet /10:
> >>> smlrho = 1.0e-4 # dens_j/10.
> >>> smallp = 1.e-3 # ~ min(pres)_ICM/10
> >>> smalle = 0.00900001 #(1/gamma)/((gamma-1)*1)/10: initial IMC
> >>> Therm Energy/10
> >>> #15.0
> >>> #smallt = 1.000
> >>>
> >>> #Total energy minimum limit
> >>> smallu = 0.000900001 #[(1/gamma)/((gamma-1)*1) + 0.]/10
> initial
> >>> IMC Total Energy/10
> >>> #15.5 #smallp/((gamma-1)smlrho)+.5(1)
> >>> #1815.0 #smallp/((gamma-1)smlrho)+.5(vel_j)^2
> >>>
> >>> tiny = 1.e-12
> >>>
> >>>
> >>> Best,
> >>>
> >>> Martin HE.
> >>> mh475 at cam.ac.uk <mailto:mh475 at cam.ac.uk>
> >>
> >
> >
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://flash.rochester.edu/pipermail/flash-users/attachments/20090311/4ef11b7d/attachment.htm>
More information about the flash-users
mailing list