[Carpet] Proper nesting

[Erik Schnetter]

On Apr 3, 2008, at 11:03:47, Ian Hinder wrote:
> Hi,
>
> I now have a question about proper nesting.  My current  
> understanding is
> that in order to be "properly nested", prolongation into the buffer
> zones of a fine grid should not use any points from the coarse grid
> which are themselves filled via prolongation.  Is this correct?

Yes.  Any kind of prolongation should not do this.  (Prolongation also  
occurs into ghost zones.)

> For a system with 12 buffer points, and equal numbers of points on  
> each
> refinement level, I think this means that using grids of 16 cells (17
> points) (in radius) would be properly nested, but 14 cells (15 points)
> would not be.  For simplicity, I am only considering the positive half
> of the grid; imagine a symmetry on the other side, and also that there
> are an even number of cells on each level, meaning that the last point
> owned by the fine grid is also present on the coarse grid.

Terminology can be confusing.  Let me assume that you use 3 ghost  
zones and 4 time interator substeps, so that you need to fill 12  
points on a refinement boundary.  Technically, these consist of 3  
ghost zones and 9 buffer zones.

I added a document "domain-decomposition" to Carpet, describing  
various terms and their definitions in rather technical terms.  It is  
probably not yet very readable as it does not have examples -- that  
is, there are figures still missing.  This also contains the exact  
definitions of these quantities.

> See the attached diagram for my reasoning.  It goes something like  
> this:
>
> * We want to determine the minimum number of grid cells we can have in
> the coarse region.
>
> * This region contains the fine buffer points, plus two extra coarse
> points needed to interpolate into the fine grid.
>
> * This comes to 12/2 + 2 coarse grid cells. Any points to the right of
> these are not used in prolongation, and can themselves be buffer  
> points,
> so in the minimum setup, they will be.
>
> * The total number of cells on a level is twice the number in the  
> coarse
> region, which would be 12 + 2*2 = 16.
>
> However, when I construct a grid of 14 cells, Carpet does not  
> complain.
> Using 12 gives the error
>
> WARNING[L1,P0] (CarpetLib): [ml=0 rl=1 c=0] The following grid  
> structure
> consistency check failed:
>   The communicated region must be contained in the active part of the
> domain
>   comm <= domain_active
>
> which I assume has replaced the "Not properly nested" warning from
> Carpet 3.

The "communicated region" of a given refined region is its exterior  
minus any outer boundary points.  The exterior of a region is, loosely  
speaking, everything, including ghost and buffer and outer boundary  
points.  The communicated region is thus what can be received from  
other regions, either via synchronisation or prolongation.  The point  
is that outer boundary points can in general not be filled via  
interpolation, and they thus have to be set by a boundary condition.   
Note that symmetries count as boundary condition, as usual in Carpet.

The active part of the domain is that part which is evolved, i.e.,  
everything without outer boundary points.

The error message says that one region, presumably one processor's  
part of a refined grid, contains non-boundary points which are on the  
boundary of your simulation domain.

This is in a sense an improperly nested grid, but it has to do with  
being too close to the outer boundary.

I'm sorry about all the terminology.  But the situation is indeed  
somewhat complex, and clear mathematical definitions seem to help.   
That doesn't make them easy to describe.  The document mentioned above  
uses mathematical notation which may be easier to read than text in  
email.

>  I have verified, in the case of 14 cells, that the points I
> expect appear in the 1D ASCII output, and I am using CarpetRegrid to
> construct the grid.  So my question is: why is Carpet not complaining
> when I use only 14 cells?  Is my argument above incorrect?


Proper nesting is not required for computational correctness, it is  
only a "nice feature" to have, and people are usually surprised when  
they learn that their grid structure is not properly nested.  In the  
presence of ghost and buffer ones some regions can be improperly  
nested, and everything is still properly defined, only the numerical  
errors will be much larger than expected.  Therefore Carpet does not  
enforce proper nesting in the loose sense above.

I don't like counting in terms of grid points, since it is easy to get  
confused.  Furthermore, different parts in Cactus/Carpet/CarpetRegrid/ 
CarpetRegrid2 eithe do or do not include boundary points, symmetry  
points, ghost points, or buffer points in their specification.  It is  
easier to speak of locations, e.g. the location of the outermost  
active (evolved) point of a region.  If you then count e.g. from the  
origin you can easily convert this into grid point counts.  Actually,  
I couldn't follow the calculation in your email.  The calculation in  
your figure is correct.  Note that Carpet add ghost zones  
automatically, whereas buffer zones have to be added explicitly if you  
use CarpetRegrid.  That is one reason why I insisted on the difference  
between ghost and buffer zones above...

Your figure assumes that the outermost active fine grid point  
coincides with a coarse grid point.  This is not required, and if not,  
you may need one more active point on the next coarser grid.

-erik

-- 
Erik Schnetter <schnetter at cct.lsu.edu>   http://www.cct.lsu.edu/~eschnett/

My email is as private as my paper mail.  I therefore support encrypting
and signing email messages.  Get my PGP key from www.keyserver.net.



-------------- next part --------------
A non-text attachment was scrubbed...
Name: PGP.sig
Type: application/pgp-signature
Size: 194 bytes
Desc: This is a digitally signed message part
Url : /archives/developers/attachments/20080403/68c1df57/attachment.pgp