flglvl2.f File Reference

Go to the source code of this file.

Functions/Subroutines
subroutine	flglvl2 (nvar, naux, lcheck, nxypts, index, lbase, npts, start_time)
	Controls the error estimation/flagging bad pts. More...
subroutine	freeflags (lcheck)

Function/Subroutine Documentation

flglvl2()

subroutine flglvl2	(		nvar,
			naux,
			lcheck,
			nxypts,
			index,
			lbase,
			npts,
			start_time
	)

Controls the error estimation/flagging bad pts.

for an entire level of grids. returns pointer into alloc where the (x,y) coordinations of the flagged pts. are.

Parameters

	nvar	number of equations for the system
	naux	number of auxiliary variables
	lcheck	level to be flagged
	nxypts	number of flagged points in total
	index	starting index (memory address) in alloc of the flagged points (which occupy 2*nxypts locations)
	lbase	base AMR level for current refinement, which stays fixed. Note that lbase is always less or equal to lcheck
	npts	Number of unique flagged cells (after removing duplicates)
[in]	start_time	start time of current simulation

Definition at line 26 of file flglvl2.f.

References amr_module::alloc, bufnst2(), colate2(), flagger(), freeflags(), igetsp(), amr_module::timebufnst, and amr_module::timeflagger.

Referenced by grdfit().

c
      use amr_module
      implicit double precision (a-h,o-z)
      integer clock_start, clock_finish, clock_rate
c
c
c
      nxypts = 0
      numbad = 0


c     flag arrays- based on either spatial gradients (and/or user defined 
c                  criteria),  or Richardson error estimation
    
      call system_clock(clock_start,clock_rate)
      call flagger(nvar,naux,lcheck,start_time)
      call system_clock(clock_finish,clock_rate)
      timeflagger = timeflagger + clock_finish - clock_start


c     buffer the flagged cells (done for each grid patch of flags)
c     also project flags from finer levels onto this level to ensure
c     proper nesting. Finally compute proper domain for each patch
      call system_clock(clock_start,clock_rate)
      call bufnst2(nvar,naux,numbad,lcheck,lbase) 
      call system_clock(clock_finish,clock_rate)
      timebufnst = timebufnst + clock_finish - clock_start

      nxypts = nxypts + numbad
c
c  colate flagged pts into flagged points array
c  new version needs to check for proper nesting at this point
c  also needs to sort,  so can remove duplicates.
c
      if (nxypts .gt. 0) then  
c        build domain flags for each grid at level lcheck, instead of
c        previous approach using domain flags over entire  domain
c         call domgrid(lbase,lcheck)   ! will need since there are flagged pts  NOW IN BUFNST2
c
c in new version, there are bad cells but nxypts isnt true count any longer
c since there are duplicates, and proper nesting not yet checked
           index = igetsp(2*nxypts)
           call colate2(alloc(index),nxypts,lcheck,npts,lbase)
      else 
         npts = 0  !npts is number of unique flagged points after removing duplicates
         call freeflags(lcheck)   ! otherwise storage freed in colate2. perhaps always do it here
      endif

      return

Here is the call graph for this function:

Here is the caller graph for this function:

freeflags()

subroutine freeflags

(

lcheck

)

Definition at line 80 of file flglvl2.f.

References amr_module::domflags2, amr_module::domflags_base, amr_module::ibuff, amr_module::levelptr, amr_module::lstart, amr_module::ndihi, amr_module::ndilo, amr_module::ndjhi, amr_module::ndjlo, amr_module::nghost, amr_module::node, reclam(), and amr_module::storeflags.

Referenced by flglvl2().

       use amr_module
       implicit double precision (a-h, o-z)

       mptr = lstart(lcheck)
 10          continue
             locamrflags = node(storeflags,mptr)
             locdomflags = node(domflags_base,mptr)
             locdom2 = node(domflags2,mptr)

             nx     = node(ndihi,mptr) - node(ndilo,mptr) + 1
             ny     = node(ndjhi,mptr) - node(ndjlo,mptr) + 1
             mbuff = max(nghost,ibuff+1)
             mibuff = nx + 2*mbuff
             mjbuff = ny + 2*mbuff

             ibytesperdp = 8
             nwords = (mibuff*mjbuff)/ibytesperdp+1
             call reclam(locdomflags, nwords)
             call reclam(locdom2, nwords)
             call reclam(locamrflags,mibuff*mjbuff)

        mptr = node(levelptr, mptr)
        if (mptr .ne. 0) go to 10

       return

Here is the call graph for this function:

Here is the caller graph for this function: