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