Controlling EB refinement

[serazo97]

Hi all, I'm working on some simulations and I'm having some trouble getting the refinement I want. Specifically, EBs seem to refine further from the boundaries and at finer levels than I need. I've been attempting to address this for a while but haven't had much success. For the refinement distance away from the EBs I thought the amr.n_error_buf option would help but no such luck when setting it to 1 or 0. For the refinement level, I haven't seen anything to help control this other than in the Tagging.H file where the option max_eb_refine_lev exists but doesn't seem to be implemented (or I'm using it wrong). I've attached an image showing what I mean. The left and right regions are solid and a detonation travels through the channel in the middle. The channel thickness is 4 blocks wide at the coarsest grid level. I don't know why the refining extends so far away from the edge of the EB both into the rest of the solid as well as into the open channel. It makes for that channel to have high refinement while nothing of interest is happening. The EB also lines up well with the coarser grid so this high level of refinement throughout the whole EB also seems unnecessary. Any help or info on this matter would be greatly appreciated!

[marchdf]

Hi, thanks for reaching out with your question! Typically to cap the level at which the EB is refined we would use something like this in the input file:

tagging.max_eb_refine_lev = 1

where the 1 indicates that we are only letting the EB be refined up to level 1. Sometimes, when the EBs are close to each other or to boundaries, we need to play with the following factor:

tagging.eb_detag_factor = 1.5

which controls how close/far the derefining of the EB happens. Can you try these options and let us know how it goes? It sounds like maybe you tried the first one already?

[serazo97]

I'm wondering now if the issue is the version of PeleC I'm using. It doesn't have the detagging criteria added, but it looks like the refinement level cap should work still. I'm going to clone the latest version and see if it works then.

[marchdf]

Yes, please use the latest. If that doesn't work, @esclapez might be able to help because he implemented this capability and probably has more insight.

[serazo97]

Well sadly it's still not working. Thanks for verifying that tagging.max_eb_refine_lev and tagging.eb_detag_factor are the correct flags to be using.

[esclapez]

I'm not entirely sure, but it looks like what you want is to have the EB refinement clustered more closely around the EB right ? This is mainly controlled by the 'properly nested' condition intrinsic to AMReX and is the result of the combination of a few parameters:

• the amr.blocking_factor
• the amr.n_error_buf
• the amr.grid_eff
  To get tighter clustering of fine patches around EB, you should have small amr.blocking_factor and amr.n_error_buf, and a high amr.grid_eff.
  As Marc mentioned, the detagging is used when the EB refinement level is smaller than the amr.max_level and you need to avoid having grid patches finer than you EB limit tagging.max_eb_refine_lev cross the EB. But that is not what you're trying to achieve at this point right ?

[serazo97]

@esclapez Thanks for the reply! I'm trying to have EB refinement clustered more closely around the EB as well as limit the refinement level for this cluster. What you said makes sense for the clustering and maybe there's not much more I can do beyond tweaking the domain to get smaller blocking factors. However, I feel like it's still possible to limit the level to which the EB itself refines some way that I'm missing. Using high amr.grid_eff most of the EB is not very refined, but at the boundaries it refines to the maximum AMR level when I feel that it could remain less refined. Maybe that also has to do with the 'properly nested' condition you mentioned, I'm not quite clear yet on how exactly the AMR works.

[serazo97]

Okay I think I was able to sort it out. As @esclapez pointed out, the clustering distance is intrinsic to AMReX and in my case I couldn't do much about it. However, I saw no reason why the refinement level cap should not be working correctly. After digging through some files, I found that the EB untagging distance is calculated by multiplying some terms, one of them being what looked to me like the amr.n_error_buf in the inputs file, which I had set to 0. Setting it to 1 and using the aforementioned tagging.max_eb_refine_lev and tagging.eb_detag_factor, I was able to finally limit the EB refinement level. Thanks to both of you for the very insightful comments!