#include <source/mesh/multiblock/MultiblockGriddingAlgorithm.h>
Inheritance diagram for SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >:
Public Member Functions | |
| MultiblockGriddingAlgorithm (const std::string &object_name, tbox::Pointer< tbox::Database > input_db, tbox::Pointer< hier::MultiblockPatchHierarchy< DIM > > multiblock, tbox::Pointer< mesh::TagAndInitializeStrategy< DIM > > level_strategy, tbox::Pointer< mesh::BoxGeneratorStrategy< DIM > > generator, tbox::Pointer< mesh::LoadBalanceStrategy< DIM > > balancer, MultiblockGriddingTagger< DIM > *mb_tagger_strategy=(MultiblockGriddingTagger< DIM > *)(0), bool register_for_restart=true) | |
| Construct the multiblock gridding algorithm. | |
| virtual | ~MultiblockGriddingAlgorithm () |
| virtual void | makeCoarsestLevel (tbox::Pointer< hier::BasePatchHierarchy< DIM > > multiblock, const double level_time, const hier::BoxArray< DIM > &override_boxes=0, const hier::ProcessorMapping &override_mapping=0) |
| Create level 0 for a hierarchy. | |
| virtual void | makeFinerLevel (tbox::Pointer< hier::BasePatchHierarchy< DIM > > multiblock, const double level_time, const bool initial_time, const int tag_buffer, const double regrid_start_time) |
| Create new finer level in hierarchy. | |
| virtual void | regridAllFinerLevels (tbox::Pointer< hier::BasePatchHierarchy< DIM > > multiblock, const int level_number, const double regrid_time, const tbox::Array< int > &tag_buffer, tbox::Array< double > regrid_start_time=tbox::Array< double >(), const bool level_is_coarsest_to_sync=true) |
| Regrid all levels finer that a specified level. | |
| virtual bool | errorEstimationUsesTimeIntegration () const |
| Return true if error estimation process uses time integration; otherwise, return false. | |
| virtual int | getErrorCoarsenRatio () const |
| Return the error coarsen ratio. | |
| virtual bool | levelCanBeRefined (const int level_number) const |
| Return true if level associated with the specified level number can * be refined; i.e., the level number is less than that of the finest level allowed in the hierarchy. Otherwise, false is returned. | |
| virtual tbox::Pointer< mesh::TagAndInitializeStrategy< DIM > > | getTagAndInitializeStrategy () const |
| Return pointer to level gridding strategy data member. | |
| virtual int | getMaxLevels () const |
| Return maximum number of levels allowed in hierarchy. | |
| virtual const hier::IntVector< DIM > & | getRatioToCoarserLevel (int level_number) const |
| Return const reference to ratio between specified level and next coarser. | |
| virtual double | getEfficiencyTolerance (int level_number) const |
| Return efficiency tolerance for clustering tags on level. | |
| virtual double | getCombineEfficiency (int level_number) const |
| Return combine efficiency for clustering tags on level. | |
| virtual int | getProperNestingBuffer (int level_number) const |
| Return proper nesting buffer width for level. | |
| virtual const hier::IntVector< DIM > & | getSmallestPatchSize (const int level_number) const |
| Return const reference to smallest patch size for level. | |
| virtual const hier::IntVector< DIM > & | getLargestPatchSize (const int level_number) const |
| Return const reference to largest patch size for level. | |
| virtual void | putToDatabase (tbox::Pointer< tbox::Database > db) |
| Write object state out to the given database. | |
The three main functions provided by this class are:
These basic AMR operations are used to generate of individual levels in the AMR patch hierarchy at the beginning of a simulation, and regridding collections of levels during an adaptive calculation. More details are found in the comments accompanying each member function below.
The operations that identify cells for refinement on a single level and initialize data and solution algorithm-specific information that depend on the AMR hierarchy configuration are provided by the data member of type mesh::TagAndInitializeStrategy<DIM>. Operations that cluster tagged cells into a collection of box regions are provided by the mesh::BoxGeneratorStrategy<DIM> data member. Routines that load balancing patches on each level are provided by the mesh::LoadBalanceStrategy<DIM> data member. The collaboration between this class and each of those objects follows the Strategy design pattern. Each instantiation of this gridding algorithm class is configured with concrete implementations of those routines by passing appropriate objects into this constructor.
Initialization of an MultiblockGriddingAlgorithm<DIM> object is performed via a combination of default parameters and values read from input. Data read from input is summarized as follows:
Required input keys and data types:
Optional input keys, data types, and defaults:
Note that when continuing from restart, the input values in the input file override all values read in from the restart database.
The following represents sample input data for a three-dimensional problem:
*
* // Required input: maximum bumber of levels in patch hierarchy
* max_levels = 4
*
* // Required input: vector ratio between each finer level and next coarser
* ratio_to_coarser {
* level_1 = 2, 2, 2
* level_2 = 2, 2, 2
* level_3 = 4, 4, 4
* }
*
* // Required input: int vector for largest patch size on each level.
* largest_patch_size {
* level_0 = 40, 40, 40
* level_1 = 30, 30, 30
* // all finer levels will use same values as level_1...
* }
*
* // Optional input: buffer of one cell used on each level
* proper_nesting_buffer = 1
* grow_after_nesting = FALSE
*
* // Optional input: int vector for smallest patch size on each level.
* smallest_patch_size {
* level_0 = 16, 16, 16
* // all finer levels will use same values as level_0...
* }
*
* // Optional input: different efficiency tolerance for each coarser level
* efficiency_tolerance = 0.80e0, 0.85e0, 0.90e0
*
* // Optional input: combine efficiency is same for all levels.
* combine_efficiency = 0.95e0
*
* write_regrid_boxes = TRUE
* regrid_boxes_filename = "regrid_boxes_32proc"
*
*
| SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::MultiblockGriddingAlgorithm | ( | const std::string & | object_name, | |
| tbox::Pointer< tbox::Database > | input_db, | |||
| tbox::Pointer< hier::MultiblockPatchHierarchy< DIM > > | multiblock, | |||
| tbox::Pointer< mesh::TagAndInitializeStrategy< DIM > > | level_strategy, | |||
| tbox::Pointer< mesh::BoxGeneratorStrategy< DIM > > | generator, | |||
| tbox::Pointer< mesh::LoadBalanceStrategy< DIM > > | balancer, | |||
| MultiblockGriddingTagger< DIM > * | mb_tagger_strategy = (MultiblockGriddingTagger< DIM > *)(0), |
|||
| bool | register_for_restart = true | |||
| ) |
Construct the multiblock gridding algorithm.
The constructor for MultiblockGriddingAlgorithm<DIM> configures the gridding algorithm with the concrete strategy objects in the argument list. Gridding parameters are initialized from values provided in the specified input and in the restart database corresponding to the specified object_name argument. The constructor also registers this object for restart using the specified object name when the boolean argument is true. Whether object will write its state to restart files during program execution is determined by this argument. Note that it has a default state of true.
If assertion checking is turned on, an unrecoverable assertion will result if any of the input database, level strategy, box generator, or load balancer pointers is null. Exceptions may also be thrown if any checks for consistency among input parameters fail.
| object_name | Name of object, to be used by RestartManager | |
| input_db | Input database | |
| multiblock | Multiblock patch hierarchy for the application | |
| level_strategy | Pointer to object that manages cell tagging | |
| generator | Pointer to object that generates boxes for a level | |
| balancer | Pointer to load-balancing object | |
| mb_tagger_strategy | Optional pointer to multiblock tagging strategy used to communicate tags across block boundaries. If not provided, a default will be used. Should be NULL unless user has implemented a class inheriting from MultiblockGriddingTagger. | |
| register_for_restart | Optional boolean flag indicating whether object will be written to restart files. The default is true indicating that the object will be written to resatrt files. |
| SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::~MultiblockGriddingAlgorithm | ( | ) | [virtual] |
Virtual destructor for MultiblockGriddingAlgorithm<DIM>.
| void SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::makeCoarsestLevel | ( | tbox::Pointer< hier::BasePatchHierarchy< DIM > > | multiblock, | |
| const double | level_time, | |||
| const hier::BoxArray< DIM > & | override_boxes = 0, |
|||
| const hier::ProcessorMapping & | override_mapping = 0 | |||
| ) | [virtual] |
Create level 0 for a hierarchy.
This routine will attempt to construct the coarsest level in an AMR multiblock patch hierarchy (i.e., level 0). If level 0 does not already exist, then the domain specification is checked against the constraints of the grid generation procedures. The level gridding strategy data member defines these constraints. Recall that the domain specification is maintained by the grid geometry object associated with the hierarchy. Generally, an unrecoverable exception will result if the constraints are not satisfied.
If level 0 already exists in the hierarchy, then the routine will generate a new level by re-applying the load balancing procedure to the existing level. Data will be moved from the old level to the new level and the pre-existing level 0 will be discarded. Note that this routine is different than the routine makeFinerLevel() below, which is used to construct levels 1 and finer. In particular, this routine does not select cells for refinement, whereas the other routine does.
Important note: If assertion checking is turned on, then an unrecoverable assertion will result if either the patch hierarchy or its grid geometry is NULL.
The two optional arguments exist only for compatibility with the base class BaseGriddingAlgorithm. If they are used in this function, they will be ignored.
| multiblock | Multiblock patch hierarchy on which level is created | |
| level_time | Simulation time for data on the new level | |
| override_boxes | optional argument that will be ignored | |
| override_mapping | optional argument that will be ignored |
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
| void SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::makeFinerLevel | ( | tbox::Pointer< hier::BasePatchHierarchy< DIM > > | multiblock, | |
| const double | level_time, | |||
| const bool | initial_time, | |||
| const int | tag_buffer, | |||
| const double | regrid_start_time | |||
| ) | [virtual] |
Create new finer level in hierarchy.
This routine attempts to create a new level in an AMR patch hierarchy finer than the finest level currently residing in the hierarchy. It will select cells for refinement on the finest level and construct a new finest level, if necessary. If no cells are selected for refinement, no new level will be added to the hierarchy. The boolean argument initial_time indicates whether the routine is called at the initial simulation time. If true, this routine is used to build individual levels during the construction of the AMR hierarchy at the initial simulation time. If false, the routine is being used to add new levels to the hierarchy at some later point. In either case, the time value is the current simulation time. Note that this routine cannot be used to construct the coarsest level in the hierarchy (i.e., level 0). The routine makeCoarsestLevel() above must be used for that purpose.
The tag buffer indicates the number of cells by which cells selected for refinement will be buffered before new finer level boxes are constructed. The buffer is important to keep phenomena of interest on refined regions of the mesh until adaptive regridding occurs next. Thus, the buffer size should take into account how the simulation may evolve before regridding occurs (e.g., number of timesteps taken).
Important note: If assertion checking is activated, several checks are applied to the function arguments. If any check is violated, an unrecoverable assertion will result. In particular, the hierarchy pointer must be non-NULL and the given level number must match that of the finest level currently residing in the hierarchy. Also, the the tag buffer must be positive.
| multiblock | Multiblock patch hierarchy on which level is created | |
| level_time | Simulation time at which this level is created | |
| initial_time | Boolean flag that should be true only if level_time is the initial time of the simulation | |
| tag_buffer | Number of cells to buffer cells tagged for refinement | |
| regrid_start_time | Time of the previous regrid |
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
| void SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::regridAllFinerLevels | ( | tbox::Pointer< hier::BasePatchHierarchy< DIM > > | multiblock, | |
| const int | level_number, | |||
| const double | regrid_time, | |||
| const tbox::Array< int > & | tag_buffer, | |||
| tbox::Array< double > | regrid_start_time = tbox::Array< double >(), |
|||
| const bool | level_is_coarsest_to_sync = true | |||
| ) | [virtual] |
Regrid all levels finer that a specified level.
This routine attempts to reconfigure the patches on each level in an AMR patch hierarchy which is finer than the specified level. The given level number is that of the coarsest level on which cells will be will be selected for refinement. In other words, that level is the finest level that will not be subject to a change in its patch configuration during the regridding process. Generally, this routine should be used to alter a pre-existing AMR patch hierarchy based on the need to adapt the computational mesh around some phenomenon of interest. The routine makeFinerLevel() above should be used to construct an initial hierarchy configuration or to add more than one new level into the hierarchy. Also, this routine will not reconfigure the patches on level 0 (i.e., the coarsest in any hierarchy). The routine makeCoarsestLevel() above is provided for that purpose.
Note that the current algorithm permits at most one new finest level to be added to the hierarchy with each invocation of the regridding process. This constraint, though seemingly restrictive makes the process of maintaining properly nested levels much easier.
The tag buffer array indicates the number of cells by which cells selected for refinement on a level will be buffered before new finer level boxes are constructed. The buffer is important to keep phenomena of interest on refined regions of the mesh until adaptive regridding occurs next. Thus, the buffer size should take into account how the simulation may evolve before regridding occurs (e.g., number of timesteps taken on each level).
The boolean argument level_is_coarsest_to_sync is used for regridding in time-dependent problems. When true, it indicates that the specified level is the coarsest level to synchronize at the current regrid time before this regridding method is called. This is a pretty idiosyncratic argument but allows some flexibility in the way memory is managed during time-dependent regridding operations.
Important note: If assertion checking is activated, several checks are applied to the functions arguments. If any check is violated, an unrecoverable assertion will result. In particular, the hierarchy pointer must be non-NULL and the given level number must match that of of some level in the hierarchy. Also, the tag buffer array must contain a positive value for each level in the hierarchy.
| multiblock | Multiblock patch hierarchy where the levels exist | |
| level_number | Level number of a coarse level for which all finer levels will be regridded | |
| regrid_time | Simulation time when regridding occurs | |
| tag_buffer | Array that stores the tag buffer around tagged cells that will be applied at each level. | |
| regrid_start_time | Array that stores the time that each level of the hierarchy was last regridded | |
| level_is_coarsest_to_sync | See comments above |
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
| bool SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::errorEstimationUsesTimeIntegration | ( | ) | const [virtual] |
Return true if error estimation process uses time integration; otherwise, return false.
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
| int SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::getErrorCoarsenRatio | ( | ) | const [virtual] |
Return the error coarsen ratio.
This is needed for cases where an error estimation schem uses time integration (e.g. Richardson extrapolation) to determine how many time levels to maintain to properly apply the estimtion scheme. In general, an even refine ratio (e.g. 2, 4, 8) will maintain two time levels, while an odd refine ratio (e.g. 3) will maintain three.
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
| bool SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::levelCanBeRefined | ( | const int | level_number | ) | const [virtual] |
Return true if level associated with the specified level number can * be refined; i.e., the level number is less than that of the finest level allowed in the hierarchy. Otherwise, false is returned.
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
| tbox::Pointer< mesh::TagAndInitializeStrategy< DIM > > SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::getTagAndInitializeStrategy | ( | ) | const [virtual] |
Return pointer to level gridding strategy data member.
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
| int SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::getMaxLevels | ( | ) | const [virtual] |
Return maximum number of levels allowed in hierarchy.
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
| const hier::IntVector< DIM > & SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::getRatioToCoarserLevel | ( | int | level_number | ) | const [virtual] |
Return const reference to ratio between specified level and next coarser.
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
| double SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::getEfficiencyTolerance | ( | int | level_number | ) | const [virtual] |
Return efficiency tolerance for clustering tags on level.
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
| double SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::getCombineEfficiency | ( | int | level_number | ) | const [virtual] |
Return combine efficiency for clustering tags on level.
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
| int SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::getProperNestingBuffer | ( | int | level_number | ) | const [virtual] |
Return proper nesting buffer width for level.
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
| const hier::IntVector< DIM > & SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::getSmallestPatchSize | ( | const int | level_number | ) | const [virtual] |
Return const reference to smallest patch size for level.
| const hier::IntVector< DIM > & SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::getLargestPatchSize | ( | const int | level_number | ) | const [virtual] |
Return const reference to largest patch size for level.
| void SAMRAI::mesh::MultiblockGriddingAlgorithm< DIM >::putToDatabase | ( | tbox::Pointer< tbox::Database > | db | ) | [virtual] |
Write object state out to the given database.
When assertion checking is active, the database pointer must be non-null.
Implements SAMRAI::mesh::BaseGriddingAlgorithm< DIM >.
1.5.1