nodget.f

Go to the documentation of this file.

c
c ------------------------------------------------------------
c
      integer function nodget()
c
      use amr_module
      implicit double precision (a-h,o-z)

c
c ::::::::::::::::: NODGET ::::::::::::::::::::::::::::::::::::;
c nodget =  get first free node of the linked list kept in node
c            array. adjust pointers accordingly.
c :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;
c
      if (ndfree .ne. null) go to 10
          write(outunit,100) maxgr
          write(*,100)       maxgr
100       format(' out of nodal space - allowed ',i8,' grids')
          do level = 1, lfine
             write(*,101) level,numgrids(level)
 101         format("    level ",i4," has ",i6,'grids')
          end do
          write(*,*)" Could need twice as many grids as on any given"
          write(*,*)" level if regridding/birecting"
          stop
c
c  update pointers
c
 10     nodget         = ndfree
        ndfree         = node(nextfree,ndfree)
c
c  initialize new  block
c
        do 20 i        = 1, nsize
           node(i,nodget) = 0
 20     continue
c
        do 30 i         = 1, rsize
           rnode(i,nodget) = 0.0d0
 30     continue
c
      return
      end
c
c ------------------------------------------------------------
c
      integer function nodget_bnd()
c
      use amr_module
      implicit double precision (a-h,o-z)

c
c ::::::::::::::::: NODGET_BND ::::::::::::::::::::::::::::::::::::;
c nodget_bnd =  same as above but for bndry list
c :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::;
c
      if (ndfree_bnd .ne. null) go to 10
          write(outunit,100) bndlistsize
          write(*,100)       bndlistsize
100       format(' out of bndry space - allowed ',i5,' bndry grids')
          ! calc average number of bndry nbors per grid
          nbortotal = 0
          numgridstotal = 0
          do lev = 1, lfine
            numgridstotal = numgridstotal + numgrids(lev)
            do mptr = 1, numgrids(lev)
               nbortotal = nbortotal + node(bndlistnum,mptr)  
            end do
          end do
          avgnbors = float(nbortotal)/numgridstotal
          write(*,101) numgridstotal,nbortotal,avgnbors
 101      format(" There are ",i8," total grids", i10," bndry nbors",
     .           " average num/grid ",f10.3)

          stop
c
c     ## adjust pointers
c
 10   nodget_bnd      = ndfree_bnd
      ndfree_bnd      = bndlist(ndfree_bnd,nextfree)
c
c     ##  initialize to 0
c
      bndlist(nodget_bnd,1) = 0
      bndlist(nodget_bnd,2) = 0
c
      return
      end
c
c -----------------------------------------------------------------
c
      subroutine makegridlist(lbase)
c
      use amr_module
      implicit none

      integer lbase, levst, lev, mptr, n

c :::::::::::::::::::::::::::: make_gridList :::::::::::::::::::::::::
c     make array of grid numbers (after sorting them so in decreasing
c     order of workload, done in arrangeGrid and put back into linked 
c     list. Done every time there is regridding, initial gridding,
c     or restarting.  Most often finest level is regridded, so
c     put it last in array. lbase is the level that didnt change, so 
c     only redo from lbase+1 to lfine.
c :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

      !write(*,*)"mgl: lbase,lfine",lbase,lfine
      do lev = lbase+1, lfine
         levst = liststart(lev) 
         !write(*,*)"mgl: level ",lev," starts at ",levSt
         mptr = lstart(lev)
c        traverse linked list into array. list already sorted by arrangegrids
         do n = 1, numgrids(lev)
            listofgrids(levst+n-1) = mptr
            mptr = node(levelptr,mptr)
         end do
c
c        next level starts one after where this one ends.
c        Using a sentinel in dimension of
c        listStart so no need to test if level = mxnest
c
         liststart(lev+1) = levst + numgrids(lev)
      end do

      return
      end
c
c -----------------------------------------------------------------
c
      subroutine initbndrylist()

      use amr_module
      implicit none
      
      integer i
c
c  need to manage the boundary List too
c
      do i = 1, bndlistsize
         bndlist(i,nextfree) = i+1
      end do

      bndlist(bndlistsize,nextfree) = null
      ndfree_bnd = 1

      end
c
c -----------------------------------------------------------------
c
      subroutine makebndrylist(level)
c
      use amr_module
      implicit none

      integer level, n, levst, k, nborcount
      integer nodget_bnd, nextspot, prevnbor, msrc, mptr
      integer imin, imax, jmin, jmax
      integer imlo, imhi, jmlo, jmhi
      integer ixlo, ixhi, jxlo, jxhi

c :::::::::::::::::::::::::::: makeBndryList :::::::::::::::::::::::::
c     preprocess each grid to have linked list of other grids at
c     same level that supply ghost cells.
c :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

c     traverse linked list into array. list already sorted by arrangegrids
      levst = liststart(level) 
      do n = 1, numgrids(level)
         mptr = listofgrids(levst+n-1)
         imin = node(ndilo,mptr) - nghost  ! ghost cells included since
         imax = node(ndihi,mptr) + nghost  ! this is what you want to fill
         jmin = node(ndjlo,mptr) - nghost  ! may also use for filval stuff,
         jmax = node(ndjhi,mptr) + nghost  ! change nghost to mbuff, etc
         nborcount = 0
         
         do k = 1, numgrids(level)  ! loop over all other grids once to find touching ones 
            if (k .eq. n) cycle     ! dont count yourself as source grid
            msrc = listofgrids(levst+k-1)

            ! Check if grid mptr and patch intersect
            imlo = node(ndilo, msrc)
            jmlo = node(ndjlo, msrc)
            imhi = node(ndihi, msrc)
            jmhi = node(ndjhi, msrc)

            ixlo = max(imlo,imin)
            ixhi = min(imhi,imax)
            jxlo = max(jmlo,jmin)
            jxhi = min(jmhi,jmax)

            if (ixlo .le. ixhi .and. jxlo .le. jxhi) then ! put on bnd list for mptr
               nborcount = nborcount + 1
               nextspot = nodget_bnd()   
               bndlist(nextspot,gridnbor) = msrc
               ! get spot in bnd list. insert next grid at front to avoid traversing
               bndlist(nextspot,nextfree) =  node(bndlistst,mptr)
               node(bndlistst,mptr) = nextspot
            endif

         end do

!        save final count
         node(bndlistnum,mptr) = nborcount
      end do

      return
      end
c
c -----------------------------------------------------------------
c
      subroutine freebndrylist(mold)
c
      use amr_module
      implicit none

      integer nborcount, mold,nextspot, i, nextnext

c :::::::::::::::::::::::::::: freeBndryList :::::::::::::::::::::::::
c     free the linked list of intersecting "boundary" grids for grid 'mold'
c     that is no longer active
c :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

           nborcount = node(bndlistnum,mold) ! count for this grid
           nextspot  = node(bndlistst,mold)  ! first index of this grids nbors
           do i = 1, nborcount
               nextnext = bndlist(nextspot,nextfree)
               call putnod_bnd(nextspot)
               nextspot = nextnext
           end do

      return
      end