Class AdvDiffSemiImplicitHierarchyIntegrator manages the spatial discretization and time integration of scalar- and vector-valued quantities whose dynamics are governed by the advection-diffusion equation. More...

#include <ibamr/AdvDiffSemiImplicitHierarchyIntegrator.h>

Inheritance diagram for IBAMR::AdvDiffSemiImplicitHierarchyIntegrator:

[legend]

Public Types
using	ResetPropertiesFcnPtr = void()(int property_idx, SAMRAI::tbox::Pointer< IBTK::HierarchyMathOps > hier_math_ops, int integrator_step, double time, bool initial_time, bool regrid_time, void ctx)
	Function to reset variables registered by this integrator. More...

using	PreprocessIntegrateHierarchyCallbackFcnPtr = void()(double current_time, double new_time, int num_cycles, void ctx)

using	IntegrateHierarchyCallbackFcnPtr = void()(double current_time, double new_time, int cycle_num, void ctx)

using	PostprocessIntegrateHierarchyCallbackFcnPtr = void()(double current_time, double new_time, bool skip_synchronize_new_state_data, int num_cycles, void ctx)

using	ApplyGradientDetectorCallbackFcnPtr = void()(SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > > hierarchy, int level_number, double error_data_time, int tag_index, bool initial_time, bool uses_richardson_extrapolation_too, void ctx)

using	RegridHierarchyCallbackFcnPtr = void()(SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > > hierarchy, double data_time, bool initial_time, void ctx)

Public Member Functions
	AdvDiffSemiImplicitHierarchyIntegrator (const std::string &object_name, SAMRAI::tbox::Pointer< SAMRAI::tbox::Database > input_db, bool register_for_restart=true)

	~AdvDiffSemiImplicitHierarchyIntegrator ()=default

void	setDefaultConvectiveTimeSteppingType (TimeSteppingType default_convective_time_stepping_type)

TimeSteppingType	getDefaultConvectiveTimeSteppingType () const

void	setDefaultInitialConvectiveTimeSteppingType (TimeSteppingType default_init_convective_time_stepping_type)

TimeSteppingType	getDefaultInitialConvectiveTimeSteppingType () const

void	setDefaultConvectiveOperatorType (const std::string &op_type)
	Set the default convective operator type to be used by the solver. More...

const std::string &	getDefaultConvectiveOperatorType () const
	Get the default convective operator type used by the solver. More...

void	setDefaultConvectiveOperatorInputDatabase (SAMRAI::tbox::Pointer< SAMRAI::tbox::Database > input_db)
	Set the default convective operator input database to be used by the solver. More...

SAMRAI::tbox::Pointer< SAMRAI::tbox::Database >	getDefaultConvectiveOperatorInputDatabase () const
	Get the default convective operator input database to be used by the solver. More...

void	registerTransportedQuantity (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, const bool Q_output=true) override

void	setConvectiveTimeSteppingType (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, TimeSteppingType convective_time_stepping_type)

TimeSteppingType	getConvectiveTimeSteppingType (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const

void	setInitialConvectiveTimeSteppingType (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, TimeSteppingType init_convective_time_stepping_type)

TimeSteppingType	getInitialConvectiveTimeSteppingType (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const

void	setConvectiveOperatorType (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, const std::string &op_type)
	Set the convective operator type to be used by the solver for a particular transported quantity Q. More...

const std::string &	getConvectiveOperatorType (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const
	Get the convective operator type used by the solver for a particular transported quantity Q. More...

void	setConvectiveOperatorInputDatabase (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, SAMRAI::tbox::Pointer< SAMRAI::tbox::Database > input_db)
	Set the convective operator input database to be used by the solver for a particular transported quantity Q. More...

SAMRAI::tbox::Pointer< SAMRAI::tbox::Database >	getConvectiveOperatorInputDatabase (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const
	Get the convective operator boundary input database used by the solver for a particular transported quantity Q. More...

void	setConvectiveOperator (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, SAMRAI::tbox::Pointer< ConvectiveOperator > convective_op)

virtual SAMRAI::tbox::Pointer< ConvectiveOperator >	getConvectiveOperator (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var)

void	setConvectiveOperatorsNeedInit ()

void	setConvectiveOperatorNeedsInit (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var)

void	initializeHierarchyIntegrator (SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > > hierarchy, SAMRAI::tbox::Pointer< SAMRAI::mesh::GriddingAlgorithm< NDIM > > gridding_alg) override

int	getNumberOfCycles () const override

void	preprocessIntegrateHierarchy (double current_time, double new_time, int num_cycles=1) override

void	postprocessIntegrateHierarchy (double current_time, double new_time, bool skip_synchronize_new_state_data, int num_cycles=1) override

void	setDefaultDiffusionTimeSteppingType (TimeSteppingType default_diffusion_time_stepping_type)

TimeSteppingType	getDefaultDiffusionTimeSteppingType () const

void	setDefaultConvectiveDifferencingType (ConvectiveDifferencingType default_convective_difference_form)

ConvectiveDifferencingType	getDefaultConvectiveDifferencingType () const

virtual void	registerAdvectionVelocity (SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > > u_var)

void	setAdvectionVelocityIsDivergenceFree (SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > > u_var, bool is_div_free)

bool	getAdvectionVelocityIsDivergenceFree (SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > > u_var) const

void	setAdvectionVelocityFunction (SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > > u_var, SAMRAI::tbox::Pointer< IBTK::CartGridFunction > u_fcn)

SAMRAI::tbox::Pointer< IBTK::CartGridFunction >	getAdvectionVelocityFunction (SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > > u_var) const

virtual void	registerSourceTerm (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > F_var, const bool output_F=true)

void	setSourceTermFunction (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > F_var, SAMRAI::tbox::Pointer< IBTK::CartGridFunction > F_fcn)

SAMRAI::tbox::Pointer< IBTK::CartGridFunction >	getSourceTermFunction (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > F_var) const

void	setAdvectionVelocity (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > > u_var)

SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > >	getAdvectionVelocity (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const

void	setSourceTerm (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > F_var)

SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	getSourceTerm (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const

void	setDiffusionTimeSteppingType (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, TimeSteppingType time_stepping_type)

TimeSteppingType	getDiffusionTimeSteppingType (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const

void	setConvectiveDifferencingType (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, ConvectiveDifferencingType difference_form)

ConvectiveDifferencingType	getConvectiveDifferencingType (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const

void	setDiffusionCoefficient (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, double kappa)

double	getDiffusionCoefficient (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const

void	registerDiffusionCoefficientVariable (SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > > D_var)

void	setDiffusionCoefficientFunction (SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > > D_var, SAMRAI::tbox::Pointer< IBTK::CartGridFunction > D_fcn)

SAMRAI::tbox::Pointer< IBTK::CartGridFunction >	getDiffusionCoefficientFunction (SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > > D_var) const

void	setDiffusionCoefficientVariable (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > > D_var)

SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > >	getDiffusionCoefficientVariable (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const

bool	isDiffusionCoefficientVariable (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const

void	setDampingCoefficient (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, double lambda)

double	getDampingCoefficient (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const

void	setInitialConditions (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, SAMRAI::tbox::Pointer< IBTK::CartGridFunction > Q_init)

SAMRAI::tbox::Pointer< IBTK::CartGridFunction >	getInitialConditions (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const

void	setPhysicalBcCoef (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, SAMRAI::solv::RobinBcCoefStrategy< NDIM > *Q_bc_coef)

void	setPhysicalBcCoefs (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, const std::vector< SAMRAI::solv::RobinBcCoefStrategy< NDIM > * > &Q_bc_coef)

std::vector< SAMRAI::solv::RobinBcCoefStrategy< NDIM > * >	getPhysicalBcCoefs (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const

void	setHelmholtzSolver (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, SAMRAI::tbox::Pointer< IBTK::PoissonSolver > helmholtz_solver)

SAMRAI::tbox::Pointer< IBTK::PoissonSolver >	getHelmholtzSolver (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var)

void	setHelmholtzSolversNeedInit ()

void	setHelmholtzSolverNeedsInit (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var)

void	setHelmholtzRHSOperator (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, SAMRAI::tbox::Pointer< IBTK::LaplaceOperator > helmholtz_rhs_operator)

SAMRAI::tbox::Pointer< IBTK::LaplaceOperator >	getHelmholtzRHSOperator (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var)

void	setHelmholtzRHSOperatorsNeedInit ()

void	setHelmholtzRHSOperatorNeedsInit (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var)

void	registerResetFunction (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, ResetPropertiesFcnPtr callback, void *ctx)
	Register a reset callback function for a specified variable. More...

void	setResetPriority (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var, int priority)
	Set a reset priority for a particular variable. More...

std::vector< ResetPropertiesFcnPtr >	getResetFunctions (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const
	Get the reset callback functions registered with this variable. More...

int	getResetPriority (SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var) const
	Get the reset priority for a particular variable. More...

const std::string &	getName () const

virtual void	initializePatchHierarchy (SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > > hierarchy, SAMRAI::tbox::Pointer< SAMRAI::mesh::GriddingAlgorithm< NDIM > > gridding_alg)

virtual void	advanceHierarchy (double dt)

double	getMinimumTimeStepSize ()

double	getMaximumTimeStepSize ()

void	synchronizeHierarchyData (VariableContextType ctx_type)

void	resetTimeDependentHierarchyData (double new_time)

void	resetIntegratorToPreadvanceState ()

virtual void	regridHierarchy ()

bool	atRegridPoint () const

double	getIntegratorTime () const

double	getStartTime () const

double	getEndTime () const

int	getIntegratorStep () const

int	getMaxIntegratorSteps () const

bool	stepsRemaining () const

void	updateWorkloadEstimates ()

SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > >	getPatchHierarchy () const

SAMRAI::tbox::Pointer< SAMRAI::mesh::GriddingAlgorithm< NDIM > >	getGriddingAlgorithm () const

virtual void	registerLoadBalancer (SAMRAI::tbox::Pointer< SAMRAI::mesh::LoadBalancer< NDIM > > load_balancer)

int	getWorkloadDataIndex () const

void	registerVisItDataWriter (SAMRAI::tbox::Pointer< SAMRAI::appu::VisItDataWriter< NDIM > > visit_writer)

SAMRAI::tbox::Pointer< SAMRAI::appu::VisItDataWriter< NDIM > >	getVisItDataWriter () const

void	setupPlotData ()

virtual int	getCurrentCycleNumber () const

virtual double	getCurrentTimeStepSize () const

void	integrateHierarchy (double current_time, double new_time, int cycle_num=0)

void	skipCycle (double current_time, double new_time, int cycle_num=0)

void	registerPreprocessIntegrateHierarchyCallback (PreprocessIntegrateHierarchyCallbackFcnPtr callback, void *ctx=nullptr)

void	registerIntegrateHierarchyCallback (IntegrateHierarchyCallbackFcnPtr callback, void *ctx=nullptr)

void	registerPostprocessIntegrateHierarchyCallback (PostprocessIntegrateHierarchyCallbackFcnPtr callback, void *ctx=nullptr)

void	registerApplyGradientDetectorCallback (ApplyGradientDetectorCallbackFcnPtr callback, void *ctx=nullptr)

void	registerRegridHierarchyCallback (RegridHierarchyCallbackFcnPtr, void *ctx=nullptr)

void	initializeCompositeHierarchyData (double init_data_time, bool initial_time)

void	initializeLevelData (SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > > hierarchy, int level_number, double init_data_time, bool can_be_refined, bool initial_time, SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchLevel< NDIM > > old_level=SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchLevel< NDIM > >(nullptr), bool allocate_data=true) override

virtual void	initializeLevelData (const tbox::Pointer< hier::BasePatchHierarchy< DIM > > hierarchy, const int level_number, const double init_data_time, const bool can_be_refined, const bool initial_time, const tbox::Pointer< hier::BasePatchLevel< DIM > > old_level=tbox::Pointer< hier::BasePatchLevel< DIM > >(NULL), const bool allocate_data=true)=0

void	resetHierarchyConfiguration (SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > > hierarchy, int coarsest_level, int finest_level) override

virtual void	resetHierarchyConfiguration (const tbox::Pointer< hier::BasePatchHierarchy< DIM > > hierarchy, const int coarsest_level, const int finest_level)=0

void	applyGradientDetector (SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > > hierarchy, int level_number, double error_data_time, int tag_index, bool initial_time, bool uses_richardson_extrapolation_too) override

virtual void	applyGradientDetector (const tbox::Pointer< hier::BasePatchHierarchy< DIM > > hierarchy, const int level_number, const double error_data_time, const int tag_index, const bool initial_time, const bool uses_richardson_extrapolation_too)

SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext >	getContext (VariableContextType ctx_type) const

SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext >	getCurrentContext () const

SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext >	getNewContext () const

SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext >	getScratchContext () const

SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext >	getPlotContext () const

bool	isAllocatedPatchData (int data_idx, int coarsest_ln=invalid_level_number, int finest_ln=invalid_level_number) const

void	allocatePatchData (int data_idx, double data_time, int coarsest_ln=invalid_level_number, int finest_ln=invalid_level_number) const

void	deallocatePatchData (int data_idx, int coarsest_ln=invalid_level_number, int finest_ln=invalid_level_number) const

SAMRAI::tbox::Pointer< HierarchyMathOps >	getHierarchyMathOps () const

void	registerVariable (int &current_idx, int &new_idx, int &scratch_idx, SAMRAI::tbox::Pointer< SAMRAI::hier::Variable< NDIM > > variable, const SAMRAI::hier::IntVector< NDIM > &scratch_ghosts=SAMRAI::hier::IntVector< NDIM >(0), const std::string &coarsen_name="NO_COARSEN", const std::string &refine_name="NO_REFINE", SAMRAI::tbox::Pointer< CartGridFunction > init_fcn=nullptr, const bool register_for_restart=true)

void	registerVariable (int &idx, SAMRAI::tbox::Pointer< SAMRAI::hier::Variable< NDIM > > variable, const SAMRAI::hier::IntVector< NDIM > &ghosts=SAMRAI::hier::IntVector< NDIM >(0), SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext > ctx=SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext >(nullptr), const bool register_for_restart=true)

void	putToDatabase (SAMRAI::tbox::Pointer< SAMRAI::tbox::Database > db) override

virtual double	getLevelDt (const tbox::Pointer< hier::BasePatchLevel< DIM > > level, const double dt_time, const bool initial_time)

virtual double	advanceLevel (const tbox::Pointer< hier::BasePatchLevel< DIM > > level, const tbox::Pointer< hier::BasePatchHierarchy< DIM > > hierarchy, const double current_time, const double new_time, const bool first_step, const bool last_step, const bool regrid_advance=false)

virtual void	resetTimeDependentData (const tbox::Pointer< hier::BasePatchLevel< DIM > > level, const double new_time, const bool can_be_refined)

virtual void	resetDataToPreadvanceState (const tbox::Pointer< hier::BasePatchLevel< DIM > > level)

virtual void	applyRichardsonExtrapolation (const tbox::Pointer< hier::PatchLevel< DIM > > level, const double error_data_time, const int tag_index, const double deltat, const int error_coarsen_ratio, const bool initial_time, const bool uses_gradient_detector_too)

virtual void	coarsenDataForRichardsonExtrapolation (const tbox::Pointer< hier::PatchHierarchy< DIM > > hierarchy, const int level_number, const tbox::Pointer< hier::PatchLevel< DIM > > coarser_level, const double coarsen_data_time, const bool before_advance)

Protected Member Functions
void	integrateHierarchySpecialized (double current_time, double new_time, int cycle_num=0) override

void	resetHierarchyConfigurationSpecialized (SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > > hierarchy, int coarsest_level, int finest_level) override

void	putToDatabaseSpecialized (SAMRAI::tbox::Pointer< SAMRAI::tbox::Database > db) override

double	getMaximumTimeStepSizeSpecialized () override

void	initializeCompositeHierarchyDataSpecialized (double init_data_time, bool initial_time) override

void	registerVariables ()

virtual void	regridHierarchyBeginSpecialized ()

virtual void	regridHierarchyEndSpecialized ()

virtual double	getMinimumTimeStepSizeSpecialized ()

virtual void	synchronizeHierarchyDataSpecialized (VariableContextType ctx_type)

virtual void	resetTimeDependentHierarchyDataSpecialized (double new_time)

virtual void	resetIntegratorToPreadvanceStateSpecialized ()

virtual bool	atRegridPointSpecialized () const

virtual void	setupPlotDataSpecialized ()

virtual void	initializeLevelDataSpecialized (SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > > hierarchy, int level_number, double init_data_time, bool can_be_refined, bool initial_time, SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchLevel< NDIM > > old_level, bool allocate_data)

virtual void	applyGradientDetectorSpecialized (SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > > hierarchy, int level_number, double error_data_time, int tag_index, bool initial_time, bool uses_richardson_extrapolation_too)

virtual void	addWorkloadEstimate (SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > > hierarchy, const int workload_data_idx)

virtual void	executePreprocessIntegrateHierarchyCallbackFcns (double current_time, double new_time, int num_cycles)

virtual void	executeIntegrateHierarchyCallbackFcns (double current_time, double new_time, int cycle_num)

virtual void	executePostprocessIntegrateHierarchyCallbackFcns (double current_time, double new_time, bool skip_synchronize_new_state_data, int num_cycles)

virtual void	executeApplyGradientDetectorCallbackFcns (SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > > hierarchy, int level_number, double error_data_time, int tag_index, bool initial_time, bool uses_richardson_extrapolation_too)

virtual void	executeRegridHierarchyCallbackFcns (SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > > hierarchy, double data_time, bool initial_time)

void	registerGhostfillRefineAlgorithm (const std::string &name, SAMRAI::tbox::Pointer< SAMRAI::xfer::RefineAlgorithm< NDIM > > ghostfill_alg, std::unique_ptr< SAMRAI::xfer::RefinePatchStrategy< NDIM > > ghostfill_patch_strategy=nullptr)

void	registerProlongRefineAlgorithm (const std::string &name, SAMRAI::tbox::Pointer< SAMRAI::xfer::RefineAlgorithm< NDIM > > prolong_alg, std::unique_ptr< SAMRAI::xfer::RefinePatchStrategy< NDIM > > prolong_patch_strategy=nullptr)

void	registerCoarsenAlgorithm (const std::string &name, SAMRAI::tbox::Pointer< SAMRAI::xfer::CoarsenAlgorithm< NDIM > > coarsen_alg, std::unique_ptr< SAMRAI::xfer::CoarsenPatchStrategy< NDIM > > coarsen_patch_strategy=nullptr)

SAMRAI::tbox::Pointer< SAMRAI::xfer::RefineAlgorithm< NDIM > >	getGhostfillRefineAlgorithm (const std::string &name) const

SAMRAI::tbox::Pointer< SAMRAI::xfer::RefineAlgorithm< NDIM > >	getProlongRefineAlgorithm (const std::string &name) const

SAMRAI::tbox::Pointer< SAMRAI::xfer::CoarsenAlgorithm< NDIM > >	getCoarsenAlgorithm (const std::string &name) const

const std::vector< SAMRAI::tbox::Pointer< SAMRAI::xfer::RefineSchedule< NDIM > > > &	getGhostfillRefineSchedules (const std::string &name) const

const std::vector< SAMRAI::tbox::Pointer< SAMRAI::xfer::RefineSchedule< NDIM > > > &	getProlongRefineSchedules (const std::string &name) const

const std::vector< SAMRAI::tbox::Pointer< SAMRAI::xfer::CoarsenSchedule< NDIM > > > &	getCoarsenSchedules (const std::string &name) const

void	registerChildHierarchyIntegrator (HierarchyIntegrator *child_integrator)

void	registerParentHierarchyIntegrator (HierarchyIntegrator *parent_integrator)

SAMRAI::tbox::Pointer< HierarchyMathOps >	buildHierarchyMathOps (SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > > hierarchy)

void	setupTagBuffer (SAMRAI::tbox::Pointer< SAMRAI::mesh::GriddingAlgorithm< NDIM > > gridding_alg)

bool	regriddingHierarchy () const

bool	atRegridTimeStep () const

Protected Attributes
TimeSteppingType	d_default_convective_time_stepping_type

TimeSteppingType	d_default_init_convective_time_stepping_type

std::string	d_default_convective_op_type

SAMRAI::tbox::Pointer< SAMRAI::tbox::Database >	d_default_convective_op_input_db

SAMRAI::tbox::Pointer< SAMRAI::math::HierarchyFaceDataOpsReal< NDIM, double > >	d_hier_fc_data_ops

std::set< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > >	d_N_var

std::set< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > >	d_N_old_var

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > >	d_Q_N_map

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > >	d_Q_N_old_map

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, TimeSteppingType >	d_Q_convective_time_stepping_type

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, TimeSteppingType >	d_Q_init_convective_time_stepping_type

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, std::string >	d_Q_convective_op_type

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, SAMRAI::tbox::Pointer< SAMRAI::tbox::Database > >	d_Q_convective_op_input_db

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, SAMRAI::tbox::Pointer< ConvectiveOperator > >	d_Q_convective_op

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, bool >	d_Q_convective_op_needs_init

bool	d_integrator_is_initialized = false

double	d_cfl_max = 0.5

TimeSteppingType	d_default_diffusion_time_stepping_type = TRAPEZOIDAL_RULE

ConvectiveDifferencingType	d_default_convective_difference_form = CONSERVATIVE

std::vector< SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > > >	d_u_var

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > >, bool >	d_u_is_div_free

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > >, SAMRAI::tbox::Pointer< IBTK::CartGridFunction > >	d_u_fcn

std::vector< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > >	d_F_var

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, SAMRAI::tbox::Pointer< IBTK::CartGridFunction > >	d_F_fcn

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, bool >	d_F_output

std::vector< SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > > >	d_diffusion_coef_var

std::vector< SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > > >	d_diffusion_coef_rhs_var

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > >, SAMRAI::tbox::Pointer< IBTK::CartGridFunction > >	d_diffusion_coef_fcn

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > >, SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > > >	d_diffusion_coef_rhs_map

std::vector< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > >	d_Q_var

std::vector< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > >	d_Q_rhs_var

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > > >	d_Q_u_map

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > >	d_Q_F_map

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > >	d_Q_Q_rhs_map

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, TimeSteppingType >	d_Q_diffusion_time_stepping_type

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, ConvectiveDifferencingType >	d_Q_difference_form

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, double >	d_Q_diffusion_coef

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > > >	d_Q_diffusion_coef_variable

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, bool >	d_Q_is_diffusion_coef_variable

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, double >	d_Q_damping_coef

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, SAMRAI::tbox::Pointer< IBTK::CartGridFunction > >	d_Q_init

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, std::vector< SAMRAI::solv::RobinBcCoefStrategy< NDIM > * > >	d_Q_bc_coef

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, bool >	d_Q_output

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, std::vector< ResetPropertiesFcnPtr > >	d_Q_reset_fcns

std::map< SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >, std::vector< void * > >	d_Q_reset_fcns_ctx

std::vector< int >	d_Q_reset_priority

SAMRAI::tbox::Pointer< SAMRAI::math::HierarchyCellDataOpsReal< NDIM, double > >	d_hier_cc_data_ops

SAMRAI::tbox::Pointer< SAMRAI::math::HierarchySideDataOpsReal< NDIM, double > >	d_hier_sc_data_ops

std::vector< SAMRAI::tbox::Pointer< IBTK::HierarchyGhostCellInterpolation > >	d_hier_bdry_fill_ops

SAMRAI::tbox::Pointer< IBTK::HierarchyGhostCellInterpolation >	d_no_fill_op

std::vector< SAMRAI::tbox::Pointer< SAMRAI::solv::SAMRAIVectorReal< NDIM, double > > >	d_sol_vecs

std::vector< SAMRAI::tbox::Pointer< SAMRAI::solv::SAMRAIVectorReal< NDIM, double > > >	d_rhs_vecs

std::string	d_helmholtz_solver_type

std::string	d_helmholtz_precond_type

std::string	d_helmholtz_sub_precond_type

SAMRAI::tbox::Pointer< SAMRAI::tbox::Database >	d_helmholtz_solver_db

SAMRAI::tbox::Pointer< SAMRAI::tbox::Database >	d_helmholtz_precond_db

SAMRAI::tbox::Pointer< SAMRAI::tbox::Database >	d_helmholtz_sub_precond_db

std::vector< SAMRAI::tbox::Pointer< IBTK::PoissonSolver > >	d_helmholtz_solvers

std::vector< SAMRAI::tbox::Pointer< IBTK::LaplaceOperator > >	d_helmholtz_rhs_ops

std::vector< bool >	d_helmholtz_solvers_need_init

std::vector< bool >	d_helmholtz_rhs_ops_need_init

int	d_coarsest_reset_ln = IBTK::invalid_level_number

int	d_finest_reset_ln = IBTK::invalid_level_number

std::string	d_object_name

bool	d_registered_for_restart = false

SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > >	d_hierarchy

SAMRAI::tbox::Pointer< SAMRAI::mesh::GriddingAlgorithm< NDIM > >	d_gridding_alg

SAMRAI::tbox::Pointer< SAMRAI::mesh::LoadBalancer< NDIM > >	d_load_balancer

SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	d_workload_var

int	d_workload_idx = IBTK::invalid_index

bool	d_hierarchy_is_initialized = false

bool	d_may_need_to_reset_hierarchy_configuration = false

HierarchyIntegrator *	d_parent_integrator = nullptr

std::set< HierarchyIntegrator * >	d_child_integrators

SAMRAI::tbox::Pointer< SAMRAI::appu::VisItDataWriter< NDIM > >	d_visit_writer

double	d_integrator_time = std::numeric_limits<double>::quiet_NaN()

double	d_start_time = 0.0

double	d_end_time = std::numeric_limits<double>::max()

double	d_dt_init = std::numeric_limits<double>::max()

double	d_dt_min = 0.0

double	d_dt_max = std::numeric_limits<double>::max()

double	d_dt_growth_factor = 2.0

int	d_integrator_step = 0

int	d_max_integrator_steps = std::numeric_limits<int>::max()

std::deque< double >	d_dt_previous

int	d_num_cycles = 1

int	d_current_num_cycles = -1

int	d_current_cycle_num = -1

double	d_current_dt = std::numeric_limits<double>::quiet_NaN()

int	d_regrid_interval = 1

RegridMode	d_regrid_mode = STANDARD

bool	d_enable_logging = false

bool	d_enable_logging_solver_iterations = false

std::string	d_bdry_extrap_type = "LINEAR"

SAMRAI::tbox::Array< int >	d_tag_buffer = { 0 }

SAMRAI::tbox::Pointer< HierarchyMathOps >	d_hier_math_ops

bool	d_manage_hier_math_ops = true

std::list< SAMRAI::tbox::Pointer< SAMRAI::hier::Variable< NDIM > > >	d_state_variables

std::list< SAMRAI::tbox::Pointer< SAMRAI::hier::Variable< NDIM > > >	d_scratch_variables

std::list< SAMRAI::tbox::Pointer< SAMRAI::hier::Variable< NDIM > > >	d_copy_scratch_to_current_fast

std::list< SAMRAI::tbox::Pointer< SAMRAI::hier::Variable< NDIM > > >	d_copy_scratch_to_current_slow

SAMRAI::hier::ComponentSelector	d_current_data

SAMRAI::hier::ComponentSelector	d_new_data

SAMRAI::hier::ComponentSelector	d_scratch_data

SAMRAI::hier::ComponentSelector	d_plot_data

std::map< SAMRAI::hier::Variable< NDIM > *, SAMRAI::tbox::Pointer< CartGridFunction > >	d_state_var_init_fcns

SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext >	d_current_context

SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext >	d_new_context

SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext >	d_scratch_context

SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext >	d_plot_context

SAMRAI::hier::ComponentSelector	d_fill_after_regrid_bc_idxs

SAMRAI::xfer::RefineAlgorithm< NDIM >	d_fill_after_regrid_prolong_alg

std::unique_ptr< SAMRAI::xfer::RefinePatchStrategy< NDIM > >	d_fill_after_regrid_phys_bdry_bc_op

std::vector< PreprocessIntegrateHierarchyCallbackFcnPtr >	d_preprocess_integrate_hierarchy_callbacks

std::vector< void * >	d_preprocess_integrate_hierarchy_callback_ctxs

std::vector< IntegrateHierarchyCallbackFcnPtr >	d_integrate_hierarchy_callbacks

std::vector< void * >	d_integrate_hierarchy_callback_ctxs

std::vector< PostprocessIntegrateHierarchyCallbackFcnPtr >	d_postprocess_integrate_hierarchy_callbacks

std::vector< void * >	d_postprocess_integrate_hierarchy_callback_ctxs

std::vector< ApplyGradientDetectorCallbackFcnPtr >	d_apply_gradient_detector_callbacks

std::vector< void * >	d_apply_gradient_detector_callback_ctxs

std::vector< RegridHierarchyCallbackFcnPtr >	d_regrid_hierarchy_callbacks

std::vector< void * >	d_regrid_hierarchy_callback_ctxs

Static Protected Attributes
static const std::string	SYNCH_CURRENT_DATA_ALG

static const std::string	SYNCH_NEW_DATA_ALG

Private Types
using	RefineAlgorithmMap = std::map< std::string, SAMRAI::tbox::Pointer< SAMRAI::xfer::RefineAlgorithm< NDIM > > >

using	RefinePatchStrategyMap = std::map< std::string, std::unique_ptr< SAMRAI::xfer::RefinePatchStrategy< NDIM > > >

using	RefineScheduleMap = std::map< std::string, std::vector< SAMRAI::tbox::Pointer< SAMRAI::xfer::RefineSchedule< NDIM > > > >

using	CoarsenAlgorithmMap = std::map< std::string, SAMRAI::tbox::Pointer< SAMRAI::xfer::CoarsenAlgorithm< NDIM > > >

using	CoarsenPatchStrategyMap = std::map< std::string, std::unique_ptr< SAMRAI::xfer::CoarsenPatchStrategy< NDIM > > >

using	CoarsenScheduleMap = std::map< std::string, std::vector< SAMRAI::tbox::Pointer< SAMRAI::xfer::CoarsenSchedule< NDIM > > > >

Private Member Functions
	AdvDiffSemiImplicitHierarchyIntegrator ()=delete
	Default constructor. More...

	AdvDiffSemiImplicitHierarchyIntegrator (const AdvDiffSemiImplicitHierarchyIntegrator &from)=delete
	Copy constructor. More...

AdvDiffSemiImplicitHierarchyIntegrator &	operator= (const AdvDiffSemiImplicitHierarchyIntegrator &that)=delete
	Assignment operator. More...

void	getFromInput (SAMRAI::tbox::Pointer< SAMRAI::tbox::Database > db, bool is_from_restart)

void	getFromRestart ()

Detailed Description

Each quantity \( Q \) managed by the integrator may have a unique diffusion coefficient \( \kappa \) and damping coefficient \( \lambda \), and may optionally have a forcing term \( F \). Additionally, a different advection velocity may be used with each quantity registered with the integrator.

This hierarchy integrator advances all levels of the patch hierarchy synchronously in time. In particular, subcycling in time is not performed.

Various options are available for the spatial and temporal discretizations.

See also: HierarchyIntegrator; SAMRAI::mesh::StandardTagAndInitStrategy; SAMRAI::algs::TimeRefinementIntegrator; SAMRAI::algs::TimeRefinementLevelStrategy

Member Typedef Documentation

◆ ResetPropertiesFcnPtr

using IBAMR::AdvDiffHierarchyIntegrator::ResetPropertiesFcnPtr = void (*)(int property_idx, SAMRAI::tbox::Pointer<IBTK::HierarchyMathOps> hier_math_ops, int integrator_step, double time, bool initial_time, bool regrid_time, void* ctx)

inherited

◆ PreprocessIntegrateHierarchyCallbackFcnPtr

using IBTK::HierarchyIntegrator::PreprocessIntegrateHierarchyCallbackFcnPtr = void (*)(double current_time, double new_time, int num_cycles, void* ctx)

inherited

Callback function specification to enable further specialization of preprocessIntegrateHierarchy().

◆ IntegrateHierarchyCallbackFcnPtr

using IBTK::HierarchyIntegrator::IntegrateHierarchyCallbackFcnPtr = void (*)(double current_time, double new_time, int cycle_num, void* ctx)

inherited

Callback function specification to enable further specialization of integrateHierarchy().

◆ PostprocessIntegrateHierarchyCallbackFcnPtr

using IBTK::HierarchyIntegrator::PostprocessIntegrateHierarchyCallbackFcnPtr = void (*)(double current_time, double new_time, bool skip_synchronize_new_state_data, int num_cycles, void* ctx)

inherited

Callback function specification to enable further specialization of postprocessIntegrateHierarchy().

◆ ApplyGradientDetectorCallbackFcnPtr

using IBTK::HierarchyIntegrator::ApplyGradientDetectorCallbackFcnPtr = void (*)(SAMRAI::tbox::Pointer<SAMRAI::hier::BasePatchHierarchy<NDIM> > hierarchy, int level_number, double error_data_time, int tag_index, bool initial_time, bool uses_richardson_extrapolation_too, void* ctx)

inherited

Callback function specification to enable further specialization of applyGradientDetector().

◆ RegridHierarchyCallbackFcnPtr

using IBTK::HierarchyIntegrator::RegridHierarchyCallbackFcnPtr = void (*)(SAMRAI::tbox::Pointer<SAMRAI::hier::BasePatchHierarchy<NDIM> > hierarchy, double data_time, bool initial_time, void* ctx)

inherited

Callback function specification to enable further specialization of regridHierarchy().

◆ RefineAlgorithmMap

using IBTK::HierarchyIntegrator::RefineAlgorithmMap = std::map<std::string, SAMRAI::tbox::Pointer<SAMRAI::xfer::RefineAlgorithm<NDIM> > >

privateinherited

◆ RefinePatchStrategyMap

using IBTK::HierarchyIntegrator::RefinePatchStrategyMap = std::map<std::string, std::unique_ptr<SAMRAI::xfer::RefinePatchStrategy<NDIM> > >

privateinherited

◆ RefineScheduleMap

using IBTK::HierarchyIntegrator::RefineScheduleMap = std::map<std::string, std::vector<SAMRAI::tbox::Pointer<SAMRAI::xfer::RefineSchedule<NDIM> > > >

privateinherited

◆ CoarsenAlgorithmMap

using IBTK::HierarchyIntegrator::CoarsenAlgorithmMap = std::map<std::string, SAMRAI::tbox::Pointer<SAMRAI::xfer::CoarsenAlgorithm<NDIM> > >

privateinherited

◆ CoarsenPatchStrategyMap

using IBTK::HierarchyIntegrator::CoarsenPatchStrategyMap = std::map<std::string, std::unique_ptr<SAMRAI::xfer::CoarsenPatchStrategy<NDIM> > >

privateinherited

◆ CoarsenScheduleMap

using IBTK::HierarchyIntegrator::CoarsenScheduleMap = std::map<std::string, std::vector<SAMRAI::tbox::Pointer<SAMRAI::xfer::CoarsenSchedule<NDIM> > > >

privateinherited

Constructor & Destructor Documentation

◆ AdvDiffSemiImplicitHierarchyIntegrator() [1/3]

IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::AdvDiffSemiImplicitHierarchyIntegrator	(	const std::string &	object_name,
		SAMRAI::tbox::Pointer< SAMRAI::tbox::Database >	input_db,
		bool	register_for_restart = `true`
	)

The constructor for class AdvDiffSemiImplicitHierarchyIntegrator sets some default values, reads in configuration information from input and restart databases, and registers the integrator object with the restart manager when requested.

◆ ~AdvDiffSemiImplicitHierarchyIntegrator()

IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::~AdvDiffSemiImplicitHierarchyIntegrator ( )

default

The destructor for class AdvDiffSemiImplicitHierarchyIntegrator unregisters the integrator object with the restart manager when the object is so registered.

◆ AdvDiffSemiImplicitHierarchyIntegrator() [2/3]

IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::AdvDiffSemiImplicitHierarchyIntegrator ( )

privatedelete

Note: This constructor is not implemented and should not be used.

◆ AdvDiffSemiImplicitHierarchyIntegrator() [3/3]

IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::AdvDiffSemiImplicitHierarchyIntegrator ( const AdvDiffSemiImplicitHierarchyIntegrator & from )

privatedelete

Note: This constructor is not implemented and should not be used.

Parameters

from	The value to copy to this object.

Member Function Documentation

◆ setDefaultConvectiveTimeSteppingType()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::setDefaultConvectiveTimeSteppingType ( TimeSteppingType default_convective_time_stepping_type )

Set the default convective time stepping method to use with registered quantities.

◆ getDefaultConvectiveTimeSteppingType()

TimeSteppingType IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::getDefaultConvectiveTimeSteppingType ( ) const

Get the default convective time stepping method being used with registered quantities.

◆ setDefaultInitialConvectiveTimeSteppingType()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::setDefaultInitialConvectiveTimeSteppingType ( TimeSteppingType default_init_convective_time_stepping_type )

Set the default convective time stepping method used during the initial time step.

Note: This is used only when the basic convective time stepping scheme uses a multi-step method such as Adams-Bashforth.

◆ getDefaultInitialConvectiveTimeSteppingType()

TimeSteppingType IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::getDefaultInitialConvectiveTimeSteppingType ( ) const

Return the default convective time stepping method used during the initial time step.

Note: This is used only when the basic convective time stepping scheme uses a multi-step method such as Adams-Bashforth.

◆ setDefaultConvectiveOperatorType()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::setDefaultConvectiveOperatorType ( const std::string & op_type )

◆ getDefaultConvectiveOperatorType()

const std::string& IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::getDefaultConvectiveOperatorType ( ) const

◆ setDefaultConvectiveOperatorInputDatabase()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::setDefaultConvectiveOperatorInputDatabase ( SAMRAI::tbox::Pointer< SAMRAI::tbox::Database > input_db )

◆ getDefaultConvectiveOperatorInputDatabase()

SAMRAI::tbox::Pointer<SAMRAI::tbox::Database> IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::getDefaultConvectiveOperatorInputDatabase ( ) const

◆ registerTransportedQuantity()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::registerTransportedQuantity	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		const bool	Q_output = `true`
	)

overridevirtual

Register a cell-centered quantity to be advected and diffused by the hierarchy integrator. Can optionally turn off outputting the quantity.

Data management for the registered quantity will be handled by the hierarchy integrator.

Reimplemented from IBAMR::AdvDiffHierarchyIntegrator.

Reimplemented in IBAMR::BrinkmanAdvDiffSemiImplicitHierarchyIntegrator.

◆ setConvectiveTimeSteppingType()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::setConvectiveTimeSteppingType	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		TimeSteppingType	convective_time_stepping_type
	)

Set the convective time stepping method to use for a particular transported quantity Q.

◆ getConvectiveTimeSteppingType()

TimeSteppingType IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::getConvectiveTimeSteppingType ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

Get the convective time stepping method being used for a particular transported quantity Q.

◆ setInitialConvectiveTimeSteppingType()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::setInitialConvectiveTimeSteppingType	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		TimeSteppingType	init_convective_time_stepping_type
	)

Set the convective time stepping method used during the initial time step for a particular transported quantity Q.

Note: This is used only when the basic convective time stepping scheme uses a multi-step method such as Adams-Bashforth.

◆ getInitialConvectiveTimeSteppingType()

TimeSteppingType IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::getInitialConvectiveTimeSteppingType ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

Return the convective time stepping method used during the initial time step for a particular transported quantity Q.

Note: This is used only when the basic convective time stepping scheme uses a multi-step method such as Adams-Bashforth.

◆ setConvectiveOperatorType()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::setConvectiveOperatorType	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		const std::string &	op_type
	)

◆ getConvectiveOperatorType()

const std::string& IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::getConvectiveOperatorType ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

◆ setConvectiveOperatorInputDatabase()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::setConvectiveOperatorInputDatabase	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		SAMRAI::tbox::Pointer< SAMRAI::tbox::Database >	input_db
	)

◆ getConvectiveOperatorInputDatabase()

SAMRAI::tbox::Pointer<SAMRAI::tbox::Database> IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::getConvectiveOperatorInputDatabase ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

◆ setConvectiveOperator()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::setConvectiveOperator	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		SAMRAI::tbox::Pointer< ConvectiveOperator >	convective_op
	)

Register an operator to compute the convective derivative term u*grad Q for a particular transported quantity Q.

◆ getConvectiveOperator()

virtual SAMRAI::tbox::Pointer<ConvectiveOperator> IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::getConvectiveOperator ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var )

virtual

Get the convective operator being used by this solver class for a particular transported quantity Q.

If the convective operator has not already been constructed, then this function will initialize a default convective operator.

◆ setConvectiveOperatorsNeedInit()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::setConvectiveOperatorsNeedInit ( )

Indicate that all of the convective operators should be (re-)initialized before the next time step.

◆ setConvectiveOperatorNeedsInit()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::setConvectiveOperatorNeedsInit ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var )

Indicate that the convective operator should be (re-)initialized before the next time step.

◆ initializeHierarchyIntegrator()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::initializeHierarchyIntegrator	(	SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > >	hierarchy,
		SAMRAI::tbox::Pointer< SAMRAI::mesh::GriddingAlgorithm< NDIM > >	gridding_alg
	)

overridevirtual

Initialize the variables, basic communications algorithms, solvers, and other data structures used by this time integrator object.

This method is called automatically by initializePatchHierarchy() prior to the construction of the patch hierarchy. It is also possible for users to make an explicit call to initializeHierarchyIntegrator() prior to calling initializePatchHierarchy().

Reimplemented from IBAMR::AdvDiffHierarchyIntegrator.

Reimplemented in IBAMR::BrinkmanAdvDiffSemiImplicitHierarchyIntegrator.

◆ getNumberOfCycles()

int IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::getNumberOfCycles ( ) const

overridevirtual

Returns the number of cycles to perform for the present time step.

Reimplemented from IBTK::HierarchyIntegrator.

◆ preprocessIntegrateHierarchy()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::preprocessIntegrateHierarchy	(	double	current_time,
		double	new_time,
		int	num_cycles = `1`
	)

overridevirtual

Prepare to advance the data from current_time to new_time.

Reimplemented from IBAMR::AdvDiffHierarchyIntegrator.

Reimplemented in IBAMR::BrinkmanAdvDiffSemiImplicitHierarchyIntegrator.

◆ postprocessIntegrateHierarchy()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::postprocessIntegrateHierarchy	(	double	current_time,
		double	new_time,
		bool	skip_synchronize_new_state_data,
		int	num_cycles = `1`
	)

overridevirtual

Clean up data following call(s) to integrateHierarchy().

Reimplemented from IBTK::HierarchyIntegrator.

Reimplemented in IBAMR::BrinkmanAdvDiffSemiImplicitHierarchyIntegrator.

◆ integrateHierarchySpecialized()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::integrateHierarchySpecialized	(	double	current_time,
		double	new_time,
		int	cycle_num = `0`
	)

overrideprotectedvirtual

Synchronously advance each level in the hierarchy over the given time increment.

Implements IBTK::HierarchyIntegrator.

Reimplemented in IBAMR::BrinkmanAdvDiffSemiImplicitHierarchyIntegrator.

◆ resetHierarchyConfigurationSpecialized()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::resetHierarchyConfigurationSpecialized	(	SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > >	hierarchy,
		int	coarsest_level,
		int	finest_level
	)

overrideprotectedvirtual

Reset cached hierarchy dependent data.

Reimplemented from IBAMR::AdvDiffHierarchyIntegrator.

◆ putToDatabaseSpecialized()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::putToDatabaseSpecialized ( SAMRAI::tbox::Pointer< SAMRAI::tbox::Database > db )

overrideprotectedvirtual

Write out specialized object state to the given database.

Reimplemented from IBAMR::AdvDiffHierarchyIntegrator.

◆ operator=()

AdvDiffSemiImplicitHierarchyIntegrator& IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::operator= ( const AdvDiffSemiImplicitHierarchyIntegrator & that )

privatedelete

Note: This operator is not implemented and should not be used.

Parameters

that	The value to assign to this object.

Returns: A reference to this object.

◆ getFromInput()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::getFromInput	(	SAMRAI::tbox::Pointer< SAMRAI::tbox::Database >	db,
		bool	is_from_restart
	)

private

Read input values from a given database.

◆ getFromRestart()

void IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::getFromRestart ( )

private

Read object state from the restart file and initialize class data members. The database from which the restart data are read is determined by the object_name specified in the class constructor.

◆ setDefaultDiffusionTimeSteppingType()

void IBAMR::AdvDiffHierarchyIntegrator::setDefaultDiffusionTimeSteppingType ( TimeSteppingType default_diffusion_time_stepping_type )

inherited

Set the default diffusion time stepping method to use with registered quantities.

◆ getDefaultDiffusionTimeSteppingType()

TimeSteppingType IBAMR::AdvDiffHierarchyIntegrator::getDefaultDiffusionTimeSteppingType ( ) const

inherited

Get the default diffusion time stepping method being used with registered quantities.

◆ setDefaultConvectiveDifferencingType()

void IBAMR::AdvDiffHierarchyIntegrator::setDefaultConvectiveDifferencingType ( ConvectiveDifferencingType default_convective_difference_form )

inherited

Set the default convective differencing form to use with registered quantities.

◆ getDefaultConvectiveDifferencingType()

ConvectiveDifferencingType IBAMR::AdvDiffHierarchyIntegrator::getDefaultConvectiveDifferencingType ( ) const

inherited

Get the default convective differencing form being used with registered quantities.

◆ registerAdvectionVelocity()

virtual void IBAMR::AdvDiffHierarchyIntegrator::registerAdvectionVelocity ( SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > > u_var )

virtualinherited

Register a face-centered advection velocity to be used to advect cell-centered quantities by the hierarchy integrator.

Data management for the registered advection velocity will be handled by the hierarchy integrator.

If a function is not provided, it is the responsibility of the user to ensure that the current and new contexts are set correctly.

Note: By default, each registered advection velocity is assumed to be divergence free.

◆ setAdvectionVelocityIsDivergenceFree()

void IBAMR::AdvDiffHierarchyIntegrator::setAdvectionVelocityIsDivergenceFree	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > >	u_var,
		bool	is_div_free
	)

inherited

Indicate whether a particular advection velocity is discretely divergence free.

◆ getAdvectionVelocityIsDivergenceFree()

bool IBAMR::AdvDiffHierarchyIntegrator::getAdvectionVelocityIsDivergenceFree ( SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > > u_var ) const

inherited

Determine whether a particular advection velocity has been indicated to be discretely divergence free.

◆ setAdvectionVelocityFunction()

void IBAMR::AdvDiffHierarchyIntegrator::setAdvectionVelocityFunction	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > >	u_var,
		SAMRAI::tbox::Pointer< IBTK::CartGridFunction >	u_fcn
	)

inherited

Supply an IBTK::CartGridFunction object to specify the value of a particular advection velocity.

If a function is not provided, it is the responsibility of the user to ensure that the current and new contexts are set correctly.

◆ getAdvectionVelocityFunction()

SAMRAI::tbox::Pointer<IBTK::CartGridFunction> IBAMR::AdvDiffHierarchyIntegrator::getAdvectionVelocityFunction ( SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > > u_var ) const

inherited

Get the IBTK::CartGridFunction object being used to specify the value of a particular advection velocity.

◆ registerSourceTerm()

virtual void IBAMR::AdvDiffHierarchyIntegrator::registerSourceTerm	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	F_var,
		const bool	output_F = `true`
	)

virtualinherited

Register a cell-centered source term. Can optionally turn off outputting the source.

Data management for the registered source term will be handled by the hierarchy integrator.

◆ setSourceTermFunction()

void IBAMR::AdvDiffHierarchyIntegrator::setSourceTermFunction	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	F_var,
		SAMRAI::tbox::Pointer< IBTK::CartGridFunction >	F_fcn
	)

inherited

Supply an IBTK::CartGridFunction object to specify the value of a particular source term.

◆ getSourceTermFunction()

SAMRAI::tbox::Pointer<IBTK::CartGridFunction> IBAMR::AdvDiffHierarchyIntegrator::getSourceTermFunction ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > F_var ) const

inherited

Get the IBTK::CartGridFunction object being used to specify the value of a particular source term.

◆ setAdvectionVelocity()

void IBAMR::AdvDiffHierarchyIntegrator::setAdvectionVelocity	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		SAMRAI::tbox::Pointer< SAMRAI::pdat::FaceVariable< NDIM, double > >	u_var
	)

inherited

Set the face-centered advection velocity to be used with a particular cell-centered quantity.

Note: The specified advection velocity must have been already registered with the hierarchy integrator.

◆ getAdvectionVelocity()

SAMRAI::tbox::Pointer<SAMRAI::pdat::FaceVariable<NDIM, double> > IBAMR::AdvDiffHierarchyIntegrator::getAdvectionVelocity ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

inherited

Get the face-centered advection velocity being used with a particular cell-centered quantity.

◆ setSourceTerm()

void IBAMR::AdvDiffHierarchyIntegrator::setSourceTerm	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	F_var
	)

inherited

Set the cell-centered source term to be used with a particular cell-centered quantity.

Note: The specified source term must have been already registered with the hierarchy integrator.

◆ getSourceTerm()

SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> > IBAMR::AdvDiffHierarchyIntegrator::getSourceTerm ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

inherited

Get the cell-centered source term being used with a particular cell-centered quantity.

◆ setDiffusionTimeSteppingType()

void IBAMR::AdvDiffHierarchyIntegrator::setDiffusionTimeSteppingType	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		TimeSteppingType	time_stepping_type
	)

inherited

Set the diffusion time integration scheme for a quantity that has been registered with the hierarchy integrator.

◆ getDiffusionTimeSteppingType()

TimeSteppingType IBAMR::AdvDiffHierarchyIntegrator::getDiffusionTimeSteppingType ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

inherited

Get the diffusion time integration scheme for a quantity that has been registered with the hierarchy integrator.

◆ setConvectiveDifferencingType()

void IBAMR::AdvDiffHierarchyIntegrator::setConvectiveDifferencingType	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		ConvectiveDifferencingType	difference_form
	)

inherited

Set the convective differencing form for a quantity that has been registered with the hierarchy integrator.

◆ getConvectiveDifferencingType()

ConvectiveDifferencingType IBAMR::AdvDiffHierarchyIntegrator::getConvectiveDifferencingType ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

inherited

Get the convective differencing form for a quantity that has been registered with the hierarchy integrator.

◆ setDiffusionCoefficient()

void IBAMR::AdvDiffHierarchyIntegrator::setDiffusionCoefficient	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		double	kappa
	)

inherited

Set the constant scalar diffusion coefficient corresponding to a quantity that has been registered with the hierarchy integrator.

◆ getDiffusionCoefficient()

double IBAMR::AdvDiffHierarchyIntegrator::getDiffusionCoefficient ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

inherited

Get the constant scalar diffusion coefficient corresponding to a quantity that has been registered with the hierarchy integrator.

◆ registerDiffusionCoefficientVariable()

void IBAMR::AdvDiffHierarchyIntegrator::registerDiffusionCoefficientVariable ( SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > > D_var )

inherited

Register a variable scalar diffusion coefficient corresponding to a quantity that has been registered with the hierarchy integrator.

◆ setDiffusionCoefficientFunction()

void IBAMR::AdvDiffHierarchyIntegrator::setDiffusionCoefficientFunction	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > >	D_var,
		SAMRAI::tbox::Pointer< IBTK::CartGridFunction >	D_fcn
	)

inherited

Supply an IBTK:CartGridFunction object to specify the value of a particular variable diffusion coefficient.

◆ getDiffusionCoefficientFunction()

SAMRAI::tbox::Pointer<IBTK::CartGridFunction> IBAMR::AdvDiffHierarchyIntegrator::getDiffusionCoefficientFunction ( SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > > D_var ) const

inherited

Get the IBTK::CartGridFunction object being used to specify the value of a particular variable diffusion coefficient.

◆ setDiffusionCoefficientVariable()

void IBAMR::AdvDiffHierarchyIntegrator::setDiffusionCoefficientVariable	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		SAMRAI::tbox::Pointer< SAMRAI::pdat::SideVariable< NDIM, double > >	D_var
	)

inherited

Set the cell-centered variable diffusion coefficient to be used with a particular cell-centered quantity.

Note: The specified source term must have been already registered with the hierarchy integrator.

◆ getDiffusionCoefficientVariable()

SAMRAI::tbox::Pointer<SAMRAI::pdat::SideVariable<NDIM, double> > IBAMR::AdvDiffHierarchyIntegrator::getDiffusionCoefficientVariable ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

inherited

Get the cell-centered variable diffusion coefficient being used with a particular cell-centered quantity.

◆ isDiffusionCoefficientVariable()

bool IBAMR::AdvDiffHierarchyIntegrator::isDiffusionCoefficientVariable ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

inherited

◆ setDampingCoefficient()

void IBAMR::AdvDiffHierarchyIntegrator::setDampingCoefficient	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		double	lambda
	)

inherited

Set the scalar linear damping coefficient corresponding to a quantity that has been registered with the hierarchy integrator.

◆ getDampingCoefficient()

double IBAMR::AdvDiffHierarchyIntegrator::getDampingCoefficient ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

inherited

Get the scalar linear damping coefficient corresponding to a quantity that has been registered with the hierarchy integrator.

◆ setInitialConditions()

void IBAMR::AdvDiffHierarchyIntegrator::setInitialConditions	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		SAMRAI::tbox::Pointer< IBTK::CartGridFunction >	Q_init
	)

inherited

Set a grid function to provide initial conditions for a quantity that has been registered with the hierarchy integrator.

◆ getInitialConditions()

SAMRAI::tbox::Pointer<IBTK::CartGridFunction> IBAMR::AdvDiffHierarchyIntegrator::getInitialConditions ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

inherited

Get the grid function being used to provide initial conditions for a quantity that has been registered with the hierarchy integrator.

◆ setPhysicalBcCoef()

void IBAMR::AdvDiffHierarchyIntegrator::setPhysicalBcCoef	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		SAMRAI::solv::RobinBcCoefStrategy< NDIM > *	Q_bc_coef
	)

inherited

Set an object to provide boundary conditions for a scalar-valued quantity that has been registered with the hierarchy integrator.

See also: IBTK::muParserRobinBcCoefs

◆ setPhysicalBcCoefs()

void IBAMR::AdvDiffHierarchyIntegrator::setPhysicalBcCoefs	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		const std::vector< SAMRAI::solv::RobinBcCoefStrategy< NDIM > * > &	Q_bc_coef
	)

inherited

Set objects to provide boundary conditions for a vector-valued quantity that has been registered with the hierarchy integrator.

See also: IBTK::muParserRobinBcCoefs

◆ getPhysicalBcCoefs()

std::vector<SAMRAI::solv::RobinBcCoefStrategy<NDIM>*> IBAMR::AdvDiffHierarchyIntegrator::getPhysicalBcCoefs ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

inherited

Get objects used to provide boundary conditions for a scalar- or vector-valued quantity that has been registered with the hierarchy integrator.

◆ setHelmholtzSolver()

void IBAMR::AdvDiffHierarchyIntegrator::setHelmholtzSolver	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		SAMRAI::tbox::Pointer< IBTK::PoissonSolver >	helmholtz_solver
	)

inherited

Register a solver for the Helmholtz equation (time-discretized diffusion equation).

◆ getHelmholtzSolver()

SAMRAI::tbox::Pointer<IBTK::PoissonSolver> IBAMR::AdvDiffHierarchyIntegrator::getHelmholtzSolver ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var )

inherited

Get the solver for the Helmholtz equation (time-discretized diffusion equation) used by this solver class.

◆ setHelmholtzSolversNeedInit()

void IBAMR::AdvDiffHierarchyIntegrator::setHelmholtzSolversNeedInit ( )

inherited

Indicate that all of the Helmholtz solvers should be (re-)initialized before the next time step.

◆ setHelmholtzSolverNeedsInit()

void IBAMR::AdvDiffHierarchyIntegrator::setHelmholtzSolverNeedsInit ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var )

inherited

Indicate that the Helmholtz solver should be (re-)initialized before the next time step.

◆ setHelmholtzRHSOperator()

void IBAMR::AdvDiffHierarchyIntegrator::setHelmholtzRHSOperator	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		SAMRAI::tbox::Pointer< IBTK::LaplaceOperator >	helmholtz_rhs_operator
	)

inherited

Register an operator to use to evaluate the right-hand side for the Helmholtz solver (time-discretized diffusion equation).

◆ getHelmholtzRHSOperator()

SAMRAI::tbox::Pointer<IBTK::LaplaceOperator> IBAMR::AdvDiffHierarchyIntegrator::getHelmholtzRHSOperator ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var )

inherited

Get the operator to use to evaluate the right-hand side for the Helmholtz solver (time-discretized diffusion equation).

◆ setHelmholtzRHSOperatorsNeedInit()

void IBAMR::AdvDiffHierarchyIntegrator::setHelmholtzRHSOperatorsNeedInit ( )

inherited

Indicate that all of the operators to evaluate the right-hand side for the Helmholtz solver should be (re-)initialized before the next time step.

◆ setHelmholtzRHSOperatorNeedsInit()

void IBAMR::AdvDiffHierarchyIntegrator::setHelmholtzRHSOperatorNeedsInit ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var )

inherited

Indicate that the operator to evaluate the right-hand side for the Helmholtz solver should be (re-)initialized before the next time step.

◆ registerResetFunction()

void IBAMR::AdvDiffHierarchyIntegrator::registerResetFunction	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		ResetPropertiesFcnPtr	callback,
		void *	ctx
	)

inherited

◆ setResetPriority()

void IBAMR::AdvDiffHierarchyIntegrator::setResetPriority	(	SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > >	Q_var,
		int	priority
	)

inherited

Note: Variables will be reset sequentially according to their priority, from lowest to highest. The reset functions registered to each variable will be called according to the order in which they were registered. If no priority is set for a variable, its reset functions will be called after those with priority, in no particular order.

◆ getResetFunctions()

std::vector<ResetPropertiesFcnPtr> IBAMR::AdvDiffHierarchyIntegrator::getResetFunctions ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

inherited

◆ getResetPriority()

int IBAMR::AdvDiffHierarchyIntegrator::getResetPriority ( SAMRAI::tbox::Pointer< SAMRAI::pdat::CellVariable< NDIM, double > > Q_var ) const

inherited

◆ getMaximumTimeStepSizeSpecialized()

double IBAMR::AdvDiffHierarchyIntegrator::getMaximumTimeStepSizeSpecialized ( )

overrideprotectedvirtualinherited

Return the maximum stable time step size.

Reimplemented from IBTK::HierarchyIntegrator.

Reimplemented in IBAMR::AdvDiffPredictorCorrectorHierarchyIntegrator.

◆ initializeCompositeHierarchyDataSpecialized()

void IBAMR::AdvDiffHierarchyIntegrator::initializeCompositeHierarchyDataSpecialized	(	double	init_data_time,
		bool	initial_time
	)

overrideprotectedvirtualinherited

Initialize composite hierarchy data.

The method initializes variables that may require the full grid hierarchy to be already created.

Reimplemented from IBTK::HierarchyIntegrator.

◆ registerVariables()

void IBAMR::AdvDiffHierarchyIntegrator::registerVariables ( )

protectedinherited

Standard variable registration.

◆ getName()

const std::string& IBTK::HierarchyIntegrator::getName ( ) const

inherited

Return the name of the hierarchy integrator object.

◆ initializePatchHierarchy()

virtual void IBTK::HierarchyIntegrator::initializePatchHierarchy	(	SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > >	hierarchy,
		SAMRAI::tbox::Pointer< SAMRAI::mesh::GriddingAlgorithm< NDIM > >	gridding_alg
	)

virtualinherited

Initialize the AMR patch hierarchy and data defined on the hierarchy at the start of a computation. If the computation is begun from a restart file, the patch hierarchy and patch data are read from the hierarchy database. Otherwise, the patch hierarchy and patch data are initialized by the gridding algorithm associated with the integrator object.

The implementation of this function assumes that the hierarchy exists upon entry to the function, but that it contains no patch levels. On return from this function, the state of the integrator object will be such that it is possible to step through time via the advanceHierarchy() function.

Reimplemented in IBAMR::IBHierarchyIntegrator, IBAMR::INSVCStaggeredHierarchyIntegrator, IBAMR::INSStaggeredHierarchyIntegrator, IBAMR::INSCollocatedHierarchyIntegrator, IBAMR::IBExplicitHierarchyIntegrator, IBAMR::INSVCStaggeredNonConservativeHierarchyIntegrator, and IBAMR::INSVCStaggeredConservativeHierarchyIntegrator.

◆ advanceHierarchy()

virtual void IBTK::HierarchyIntegrator::advanceHierarchy ( double dt )

virtualinherited

Integrate data on all patches on all levels of the patch hierarchy over the specified time increment.

◆ getMinimumTimeStepSize()

double IBTK::HierarchyIntegrator::getMinimumTimeStepSize ( )

inherited

Return the current value of the minimum time step size for the integrator object.

Subclasses can control the method used to determined the time step size by overriding the protected virtual member function getMinimumTimeStepSizeSpecialized().

◆ getMaximumTimeStepSize()

double IBTK::HierarchyIntegrator::getMaximumTimeStepSize ( )

inherited

Return the current value of the maximum time step size for the integrator object.

Subclasses can control the method used to determined the time step size by overriding the protected virtual member function getMaximumTimeStepSizeSpecialized().

◆ synchronizeHierarchyData()

void IBTK::HierarchyIntegrator::synchronizeHierarchyData ( VariableContextType ctx_type )

inherited

Synchronize data defined on the grid hierarchy.

Subclasses can control the method used to synchronize data on the grid hierarchy by overriding the protected virtual member function synchronizeHierarchyDataSpecialized().

◆ resetTimeDependentHierarchyData()

void IBTK::HierarchyIntegrator::resetTimeDependentHierarchyData ( double new_time )

inherited

Reset the current data to equal the new data, update the time level of the current data, and deallocate the scratch and new data.

Subclasses can control the method used to reset data on the grid hierarchy by overriding the protected virtual member function resetTimeDependentHierarchyDataSpecialized().

◆ resetIntegratorToPreadvanceState()

void IBTK::HierarchyIntegrator::resetIntegratorToPreadvanceState ( )

inherited

Reset the hierarchy integrator to the state at the beginning of the current time step.

Subclasses can control the method used to reset data on the grid hierarchy by overriding the protected virtual member function resetTimeDependentHierarchyDataSpecialized().

◆ regridHierarchy()

virtual void IBTK::HierarchyIntegrator::regridHierarchy ( )

virtualinherited

Virtual method to regrid the patch hierarchy.

A default implementation is provided that calls GriddingAlgorithm::regidAllFinerLevels() to regrid the patch hierarchy. Subclasses can control the method used to regrid the patch hierarchy by overriding this public virtual member function.

Before regridding, this method calls regridHierarchyBeginSpecialized() on the current integrator and all child integrators.

After regridding and (optionally) checking the new grid volume, this method calls regridHierarchyEndSpecialized() on the current integrator and all child integrators. It then calls the following methods (and, therefore, the specialized methods on the current and all child integrators) in the following order:

initializeCompositeHierarchyData
synchronizeHierarchyData

Warning: This class assumes, but does not enforce, that this method is only called on the parent integrator. A future release of IBAMR will enforce this assumption.

◆ atRegridPoint()

bool IBTK::HierarchyIntegrator::atRegridPoint ( ) const

inherited

Return a boolean value that indicates whether regridding should occur at the current time step.

Subclasses can control the method used to trigger adaptive regridding by overriding the protected virtual member function atRegridPointSpecialized().

◆ getIntegratorTime()

double IBTK::HierarchyIntegrator::getIntegratorTime ( ) const

inherited

Return the current integration time.

◆ getStartTime()

double IBTK::HierarchyIntegrator::getStartTime ( ) const

inherited

Return the initial integration time.

◆ getEndTime()

double IBTK::HierarchyIntegrator::getEndTime ( ) const

inherited

Return the final integration time.

◆ getIntegratorStep()

int IBTK::HierarchyIntegrator::getIntegratorStep ( ) const

inherited

Return the number of time steps taken by the integrator.

◆ getMaxIntegratorSteps()

int IBTK::HierarchyIntegrator::getMaxIntegratorSteps ( ) const

inherited

Return the maximum number of time steps allowed by the integrator.

◆ stepsRemaining()

bool IBTK::HierarchyIntegrator::stepsRemaining ( ) const

inherited

Return true if any time steps remain, false otherwise.

◆ updateWorkloadEstimates()

void IBTK::HierarchyIntegrator::updateWorkloadEstimates ( )

inherited

Update workload estimates on each level of the patch hierarchy. Does nothing unless a load balancer has previously been attached via HierarchyIntegrator::register_load_balancer. This function is usually called immediately before regridding so that, should a load balancer be registered with the current class, that load balancer can distribute patches in a way that gives each processor a roughly equal amount of work (instead of simply an equal number of cells).

If you want to visualize the workload then you will have to ensure that workload estimates are recomputed after regridding (by default they are not). This is because workload estimates are only used when moving data between processors: they are computed immediately before the domain is repartitioned and, therefore, their patch data is always invalid at points where output is written. The easiest way to get around this is to enable logging (which will result in workload estimates being updated after regridding) or to manually call updateWorkloadEstimates at points where output is written. The former is more efficient since most applications regrid less frequently than they write visualization files.

Once the data is available, it can be attached to the visit data writer in the usual way. Here is one way to do set this up at the same time the visit data writer is registered:

Pointer<VisItDataWriter<NDIM> > visit_data_writer = app_initializer->getVisItDataWriter();
if (uses_visit)
{
    time_integrator->registerVisItDataWriter(visit_data_writer);
    // This is only valid if a load balancer has previously been attached
    // to the time integrator or, should it exist, its parent integrator;
    // otherwise no workload estimates are computed
    visit_data_writer->registerPlotQuantity("workload", "SCALAR",
                                            time_integrator->getWorkloadDataIndex());
}

Note: This function computes workloads by setting the estimated work value on all cells to 1 and then calling addWorkloadEstimate on the current object and on each child hierarchy integrator.; The workload estimate itself is stored in the variable with index HierarchyIntegrator::d_workload_idx.

@seealso HierarchyIntegrator::getWorkloadDataIndex()

◆ getPatchHierarchy()

SAMRAI::tbox::Pointer<SAMRAI::hier::PatchHierarchy<NDIM> > IBTK::HierarchyIntegrator::getPatchHierarchy ( ) const

inherited

Return a pointer to the patch hierarchy managed by the integrator.

◆ getGriddingAlgorithm()

SAMRAI::tbox::Pointer<SAMRAI::mesh::GriddingAlgorithm<NDIM> > IBTK::HierarchyIntegrator::getGriddingAlgorithm ( ) const

inherited

Return a pointer to the gridding algorithm object managed by the integrator.

◆ registerLoadBalancer()

virtual void IBTK::HierarchyIntegrator::registerLoadBalancer ( SAMRAI::tbox::Pointer< SAMRAI::mesh::LoadBalancer< NDIM > > load_balancer )

virtualinherited

Register a load balancer for non-uniform load balancing.

Note: inheriting classes may reimplement this method in such a way that load_balancer is registered with another object; e.g., IBHierarchyIntegrator passes load_balancer to its IBStrategy object. It will still usually be necessary to call HierarchyIntegrator::registerLoadBalancer at the beginning top of such overloaded functions.; If it does not already exist, calling this function will also register a cell variable for containing workload estimates (and subsequently register that variable with the load balancer): The variable index is d_workload_idx. All inheriting classes assume that this is the cell variable associated with workload estimates and will write their own data into these arrays.

Reimplemented in IBAMR::IBHierarchyIntegrator.

◆ getWorkloadDataIndex()

int IBTK::HierarchyIntegrator::getWorkloadDataIndex ( ) const

inherited

Return the workload variable's patch data index. If the workload variable has not yet been set up by this object (or, should it exist, this object's parent hierarchy integrator) then IBTK::invalid_index is returned instead.

Note: this is only implemented since this information is not readily available from the variable database and there is no other way to access this variable. The main use of this variable is for optionally adding the workload estimates to the VisIt data writer.

◆ registerVisItDataWriter()

void IBTK::HierarchyIntegrator::registerVisItDataWriter ( SAMRAI::tbox::Pointer< SAMRAI::appu::VisItDataWriter< NDIM > > visit_writer )

inherited

Register a VisIt data writer so the integrator can output data files that may be postprocessed with the VisIt visualization tool.

◆ getVisItDataWriter()

SAMRAI::tbox::Pointer<SAMRAI::appu::VisItDataWriter<NDIM> > IBTK::HierarchyIntegrator::getVisItDataWriter ( ) const

inherited

Get a pointer to the VisIt data writer registered with the solver.

◆ setupPlotData()

void IBTK::HierarchyIntegrator::setupPlotData ( )

inherited

Prepare variables for plotting.

Subclasses can control the method used to setup plot data by overriding the protected virtual member function setupPlotData().

Note: Subclasses are allowed to require that this function be called immediately before writing visualization data.

◆ getCurrentCycleNumber()

virtual int IBTK::HierarchyIntegrator::getCurrentCycleNumber ( ) const

virtualinherited

Virtual method to return the current cycle number within the present time step.

The default implementation returns a value of -1 when it is not advancing the hierarchy.

◆ getCurrentTimeStepSize()

virtual double IBTK::HierarchyIntegrator::getCurrentTimeStepSize ( ) const

virtualinherited

Virtual method to return the current time step size.

The default implementation returns the value numeric_limits<>::quiet_NaN() when it is not advancing the hierarchy.

◆ integrateHierarchy()

void IBTK::HierarchyIntegrator::integrateHierarchy	(	double	current_time,
		double	new_time,
		int	cycle_num = `0`
	)

inherited

Advance data from current_time to new_time. The current implementation calls doIntegrateHierarchy() followed by executeIntegrateHierarchyCallbackFcns().

◆ skipCycle()

void IBTK::HierarchyIntegrator::skipCycle	(	double	current_time,
		double	new_time,
		int	cycle_num = `0`
	)

inherited

Method to skip a cycle of the time integration scheme (e.g. for cases in which time integration is handled by another class).

◆ registerPreprocessIntegrateHierarchyCallback()

void IBTK::HierarchyIntegrator::registerPreprocessIntegrateHierarchyCallback	(	PreprocessIntegrateHierarchyCallbackFcnPtr	callback,
		void *	ctx = `nullptr`
	)

inherited

Register a callback function to enable further specialization of preprocessIntegrateHierarchy().

◆ registerIntegrateHierarchyCallback()

void IBTK::HierarchyIntegrator::registerIntegrateHierarchyCallback	(	IntegrateHierarchyCallbackFcnPtr	callback,
		void *	ctx = `nullptr`
	)

inherited

Register a callback function to enable further specialization of integrateHierarchy().

◆ registerPostprocessIntegrateHierarchyCallback()

void IBTK::HierarchyIntegrator::registerPostprocessIntegrateHierarchyCallback	(	PostprocessIntegrateHierarchyCallbackFcnPtr	callback,
		void *	ctx = `nullptr`
	)

inherited

Register a callback function to enable further specialization of postprocessIntegrateHierarchy().

◆ registerApplyGradientDetectorCallback()

void IBTK::HierarchyIntegrator::registerApplyGradientDetectorCallback	(	ApplyGradientDetectorCallbackFcnPtr	callback,
		void *	ctx = `nullptr`
	)

inherited

Register a callback function to enable further specialization of applyGradientDetector().

◆ registerRegridHierarchyCallback()

void IBTK::HierarchyIntegrator::registerRegridHierarchyCallback	(	RegridHierarchyCallbackFcnPtr	,
		void *	ctx = `nullptr`
	)

inherited

Register a callback function to enable further specialization of regridHierarchy().

Note: This function will be called after all data owned by the hierarchy is initialized and set, but before the data is synchronized. If data owned by the integrator is used in this function, it should be synchronized prior to use by an appropriate coarsening operation.

◆ initializeCompositeHierarchyData()

void IBTK::HierarchyIntegrator::initializeCompositeHierarchyData	(	double	init_data_time,
		bool	initial_time
	)

inherited

Perform data initialization after the entire hierarchy has been constructed.

◆ initializeLevelData() [1/2]

void IBTK::HierarchyIntegrator::initializeLevelData	(	SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > >	hierarchy,
		int	level_number,
		double	init_data_time,
		bool	can_be_refined,
		bool	initial_time,
		SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchLevel< NDIM > >	old_level = `SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchLevel< NDIM > >(nullptr)`,
		bool	allocate_data = `true`
	)

overrideinherited

Implementations of functions declared in the SAMRAI::mesh::StandardTagAndInitStrategy abstract base class.

Initialize data on a new level after it is inserted into an AMR patch hierarchy by the gridding algorithm.

Note: Subclasses should not override the implementation of this function provided by class HierarchyIntegrator. Instead, they should override the protected virtual member function initializeLevelDataSpecialized().

See also: SAMRAI::mesh::StandardTagAndInitStrategy::initializeLevelData

◆ initializeLevelData() [2/2]

virtual void SAMRAI::mesh::StandardTagAndInitStrategy< DIM >::initializeLevelData	(	const tbox::Pointer< hier::BasePatchHierarchy< DIM > >	hierarchy,
		const int	level_number,
		const double	init_data_time,
		const bool	can_be_refined,
		const bool	initial_time,
		const tbox::Pointer< hier::BasePatchLevel< DIM > >	old_level = `tbox::Pointer< hier::BasePatchLevel<DIM> >(NULL)`,
		const bool	allocate_data = `true`
	)

pure virtualinherited

Initialize data on a new level after it is inserted into an AMR patch hierarchy by the gridding algorithm. The level number indicates that of the new level.

Generally, when data is set, it is interpolated from coarser levels in the hierarchy. If the old level pointer in the argument list is non-null, then data is copied from the old level to the new level on regions of intersection between those levels before interpolation occurs. In this case, the level number must match that of the old level. The specific operations that occur when initializing level data are determined by the particular solution methods in use; i.e., in the subclass of this abstract base class.

The boolean argument initial_time indicates whether the level is being introduced for the first time (i.e., at initialization time), or after some regrid process during the calculation beyond the initial hierarchy construction. This information is provided since the initialization of the data may be different in each of those circumstances. The can_be_refined boolean argument indicates whether the level is the finest allowable level in the hierarchy.

◆ resetHierarchyConfiguration() [1/2]

void IBTK::HierarchyIntegrator::resetHierarchyConfiguration	(	SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > >	hierarchy,
		int	coarsest_level,
		int	finest_level
	)

overrideinherited

Reset cached hierarchy dependent data.

Note: Subclasses should not override the implementation of this function provided by class HierarchyIntegrator. Instead, they should override the protected virtual member function resetHierarchyConfigurationSpecialized().

See also: SAMRAI::mesh::StandardTagAndInitStrategy::resetHierarchyConfiguration

◆ resetHierarchyConfiguration() [2/2]

virtual void SAMRAI::mesh::StandardTagAndInitStrategy< DIM >::resetHierarchyConfiguration	(	const tbox::Pointer< hier::BasePatchHierarchy< DIM > >	hierarchy,
		const int	coarsest_level,
		const int	finest_level
	)

pure virtualinherited

After hierarchy levels have changed and data has been initialized on the new levels, this routine can be used to reset any information needed by the solution method that is particular to the hierarchy configuration. For example, the solution procedure may cache communication schedules to amortize the cost of data movement on the AMR patch hierarchy. This function will be called by the gridding algorithm after the initialization occurs so that the algorithm-specific subclass can reset such things. Also, if the solution method must make the solution consistent across multiple levels after the hierarchy is changed, this process may be invoked by this routine. Of course the details of these processes are determined by the particular solution methods in use.

The level number arguments indicate the coarsest and finest levels in the current hierarchy configuration that have changed. It should be assumed that all intermediate levels have changed as well.

◆ applyGradientDetector() [1/2]

void IBTK::HierarchyIntegrator::applyGradientDetector	(	SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > >	hierarchy,
		int	level_number,
		double	error_data_time,
		int	tag_index,
		bool	initial_time,
		bool	uses_richardson_extrapolation_too
	)

overrideinherited

Set integer tags to "one" in cells where refinement of the given level should occur according to user-supplied feature detection criteria.

Note: Subclasses should not override the implementation of this function provided by class HierarchyIntegrator. Instead, they should override the protected virtual member function applyGradientDetectorSpecialized().

See also: SAMRAI::mesh::StandardTagAndInitStrategy::applyGradientDetector

◆ applyGradientDetector() [2/2]

virtual void SAMRAI::mesh::StandardTagAndInitStrategy< DIM >::applyGradientDetector	(	const tbox::Pointer< hier::BasePatchHierarchy< DIM > >	hierarchy,
		const int	level_number,
		const double	error_data_time,
		const int	tag_index,
		const bool	initial_time,
		const bool	uses_richardson_extrapolation_too
	)

virtualinherited

Set integer tags to "one" in cells where refinement of the given level should occur according to some user-supplied gradient criteria. The double time argument is the regrid time. The integer "tag_index" argument is the patch descriptor index of the cell-centered integer tag array on each patch in the hierarchy. The boolean argument initial_time indicates whether the level is being subject to refinement at the initial simulation time. If it is false, then the error estimation process is being invoked at some later time after the AMR hierarchy was initially constructed. Typically, this information is passed to the user's patch tagging routines since the error estimator or gradient detector may be different in each case.

The boolean uses_richardson_extrapolation_too is true when Richardson extrapolation error estimation is used in addition to the gradient detector, and false otherwise. This argument helps the user to manage multiple regridding criteria.

This routine is only when gradient detector is being used. It is virtual with an empty implementation here (rather than pure virtual) so that users are not required to provide an implementation when the function is not needed.

◆ getContext()

SAMRAI::tbox::Pointer<SAMRAI::hier::VariableContext> IBTK::HierarchyIntegrator::getContext ( VariableContextType ctx_type ) const

inherited

Routines to access to the variable contexts maintained by the integrator.

Return a pointer the variable context corresponding to the specified variable context type.

◆ getCurrentContext()

SAMRAI::tbox::Pointer<SAMRAI::hier::VariableContext> IBTK::HierarchyIntegrator::getCurrentContext ( ) const

inherited

Return a pointer to the "current" variable context used by integrator. Current data corresponds to state data at the beginning of a time step, or when a new level is initialized.

◆ getNewContext()

SAMRAI::tbox::Pointer<SAMRAI::hier::VariableContext> IBTK::HierarchyIntegrator::getNewContext ( ) const

inherited

Return a pointer to the "new" variable context used by integrator. New data corresponds to advanced state data at the end of a time step. The data is one time step later than the "current" data.

◆ getScratchContext()

SAMRAI::tbox::Pointer<SAMRAI::hier::VariableContext> IBTK::HierarchyIntegrator::getScratchContext ( ) const

inherited

Return a pointer to the "scratch" variable context used by integrator. Scratch data typically corresponds to storage that user-routines in the concrete GodunovAdvector object manipulate; in particular, scratch data contains ghost cells.

◆ getPlotContext()

SAMRAI::tbox::Pointer<SAMRAI::hier::VariableContext> IBTK::HierarchyIntegrator::getPlotContext ( ) const

inherited

Return a pointer to the "plot" variable context used by integrator. Plot data is only read from by the VisItDataWriter and is allocated by setupPlotData() and deallocated by regridHierarchyBegin().

◆ isAllocatedPatchData()

bool IBTK::HierarchyIntegrator::isAllocatedPatchData	(	int	data_idx,
		int	coarsest_ln = `invalid_level_number`,
		int	finest_ln = `invalid_level_number`
	)		const

inherited

Check whether a patch data index corresponds to allocated data over the specified range of patch level numbers.

NOTE: This method will return "false" without error for invalid (i.e., negative) patch data indices.

◆ allocatePatchData()

void IBTK::HierarchyIntegrator::allocatePatchData	(	int	data_idx,
		double	data_time,
		int	coarsest_ln = `invalid_level_number`,
		int	finest_ln = `invalid_level_number`
	)		const

inherited

Allocate a patch data index over the specified range of patch level numbers.

◆ deallocatePatchData()

void IBTK::HierarchyIntegrator::deallocatePatchData	(	int	data_idx,
		int	coarsest_ln = `invalid_level_number`,
		int	finest_ln = `invalid_level_number`
	)		const

inherited

Deallocate a patch data index over the specified range of patch level numbers.

◆ getHierarchyMathOps()

SAMRAI::tbox::Pointer<HierarchyMathOps> IBTK::HierarchyIntegrator::getHierarchyMathOps ( ) const

inherited

Routines to access utility classeses managed by the integrator.

◆ registerVariable() [1/2]

void IBTK::HierarchyIntegrator::registerVariable	(	int &	current_idx,
		int &	new_idx,
		int &	scratch_idx,
		SAMRAI::tbox::Pointer< SAMRAI::hier::Variable< NDIM > >	variable,
		const SAMRAI::hier::IntVector< NDIM > &	scratch_ghosts = `SAMRAI::hier::IntVector< NDIM >(0)`,
		const std::string &	coarsen_name = `"NO_COARSEN"`,
		const std::string &	refine_name = `"NO_REFINE"`,
		SAMRAI::tbox::Pointer< CartGridFunction >	init_fcn = `nullptr`,
		const bool	register_for_restart = `true`
	)

inherited

Routines to register new variables with the integrator.

Register a state variable with the integrator. When a refine operator is specified, the data for the variable are automatically maintained as the patch hierarchy evolves.

All state variables are registered with three contexts: current, new, and scratch. The current context of a state variable is maintained from time step to time step and, if the necessary coarsen and refine operators are specified, as the patch hierarchy evolves.

◆ registerVariable() [2/2]

void IBTK::HierarchyIntegrator::registerVariable	(	int &	idx,
		SAMRAI::tbox::Pointer< SAMRAI::hier::Variable< NDIM > >	variable,
		const SAMRAI::hier::IntVector< NDIM > &	ghosts = `SAMRAI::hier::IntVector< NDIM >(0)`,
		SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext >	ctx = `SAMRAI::tbox::Pointer< SAMRAI::hier::VariableContext >(nullptr)`,
		const bool	register_for_restart = `true`
	)

inherited

Register a variable with the integrator that may not be maintained from time step to time step.

By default, variables are registered with the scratch context, which is deallocated after each time step.

◆ putToDatabase()

void IBTK::HierarchyIntegrator::putToDatabase ( SAMRAI::tbox::Pointer< SAMRAI::tbox::Database > db )

overridevirtualinherited

Implementations of functions declared in the SAMRAI::tbox::Serializable abstract base class.

Write out object state to the given database.

Note: Subclasses should not override the implementation of this function provided by class HierarchyIntegrator. Instead, they should override the protected virtual member function putToDatabaseSpecialized().

Implements SAMRAI::tbox::Serializable.

◆ regridHierarchyBeginSpecialized()

virtual void IBTK::HierarchyIntegrator::regridHierarchyBeginSpecialized ( )

protectedvirtualinherited

Perform any necessary work relevant to data owned by the current integrator prior to regridding (e.g., calculating divergences). An empty default implementation is provided.

Reimplemented in IBAMR::INSVCStaggeredHierarchyIntegrator, IBAMR::INSStaggeredHierarchyIntegrator, IBAMR::IBHierarchyIntegrator, and IBAMR::IBExplicitHierarchyIntegrator.

◆ regridHierarchyEndSpecialized()

virtual void IBTK::HierarchyIntegrator::regridHierarchyEndSpecialized ( )

protectedvirtualinherited

Perform any necessary work relevant to data owned by the current integrator after regridding (e.g., calculating divergences). An empty default implementation is provided.

Reimplemented in IBAMR::INSVCStaggeredHierarchyIntegrator, IBAMR::INSStaggeredHierarchyIntegrator, IBAMR::IBHierarchyIntegrator, and IBAMR::IBExplicitHierarchyIntegrator.

◆ getMinimumTimeStepSizeSpecialized()

virtual double IBTK::HierarchyIntegrator::getMinimumTimeStepSizeSpecialized ( )

protectedvirtualinherited

Virtual method to compute an implementation-specific minimum stable time step size. Implementations should ensure that the returned time step is consistent across all processors.

A default implementation is provided that returns min(dt_max,dt_growth_factor*dt_current). The growth condition prevents excessive changes in the time step size as the computation progresses.

◆ synchronizeHierarchyDataSpecialized()

virtual void IBTK::HierarchyIntegrator::synchronizeHierarchyDataSpecialized ( VariableContextType ctx_type )

protectedvirtualinherited

Virtual method to perform implementation-specific data synchronization.

A default implementation is provided that synchronizes state data registered with the HierarchyIntegrator object using the coarsen operations specified by calls to registerVariable().

◆ resetTimeDependentHierarchyDataSpecialized()

virtual void IBTK::HierarchyIntegrator::resetTimeDependentHierarchyDataSpecialized ( double new_time )

protectedvirtualinherited

Virtual method to perform implementation-specific data reset operations.

A default implementation is provided that first swaps the current and new PatchData pointers, and then deallocates the new and scratch data contexts.

Reimplemented in IBAMR::AdvDiffPredictorCorrectorHierarchyIntegrator.

◆ resetIntegratorToPreadvanceStateSpecialized()

virtual void IBTK::HierarchyIntegrator::resetIntegratorToPreadvanceStateSpecialized ( )

protectedvirtualinherited

Virtual method to perform implementation-specific data reset operations.

A default implementation is provided that deallocates the new and scratch data contexts when data associated with those contexts have been allocated.

Reimplemented in IBAMR::AdvDiffPredictorCorrectorHierarchyIntegrator.

◆ atRegridPointSpecialized()

virtual bool IBTK::HierarchyIntegrator::atRegridPointSpecialized ( ) const

protectedvirtualinherited

Virtual method to provide implementation-specific function to determine whether regridding should occur at the current time step.

A default implementation is provided that indicates that the hierarchy should be regridded at a fixed integer interval of time steps unless a parent integrator has been registered with this integrator. If a parent integrator has been registered with this integrator, atRegridPointSpecialized() returns false, in order to allow the parent integrator to control the timing of regridding.

Reimplemented in IBAMR::IBHierarchyIntegrator.

◆ setupPlotDataSpecialized()

virtual void IBTK::HierarchyIntegrator::setupPlotDataSpecialized ( )

protectedvirtualinherited

Virtual method to perform implementation-specific visualization setup.

An empty default implementation is provided.

Reimplemented in IBAMR::INSVCStaggeredHierarchyIntegrator, IBAMR::INSStaggeredHierarchyIntegrator, IBAMR::INSCollocatedHierarchyIntegrator, IBAMR::INSVCStaggeredConservativeHierarchyIntegrator, and IBAMR::INSVCStaggeredNonConservativeHierarchyIntegrator.

◆ initializeLevelDataSpecialized()

virtual void IBTK::HierarchyIntegrator::initializeLevelDataSpecialized	(	SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > >	hierarchy,
		int	level_number,
		double	init_data_time,
		bool	can_be_refined,
		bool	initial_time,
		SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchLevel< NDIM > >	old_level,
		bool	allocate_data
	)

protectedvirtualinherited

Virtual method to perform implementation-specific data initialization on a new level after it is inserted into an AMR patch hierarchy by the gridding algorithm.

An empty default implementation is provided.

Reimplemented in IBAMR::INSVCStaggeredHierarchyIntegrator, IBAMR::INSStaggeredHierarchyIntegrator, IBAMR::IBHierarchyIntegrator, IBAMR::INSCollocatedHierarchyIntegrator, IBAMR::AdvDiffPredictorCorrectorHierarchyIntegrator, IBAMR::INSVCStaggeredConservativeHierarchyIntegrator, and IBAMR::INSVCStaggeredNonConservativeHierarchyIntegrator.

◆ applyGradientDetectorSpecialized()

virtual void IBTK::HierarchyIntegrator::applyGradientDetectorSpecialized	(	SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > >	hierarchy,
		int	level_number,
		double	error_data_time,
		int	tag_index,
		bool	initial_time,
		bool	uses_richardson_extrapolation_too
	)

protectedvirtualinherited

Virtual method to perform implementation-specific cell tagging operations.

An empty default implementation is provided.

Reimplemented in IBAMR::INSVCStaggeredHierarchyIntegrator, IBAMR::INSStaggeredHierarchyIntegrator, IBAMR::IBHierarchyIntegrator, IBAMR::INSCollocatedHierarchyIntegrator, IBAMR::AdvDiffPredictorCorrectorHierarchyIntegrator, IBAMR::INSVCStaggeredConservativeHierarchyIntegrator, and IBAMR::INSVCStaggeredNonConservativeHierarchyIntegrator.

◆ addWorkloadEstimate()

virtual void IBTK::HierarchyIntegrator::addWorkloadEstimate	(	SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > >	hierarchy,
		const int	workload_data_idx
	)

protectedvirtualinherited

Virtual method to provide implementation-specific workload estimate calculations. This method will be called on each registered child integrator. The intent of this function is that any HierarchyIntegrator object that manages data whose work varies from SAMRAI cell to SAMRAI cell will represent its additional workload by summing estimates into the workload_data_idx variable.

Note: The default version of this function, i.e., HierarchyIntegrator::addWorkloadEstimate(), does nothing.

Reimplemented in IBAMR::IBHierarchyIntegrator.

◆ executePreprocessIntegrateHierarchyCallbackFcns()

virtual void IBTK::HierarchyIntegrator::executePreprocessIntegrateHierarchyCallbackFcns	(	double	current_time,
		double	new_time,
		int	num_cycles
	)

protectedvirtualinherited

Execute any user-specified preprocessIntegrateHierarchy callback functions.

◆ executeIntegrateHierarchyCallbackFcns()

virtual void IBTK::HierarchyIntegrator::executeIntegrateHierarchyCallbackFcns	(	double	current_time,
		double	new_time,
		int	cycle_num
	)

protectedvirtualinherited

Execute any user-specified integrateHierarchy callback functions.

◆ executePostprocessIntegrateHierarchyCallbackFcns()

virtual void IBTK::HierarchyIntegrator::executePostprocessIntegrateHierarchyCallbackFcns	(	double	current_time,
		double	new_time,
		bool	skip_synchronize_new_state_data,
		int	num_cycles
	)

protectedvirtualinherited

Execute any user-specified postprocessIntegrateHierarchy callback functions.

◆ executeApplyGradientDetectorCallbackFcns()

virtual void IBTK::HierarchyIntegrator::executeApplyGradientDetectorCallbackFcns	(	SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > >	hierarchy,
		int	level_number,
		double	error_data_time,
		int	tag_index,
		bool	initial_time,
		bool	uses_richardson_extrapolation_too
	)

protectedvirtualinherited

Execute any user-specified applyGradientDetector callback functions.

◆ executeRegridHierarchyCallbackFcns()

virtual void IBTK::HierarchyIntegrator::executeRegridHierarchyCallbackFcns	(	SAMRAI::tbox::Pointer< SAMRAI::hier::BasePatchHierarchy< NDIM > >	hierarchy,
		double	data_time,
		bool	initial_time
	)

protectedvirtualinherited

Execute any user-specified regridHierarchy callback functions.

◆ registerGhostfillRefineAlgorithm()

void IBTK::HierarchyIntegrator::registerGhostfillRefineAlgorithm	(	const std::string &	name,
		SAMRAI::tbox::Pointer< SAMRAI::xfer::RefineAlgorithm< NDIM > >	ghostfill_alg,
		std::unique_ptr< SAMRAI::xfer::RefinePatchStrategy< NDIM > >	ghostfill_patch_strategy = `nullptr`
	)

protectedinherited

Register a ghost cell-filling refine algorithm.

◆ registerProlongRefineAlgorithm()

void IBTK::HierarchyIntegrator::registerProlongRefineAlgorithm	(	const std::string &	name,
		SAMRAI::tbox::Pointer< SAMRAI::xfer::RefineAlgorithm< NDIM > >	prolong_alg,
		std::unique_ptr< SAMRAI::xfer::RefinePatchStrategy< NDIM > >	prolong_patch_strategy = `nullptr`
	)

protectedinherited

Register a data-prolonging refine algorithm.

◆ registerCoarsenAlgorithm()

void IBTK::HierarchyIntegrator::registerCoarsenAlgorithm	(	const std::string &	name,
		SAMRAI::tbox::Pointer< SAMRAI::xfer::CoarsenAlgorithm< NDIM > >	coarsen_alg,
		std::unique_ptr< SAMRAI::xfer::CoarsenPatchStrategy< NDIM > >	coarsen_patch_strategy = `nullptr`
	)

protectedinherited

Register a coarsen algorithm.

◆ getGhostfillRefineAlgorithm()

SAMRAI::tbox::Pointer<SAMRAI::xfer::RefineAlgorithm<NDIM> > IBTK::HierarchyIntegrator::getGhostfillRefineAlgorithm ( const std::string & name ) const

protectedinherited

Get ghost cell-filling refine algorithm.

◆ getProlongRefineAlgorithm()

SAMRAI::tbox::Pointer<SAMRAI::xfer::RefineAlgorithm<NDIM> > IBTK::HierarchyIntegrator::getProlongRefineAlgorithm ( const std::string & name ) const

protectedinherited

Get data-prolonging refine algorithm.

◆ getCoarsenAlgorithm()

SAMRAI::tbox::Pointer<SAMRAI::xfer::CoarsenAlgorithm<NDIM> > IBTK::HierarchyIntegrator::getCoarsenAlgorithm ( const std::string & name ) const

protectedinherited

Get coarsen algorithm.

◆ getGhostfillRefineSchedules()

const std::vector<SAMRAI::tbox::Pointer<SAMRAI::xfer::RefineSchedule<NDIM> > >& IBTK::HierarchyIntegrator::getGhostfillRefineSchedules ( const std::string & name ) const

protectedinherited

Get ghost cell-filling refine schedules.

◆ getProlongRefineSchedules()

const std::vector<SAMRAI::tbox::Pointer<SAMRAI::xfer::RefineSchedule<NDIM> > >& IBTK::HierarchyIntegrator::getProlongRefineSchedules ( const std::string & name ) const

protectedinherited

Get data-prolonging refine schedules.

Note: These schedules are allocated only for level numbers >= 1.

◆ getCoarsenSchedules()

const std::vector<SAMRAI::tbox::Pointer<SAMRAI::xfer::CoarsenSchedule<NDIM> > >& IBTK::HierarchyIntegrator::getCoarsenSchedules ( const std::string & name ) const

protectedinherited

Get coarsen schedules.

Note: These schedules are allocated only for level numbers >= 1.

◆ registerChildHierarchyIntegrator()

void IBTK::HierarchyIntegrator::registerChildHierarchyIntegrator ( HierarchyIntegrator * child_integrator )

protectedinherited

Register a "child" integrator object with this integrator object.

Note: Multiple child integrator objects may be registered with a single parent integrator object.

◆ registerParentHierarchyIntegrator()

void IBTK::HierarchyIntegrator::registerParentHierarchyIntegrator ( HierarchyIntegrator * parent_integrator )

protectedinherited

Register a "parent" integrator object with this integrator object.

Note: Only a single parent integrator object may be registered with a particular child integrator object.

◆ buildHierarchyMathOps()

SAMRAI::tbox::Pointer<HierarchyMathOps> IBTK::HierarchyIntegrator::buildHierarchyMathOps ( SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > > hierarchy )

protectedinherited

Build the HierarchyMathOps object.

◆ setupTagBuffer()

void IBTK::HierarchyIntegrator::setupTagBuffer ( SAMRAI::tbox::Pointer< SAMRAI::mesh::GriddingAlgorithm< NDIM > > gridding_alg )

protectedinherited

Setup the tag buffer.

◆ regriddingHierarchy()

bool IBTK::HierarchyIntegrator::regriddingHierarchy ( ) const

inlineprotectedinherited

Returns true when we are regridding the patch hierarchy.

◆ atRegridTimeStep()

bool IBTK::HierarchyIntegrator::atRegridTimeStep ( ) const

inlineprotectedinherited

Returns true when we are executing a time step in which a regridding operation was performed.

◆ getLevelDt()

virtual double SAMRAI::mesh::StandardTagAndInitStrategy< DIM >::getLevelDt	(	const tbox::Pointer< hier::BasePatchLevel< DIM > >	level,
		const double	dt_time,
		const bool	initial_time
	)

virtualinherited

Determine time increment to advance data on level. The recompute_dt option specifies whether to compute the timestep using the current level data or to return the value stored by the time integrator. The default true setting means the timestep will be computed if no value is supplied.

This routine is only when Richardson extrapolation is being used. It is virtual with an empty implementation here (rather than pure virtual) so that users are not required to provide an implementation when the function is not needed.

◆ advanceLevel()

virtual double SAMRAI::mesh::StandardTagAndInitStrategy< DIM >::advanceLevel	(	const tbox::Pointer< hier::BasePatchLevel< DIM > >	level,
		const tbox::Pointer< hier::BasePatchHierarchy< DIM > >	hierarchy,
		const double	current_time,
		const double	new_time,
		const bool	first_step,
		const bool	last_step,
		const bool	regrid_advance = `false`
	)

virtualinherited

Advance data on all patches on specified patch level from current time (current_time) to new time (new_time). This routine is called only during time-dependent regridding procedures, such as Richardson extrapolation. It is virtual with an empty implementation here (rather than pure virtual) so that users are not required to provide an implementation when the function is not needed. The boolean arguments are used to determine the state of the algorithm and the data when the advance routine is called. Note that this advance function is also used during normal time integration steps.

When this function is called, the level data required to begin the advance must be allocated and be defined appropriately. Typically, this is equivalent to what is needed to initialize a new level after regridding. Upon exiting this routine, both current and new data may exist on the level. This data is needed until level synchronization occurs, in general. Current and new data may be reset by calling the member function resetTimeDependentData().

This routine is called from two different points within the Richardson exptrapolation process: to advance a temporary level that is coarser than the hierarchy level on which error estimation is performed, and to advance the hierarchy level itself. In the first case, the values of the boolean flags are:

first_step = true.
last_step = true.
regrid_advance = true.

In the second case, the values of the boolean flags are:

first_step (when regridding during time integration sequence) = true when the level is not coarsest level to synchronize immediately before the regridding process; else, false. (when generating initial hierarchy construction) = true, even though there may be multiple advance steps.
last_step = true when the advance is the last in the Richardson extrapolation step sequence; else false.
regrid_advance = true.

◆ resetTimeDependentData()

virtual void SAMRAI::mesh::StandardTagAndInitStrategy< DIM >::resetTimeDependentData	(	const tbox::Pointer< hier::BasePatchLevel< DIM > >	level,
		const double	new_time,
		const bool	can_be_refined
	)

virtualinherited

Reset time-dependent data storage for the specified patch level.

This routine only applies when Richardson extrapolation is being used. It is virtual with an empty implementation here (rather than pure virtual) so that users are not required to provide an implementation when the function is not needed.

◆ resetDataToPreadvanceState()

virtual void SAMRAI::mesh::StandardTagAndInitStrategy< DIM >::resetDataToPreadvanceState ( const tbox::Pointer< hier::BasePatchLevel< DIM > > level )

virtualinherited

Reset data on the patch level by destroying all patch data other than that which is needed to initialize the solution on that level. In other words, this is the data needed to begin a time integration step on the level.

This routine is only when Richardson extrapolation is being used. It is virtual with an empty implementation here (rather than pure virtual) so that users are not required to provide an implementation when the function is not needed.

◆ applyRichardsonExtrapolation()

virtual void SAMRAI::mesh::StandardTagAndInitStrategy< DIM >::applyRichardsonExtrapolation	(	const tbox::Pointer< hier::PatchLevel< DIM > >	level,
		const double	error_data_time,
		const int	tag_index,
		const double	deltat,
		const int	error_coarsen_ratio,
		const bool	initial_time,
		const bool	uses_gradient_detector_too
	)

virtualinherited

Set integer tags to "one" in cells where refinement of the given level should occur according to some user-supplied Richardson extrapolation criteria. The "error_data_time" argument is the regrid time. The "deltat" argument is the time increment to advance the solution on the level to be refined. Note that that level is finer than the level in the argument list, in general. The ratio between the argument level and the actual hierarchy level is given by the integer "coarsen ratio".

The integer "tag_index" argument is the patch descriptor index of the cell-centered integer tag array on each patch in the hierarchy.

The boolean argument initial_time indicates whether the level is being subject to refinement at the initial simulation time. If it is false, then the error estimation process is being invoked at some later time after the AMR hierarchy was initially constructed. Typically, this information is passed to the user's patch tagging routines since the application of the Richardson extrapolation process may be different in each case.

The boolean uses_gradient_detector_too is true when a gradient detector procedure is used in addition to Richardson extrapolation, and false otherwise. This argument helps the user to manage multiple regridding criteria.

This routine is only when Richardson extrapolation is being used. It is virtual with an empty implementation here (rather than pure virtual) so that users are not required to provide an implementation when the function is not needed.

◆ coarsenDataForRichardsonExtrapolation()

virtual void SAMRAI::mesh::StandardTagAndInitStrategy< DIM >::coarsenDataForRichardsonExtrapolation	(	const tbox::Pointer< hier::PatchHierarchy< DIM > >	hierarchy,
		const int	level_number,
		const tbox::Pointer< hier::PatchLevel< DIM > >	coarser_level,
		const double	coarsen_data_time,
		const bool	before_advance
	)

virtualinherited

Coarsen solution data from level to coarse_level for Richardson extrapolation. Note that this routine will be called twice during the Richardson extrapolation error estimation process, once to set data on the coarser level and once to coarsen data from after advancing the fine level. The init_coarse_level boolean argument indicates whether data is set on the coarse level by coarsening the "old" time level solution or by coarsening the "new" solution on the fine level (i.e., after it has been advanced).

This routine is only when Richardson extrapolation is being used. It is virtual with an empty implementation here (rather than pure virtual) so that users are not required to provide an implementation when the function is not needed.

Member Data Documentation

◆ d_default_convective_time_stepping_type

TimeSteppingType IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_default_convective_time_stepping_type

protected

Default convective time integration methods.

◆ d_default_init_convective_time_stepping_type

TimeSteppingType IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_default_init_convective_time_stepping_type

protected

◆ d_default_convective_op_type

std::string IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_default_convective_op_type

protected

Default convective operator settings.

◆ d_default_convective_op_input_db

SAMRAI::tbox::Pointer<SAMRAI::tbox::Database> IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_default_convective_op_input_db

protected

◆ d_hier_fc_data_ops

SAMRAI::tbox::Pointer<SAMRAI::math::HierarchyFaceDataOpsReal<NDIM, double> > IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_hier_fc_data_ops

protected

◆ d_N_var

std::set<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> > > IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_N_var

protected

Transported quantities.

◆ d_N_old_var

std::set<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> > > IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_N_old_var

protected

◆ d_Q_N_map

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> > > IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_Q_N_map

protected

◆ d_Q_N_old_map

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> > > IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_Q_N_old_map

protected

◆ d_Q_convective_time_stepping_type

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, TimeSteppingType> IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_Q_convective_time_stepping_type

protected

◆ d_Q_init_convective_time_stepping_type

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, TimeSteppingType> IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_Q_init_convective_time_stepping_type

protected

◆ d_Q_convective_op_type

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, std::string> IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_Q_convective_op_type

protected

◆ d_Q_convective_op_input_db

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, SAMRAI::tbox::Pointer<SAMRAI::tbox::Database> > IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_Q_convective_op_input_db

protected

◆ d_Q_convective_op

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, SAMRAI::tbox::Pointer<ConvectiveOperator> > IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_Q_convective_op

protected

◆ d_Q_convective_op_needs_init

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, bool> IBAMR::AdvDiffSemiImplicitHierarchyIntegrator::d_Q_convective_op_needs_init

protected

◆ d_integrator_is_initialized

bool IBAMR::AdvDiffHierarchyIntegrator::d_integrator_is_initialized = false

protectedinherited

◆ d_cfl_max

double IBAMR::AdvDiffHierarchyIntegrator::d_cfl_max = 0.5

protectedinherited

Advective CFL condition.

◆ d_default_diffusion_time_stepping_type

TimeSteppingType IBAMR::AdvDiffHierarchyIntegrator::d_default_diffusion_time_stepping_type = TRAPEZOIDAL_RULE

protectedinherited

Default diffusion time integration method.

◆ d_default_convective_difference_form

ConvectiveDifferencingType IBAMR::AdvDiffHierarchyIntegrator::d_default_convective_difference_form = CONSERVATIVE

protectedinherited

Default convective differencing type.

◆ d_u_var

std::vector<SAMRAI::tbox::Pointer<SAMRAI::pdat::FaceVariable<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_u_var

protectedinherited

Advection velocity data.

◆ d_u_is_div_free

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::FaceVariable<NDIM, double> >, bool> IBAMR::AdvDiffHierarchyIntegrator::d_u_is_div_free

protectedinherited

◆ d_u_fcn

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::FaceVariable<NDIM, double> >, SAMRAI::tbox::Pointer<IBTK::CartGridFunction> > IBAMR::AdvDiffHierarchyIntegrator::d_u_fcn

protectedinherited

◆ d_F_var

std::vector<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_F_var

protectedinherited

Source term data.

◆ d_F_fcn

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, SAMRAI::tbox::Pointer<IBTK::CartGridFunction> > IBAMR::AdvDiffHierarchyIntegrator::d_F_fcn

protectedinherited

◆ d_F_output

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, bool> IBAMR::AdvDiffHierarchyIntegrator::d_F_output

protectedinherited

◆ d_diffusion_coef_var

std::vector<SAMRAI::tbox::Pointer<SAMRAI::pdat::SideVariable<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_diffusion_coef_var

protectedinherited

Diffusion coefficient data

◆ d_diffusion_coef_rhs_var

std::vector<SAMRAI::tbox::Pointer<SAMRAI::pdat::SideVariable<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_diffusion_coef_rhs_var

protectedinherited

◆ d_diffusion_coef_fcn

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::SideVariable<NDIM, double> >, SAMRAI::tbox::Pointer<IBTK::CartGridFunction> > IBAMR::AdvDiffHierarchyIntegrator::d_diffusion_coef_fcn

protectedinherited

◆ d_diffusion_coef_rhs_map

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::SideVariable<NDIM, double> >, SAMRAI::tbox::Pointer<SAMRAI::pdat::SideVariable<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_diffusion_coef_rhs_map

protectedinherited

◆ d_Q_var

std::vector<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_Q_var

protectedinherited

Transported quantities.

◆ d_Q_rhs_var

std::vector<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_Q_rhs_var

protectedinherited

◆ d_Q_u_map

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, SAMRAI::tbox::Pointer<SAMRAI::pdat::FaceVariable<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_Q_u_map

protectedinherited

◆ d_Q_F_map

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_Q_F_map

protectedinherited

◆ d_Q_Q_rhs_map

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_Q_Q_rhs_map

protectedinherited

◆ d_Q_diffusion_time_stepping_type

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, TimeSteppingType> IBAMR::AdvDiffHierarchyIntegrator::d_Q_diffusion_time_stepping_type

protectedinherited

◆ d_Q_difference_form

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, ConvectiveDifferencingType> IBAMR::AdvDiffHierarchyIntegrator::d_Q_difference_form

protectedinherited

◆ d_Q_diffusion_coef

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, double> IBAMR::AdvDiffHierarchyIntegrator::d_Q_diffusion_coef

protectedinherited

◆ d_Q_diffusion_coef_variable

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, SAMRAI::tbox::Pointer<SAMRAI::pdat::SideVariable<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_Q_diffusion_coef_variable

protectedinherited

◆ d_Q_is_diffusion_coef_variable

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, bool> IBAMR::AdvDiffHierarchyIntegrator::d_Q_is_diffusion_coef_variable

protectedinherited

◆ d_Q_damping_coef

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, double> IBAMR::AdvDiffHierarchyIntegrator::d_Q_damping_coef

protectedinherited

◆ d_Q_init

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, SAMRAI::tbox::Pointer<IBTK::CartGridFunction> > IBAMR::AdvDiffHierarchyIntegrator::d_Q_init

protectedinherited

◆ d_Q_bc_coef

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, std::vector<SAMRAI::solv::RobinBcCoefStrategy<NDIM>*> > IBAMR::AdvDiffHierarchyIntegrator::d_Q_bc_coef

protectedinherited

◆ d_Q_output

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, bool> IBAMR::AdvDiffHierarchyIntegrator::d_Q_output

protectedinherited

◆ d_Q_reset_fcns

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, std::vector<ResetPropertiesFcnPtr> > IBAMR::AdvDiffHierarchyIntegrator::d_Q_reset_fcns

protectedinherited

Objects to keep track of the resetting functions.

◆ d_Q_reset_fcns_ctx

std::map<SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> >, std::vector<void*> > IBAMR::AdvDiffHierarchyIntegrator::d_Q_reset_fcns_ctx

protectedinherited

◆ d_Q_reset_priority

std::vector<int> IBAMR::AdvDiffHierarchyIntegrator::d_Q_reset_priority

protectedinherited

◆ d_hier_cc_data_ops

SAMRAI::tbox::Pointer<SAMRAI::math::HierarchyCellDataOpsReal<NDIM, double> > IBAMR::AdvDiffHierarchyIntegrator::d_hier_cc_data_ops

protectedinherited

◆ d_hier_sc_data_ops

SAMRAI::tbox::Pointer<SAMRAI::math::HierarchySideDataOpsReal<NDIM, double> > IBAMR::AdvDiffHierarchyIntegrator::d_hier_sc_data_ops

protectedinherited

◆ d_hier_bdry_fill_ops

std::vector<SAMRAI::tbox::Pointer<IBTK::HierarchyGhostCellInterpolation> > IBAMR::AdvDiffHierarchyIntegrator::d_hier_bdry_fill_ops

protectedinherited

◆ d_no_fill_op

SAMRAI::tbox::Pointer<IBTK::HierarchyGhostCellInterpolation> IBAMR::AdvDiffHierarchyIntegrator::d_no_fill_op

protectedinherited

◆ d_sol_vecs

std::vector<SAMRAI::tbox::Pointer<SAMRAI::solv::SAMRAIVectorReal<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_sol_vecs

protectedinherited

◆ d_rhs_vecs

std::vector<SAMRAI::tbox::Pointer<SAMRAI::solv::SAMRAIVectorReal<NDIM, double> > > IBAMR::AdvDiffHierarchyIntegrator::d_rhs_vecs

protectedinherited

◆ d_helmholtz_solver_type

std::string IBAMR::AdvDiffHierarchyIntegrator::d_helmholtz_solver_type

protectedinherited

◆ d_helmholtz_precond_type

std::string IBAMR::AdvDiffHierarchyIntegrator::d_helmholtz_precond_type

protectedinherited

◆ d_helmholtz_sub_precond_type

std::string IBAMR::AdvDiffHierarchyIntegrator::d_helmholtz_sub_precond_type

protectedinherited

◆ d_helmholtz_solver_db

SAMRAI::tbox::Pointer<SAMRAI::tbox::Database> IBAMR::AdvDiffHierarchyIntegrator::d_helmholtz_solver_db

protectedinherited

◆ d_helmholtz_precond_db

SAMRAI::tbox::Pointer<SAMRAI::tbox::Database> IBAMR::AdvDiffHierarchyIntegrator::d_helmholtz_precond_db

protectedinherited

◆ d_helmholtz_sub_precond_db

SAMRAI::tbox::Pointer<SAMRAI::tbox::Database> IBAMR::AdvDiffHierarchyIntegrator::d_helmholtz_sub_precond_db

protectedinherited

◆ d_helmholtz_solvers

std::vector<SAMRAI::tbox::Pointer<IBTK::PoissonSolver> > IBAMR::AdvDiffHierarchyIntegrator::d_helmholtz_solvers

protectedinherited

◆ d_helmholtz_rhs_ops

std::vector<SAMRAI::tbox::Pointer<IBTK::LaplaceOperator> > IBAMR::AdvDiffHierarchyIntegrator::d_helmholtz_rhs_ops

protectedinherited

◆ d_helmholtz_solvers_need_init

std::vector<bool> IBAMR::AdvDiffHierarchyIntegrator::d_helmholtz_solvers_need_init

protectedinherited

◆ d_helmholtz_rhs_ops_need_init

std::vector<bool> IBAMR::AdvDiffHierarchyIntegrator::d_helmholtz_rhs_ops_need_init

protectedinherited

◆ d_coarsest_reset_ln

int IBAMR::AdvDiffHierarchyIntegrator::d_coarsest_reset_ln = IBTK::invalid_level_number

protectedinherited

◆ d_finest_reset_ln

int IBAMR::AdvDiffHierarchyIntegrator::d_finest_reset_ln = IBTK::invalid_level_number

protectedinherited

◆ d_object_name

std::string IBTK::HierarchyIntegrator::d_object_name

protectedinherited

◆ d_registered_for_restart

bool IBTK::HierarchyIntegrator::d_registered_for_restart = false

protectedinherited

◆ d_hierarchy

SAMRAI::tbox::Pointer<SAMRAI::hier::PatchHierarchy<NDIM> > IBTK::HierarchyIntegrator::d_hierarchy

protectedinherited

◆ d_gridding_alg

SAMRAI::tbox::Pointer<SAMRAI::mesh::GriddingAlgorithm<NDIM> > IBTK::HierarchyIntegrator::d_gridding_alg

protectedinherited

◆ d_load_balancer

SAMRAI::tbox::Pointer<SAMRAI::mesh::LoadBalancer<NDIM> > IBTK::HierarchyIntegrator::d_load_balancer

protectedinherited

◆ d_workload_var

SAMRAI::tbox::Pointer<SAMRAI::pdat::CellVariable<NDIM, double> > IBTK::HierarchyIntegrator::d_workload_var

protectedinherited

◆ d_workload_idx

int IBTK::HierarchyIntegrator::d_workload_idx = IBTK::invalid_index

protectedinherited

The index of the workload estimate variable. If the current integrator is a child integrator then this variable index may not be set to the correct variable index since the parent is assumed to manage the variable, and the correct index is always provided when calling HierarchyIntegrator::addWorkloadEstimate() from parent integrators.

If necessary, this variable can be retrieved from the variable database under the name object_name + "::workload", where object_name is the name of the parent hierarchy integrator.

◆ d_hierarchy_is_initialized

bool IBTK::HierarchyIntegrator::d_hierarchy_is_initialized = false

protectedinherited

◆ d_may_need_to_reset_hierarchy_configuration

bool IBTK::HierarchyIntegrator::d_may_need_to_reset_hierarchy_configuration = false

protectedinherited

◆ d_parent_integrator

HierarchyIntegrator* IBTK::HierarchyIntegrator::d_parent_integrator = nullptr

protectedinherited

◆ d_child_integrators

std::set<HierarchyIntegrator*> IBTK::HierarchyIntegrator::d_child_integrators

protectedinherited

◆ d_visit_writer

SAMRAI::tbox::Pointer<SAMRAI::appu::VisItDataWriter<NDIM> > IBTK::HierarchyIntegrator::d_visit_writer

protectedinherited

◆ d_integrator_time

double IBTK::HierarchyIntegrator::d_integrator_time = std::numeric_limits<double>::quiet_NaN()

protectedinherited

◆ d_start_time

double IBTK::HierarchyIntegrator::d_start_time = 0.0

protectedinherited

◆ d_end_time

double IBTK::HierarchyIntegrator::d_end_time = std::numeric_limits<double>::max()

protectedinherited

◆ d_dt_init

double IBTK::HierarchyIntegrator::d_dt_init = std::numeric_limits<double>::max()

protectedinherited

◆ d_dt_min

double IBTK::HierarchyIntegrator::d_dt_min = 0.0

protectedinherited

◆ d_dt_max

double IBTK::HierarchyIntegrator::d_dt_max = std::numeric_limits<double>::max()

protectedinherited

◆ d_dt_growth_factor

double IBTK::HierarchyIntegrator::d_dt_growth_factor = 2.0

protectedinherited

◆ d_integrator_step

int IBTK::HierarchyIntegrator::d_integrator_step = 0

protectedinherited

◆ d_max_integrator_steps

int IBTK::HierarchyIntegrator::d_max_integrator_steps = std::numeric_limits<int>::max()

protectedinherited

◆ d_dt_previous

std::deque<double> IBTK::HierarchyIntegrator::d_dt_previous

protectedinherited

◆ d_num_cycles

int IBTK::HierarchyIntegrator::d_num_cycles = 1

protectedinherited

◆ d_current_num_cycles

int IBTK::HierarchyIntegrator::d_current_num_cycles = -1

protectedinherited

◆ d_current_cycle_num

int IBTK::HierarchyIntegrator::d_current_cycle_num = -1

protectedinherited

◆ d_current_dt

double IBTK::HierarchyIntegrator::d_current_dt = std::numeric_limits<double>::quiet_NaN()

protectedinherited

◆ d_regrid_interval

int IBTK::HierarchyIntegrator::d_regrid_interval = 1

protectedinherited

◆ d_regrid_mode

RegridMode IBTK::HierarchyIntegrator::d_regrid_mode = STANDARD

protectedinherited

◆ d_enable_logging

bool IBTK::HierarchyIntegrator::d_enable_logging = false

protectedinherited

◆ d_enable_logging_solver_iterations

bool IBTK::HierarchyIntegrator::d_enable_logging_solver_iterations = false

protectedinherited

◆ d_bdry_extrap_type

std::string IBTK::HierarchyIntegrator::d_bdry_extrap_type = "LINEAR"

protectedinherited

◆ d_tag_buffer

SAMRAI::tbox::Array<int> IBTK::HierarchyIntegrator::d_tag_buffer = { 0 }

protectedinherited

◆ d_hier_math_ops

SAMRAI::tbox::Pointer<HierarchyMathOps> IBTK::HierarchyIntegrator::d_hier_math_ops

protectedinherited

◆ d_manage_hier_math_ops

bool IBTK::HierarchyIntegrator::d_manage_hier_math_ops = true

protectedinherited

◆ d_state_variables

std::list<SAMRAI::tbox::Pointer<SAMRAI::hier::Variable<NDIM> > > IBTK::HierarchyIntegrator::d_state_variables

protectedinherited

◆ d_scratch_variables

std::list<SAMRAI::tbox::Pointer<SAMRAI::hier::Variable<NDIM> > > IBTK::HierarchyIntegrator::d_scratch_variables

protectedinherited

◆ d_copy_scratch_to_current_fast

std::list<SAMRAI::tbox::Pointer<SAMRAI::hier::Variable<NDIM> > > IBTK::HierarchyIntegrator::d_copy_scratch_to_current_fast

protectedinherited

◆ d_copy_scratch_to_current_slow

std::list<SAMRAI::tbox::Pointer<SAMRAI::hier::Variable<NDIM> > > IBTK::HierarchyIntegrator::d_copy_scratch_to_current_slow

protectedinherited

◆ d_current_data

SAMRAI::hier::ComponentSelector IBTK::HierarchyIntegrator::d_current_data

protectedinherited

◆ d_new_data

SAMRAI::hier::ComponentSelector IBTK::HierarchyIntegrator::d_new_data

protectedinherited

◆ d_scratch_data

SAMRAI::hier::ComponentSelector IBTK::HierarchyIntegrator::d_scratch_data

protectedinherited

◆ d_plot_data

SAMRAI::hier::ComponentSelector IBTK::HierarchyIntegrator::d_plot_data

protectedinherited

◆ d_state_var_init_fcns

std::map<SAMRAI::hier::Variable<NDIM>*, SAMRAI::tbox::Pointer<CartGridFunction> > IBTK::HierarchyIntegrator::d_state_var_init_fcns

protectedinherited

◆ d_current_context

SAMRAI::tbox::Pointer<SAMRAI::hier::VariableContext> IBTK::HierarchyIntegrator::d_current_context

protectedinherited

Variable contexts.

◆ d_new_context

SAMRAI::tbox::Pointer<SAMRAI::hier::VariableContext> IBTK::HierarchyIntegrator::d_new_context

protectedinherited

◆ d_scratch_context

SAMRAI::tbox::Pointer<SAMRAI::hier::VariableContext> IBTK::HierarchyIntegrator::d_scratch_context

protectedinherited

◆ d_plot_context

SAMRAI::tbox::Pointer<SAMRAI::hier::VariableContext> IBTK::HierarchyIntegrator::d_plot_context

protectedinherited

◆ SYNCH_CURRENT_DATA_ALG

const std::string IBTK::HierarchyIntegrator::SYNCH_CURRENT_DATA_ALG

staticprotectedinherited

Names of special coarsen algorithms/schedules.

◆ SYNCH_NEW_DATA_ALG

const std::string IBTK::HierarchyIntegrator::SYNCH_NEW_DATA_ALG

staticprotectedinherited

◆ d_fill_after_regrid_bc_idxs

SAMRAI::hier::ComponentSelector IBTK::HierarchyIntegrator::d_fill_after_regrid_bc_idxs

protectedinherited

Regridding-related communications algorithms and other data structures.

◆ d_fill_after_regrid_prolong_alg

SAMRAI::xfer::RefineAlgorithm<NDIM> IBTK::HierarchyIntegrator::d_fill_after_regrid_prolong_alg

protectedinherited

◆ d_fill_after_regrid_phys_bdry_bc_op

std::unique_ptr<SAMRAI::xfer::RefinePatchStrategy<NDIM> > IBTK::HierarchyIntegrator::d_fill_after_regrid_phys_bdry_bc_op

protectedinherited

◆ d_preprocess_integrate_hierarchy_callbacks

std::vector<PreprocessIntegrateHierarchyCallbackFcnPtr> IBTK::HierarchyIntegrator::d_preprocess_integrate_hierarchy_callbacks

protectedinherited

Callback functions and callback function contexts.

◆ d_preprocess_integrate_hierarchy_callback_ctxs

std::vector<void*> IBTK::HierarchyIntegrator::d_preprocess_integrate_hierarchy_callback_ctxs

protectedinherited

◆ d_integrate_hierarchy_callbacks

std::vector<IntegrateHierarchyCallbackFcnPtr> IBTK::HierarchyIntegrator::d_integrate_hierarchy_callbacks

protectedinherited

◆ d_integrate_hierarchy_callback_ctxs

std::vector<void*> IBTK::HierarchyIntegrator::d_integrate_hierarchy_callback_ctxs

protectedinherited

◆ d_postprocess_integrate_hierarchy_callbacks

std::vector<PostprocessIntegrateHierarchyCallbackFcnPtr> IBTK::HierarchyIntegrator::d_postprocess_integrate_hierarchy_callbacks

protectedinherited

◆ d_postprocess_integrate_hierarchy_callback_ctxs

std::vector<void*> IBTK::HierarchyIntegrator::d_postprocess_integrate_hierarchy_callback_ctxs

protectedinherited

◆ d_apply_gradient_detector_callbacks

std::vector<ApplyGradientDetectorCallbackFcnPtr> IBTK::HierarchyIntegrator::d_apply_gradient_detector_callbacks

protectedinherited

◆ d_apply_gradient_detector_callback_ctxs

std::vector<void*> IBTK::HierarchyIntegrator::d_apply_gradient_detector_callback_ctxs

protectedinherited

◆ d_regrid_hierarchy_callbacks

std::vector<RegridHierarchyCallbackFcnPtr> IBTK::HierarchyIntegrator::d_regrid_hierarchy_callbacks

protectedinherited

◆ d_regrid_hierarchy_callback_ctxs

std::vector<void*> IBTK::HierarchyIntegrator::d_regrid_hierarchy_callback_ctxs

protectedinherited

◆ d_regridding_hierarchy

bool IBTK::HierarchyIntegrator::d_regridding_hierarchy = false

privateinherited

◆ d_at_regrid_time_step

bool IBTK::HierarchyIntegrator::d_at_regrid_time_step = false

privateinherited

◆ d_ghostfill_algs

RefineAlgorithmMap IBTK::HierarchyIntegrator::d_ghostfill_algs

privateinherited

◆ d_ghostfill_strategies

RefinePatchStrategyMap IBTK::HierarchyIntegrator::d_ghostfill_strategies

privateinherited

◆ d_ghostfill_scheds

RefineScheduleMap IBTK::HierarchyIntegrator::d_ghostfill_scheds

privateinherited

◆ d_prolong_algs

RefineAlgorithmMap IBTK::HierarchyIntegrator::d_prolong_algs

privateinherited

◆ d_prolong_strategies

RefinePatchStrategyMap IBTK::HierarchyIntegrator::d_prolong_strategies

privateinherited

◆ d_prolong_scheds

RefineScheduleMap IBTK::HierarchyIntegrator::d_prolong_scheds

privateinherited

◆ d_coarsen_algs

CoarsenAlgorithmMap IBTK::HierarchyIntegrator::d_coarsen_algs

privateinherited

◆ d_coarsen_strategies

CoarsenPatchStrategyMap IBTK::HierarchyIntegrator::d_coarsen_strategies

privateinherited

◆ d_coarsen_scheds

CoarsenScheduleMap IBTK::HierarchyIntegrator::d_coarsen_scheds

privateinherited

The documentation for this class was generated from the following file:

include/ibamr/AdvDiffSemiImplicitHierarchyIntegrator.h

Private Attributes
bool	d_regridding_hierarchy = false

bool	d_at_regrid_time_step = false

RefineAlgorithmMap	d_ghostfill_algs

RefinePatchStrategyMap	d_ghostfill_strategies

RefineScheduleMap	d_ghostfill_scheds

RefineAlgorithmMap	d_prolong_algs

RefinePatchStrategyMap	d_prolong_strategies

RefineScheduleMap	d_prolong_scheds

CoarsenAlgorithmMap	d_coarsen_algs

CoarsenPatchStrategyMap	d_coarsen_strategies

CoarsenScheduleMap	d_coarsen_scheds

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ResetPropertiesFcnPtr

◆ PreprocessIntegrateHierarchyCallbackFcnPtr

◆ IntegrateHierarchyCallbackFcnPtr

◆ PostprocessIntegrateHierarchyCallbackFcnPtr

◆ ApplyGradientDetectorCallbackFcnPtr

◆ RegridHierarchyCallbackFcnPtr

◆ RefineAlgorithmMap

◆ RefinePatchStrategyMap

◆ RefineScheduleMap

◆ CoarsenAlgorithmMap

◆ CoarsenPatchStrategyMap

◆ CoarsenScheduleMap

Constructor & Destructor Documentation

◆ AdvDiffSemiImplicitHierarchyIntegrator() [1/3]

◆ ~AdvDiffSemiImplicitHierarchyIntegrator()

◆ AdvDiffSemiImplicitHierarchyIntegrator() [2/3]

◆ AdvDiffSemiImplicitHierarchyIntegrator() [3/3]

Member Function Documentation

◆ setDefaultConvectiveTimeSteppingType()

◆ getDefaultConvectiveTimeSteppingType()

◆ setDefaultInitialConvectiveTimeSteppingType()

◆ getDefaultInitialConvectiveTimeSteppingType()

◆ setDefaultConvectiveOperatorType()

◆ getDefaultConvectiveOperatorType()

◆ setDefaultConvectiveOperatorInputDatabase()

◆ getDefaultConvectiveOperatorInputDatabase()

◆ registerTransportedQuantity()

◆ setConvectiveTimeSteppingType()

◆ getConvectiveTimeSteppingType()

◆ setInitialConvectiveTimeSteppingType()

◆ getInitialConvectiveTimeSteppingType()

◆ setConvectiveOperatorType()

◆ getConvectiveOperatorType()

◆ setConvectiveOperatorInputDatabase()

◆ getConvectiveOperatorInputDatabase()

◆ setConvectiveOperator()

◆ getConvectiveOperator()

◆ setConvectiveOperatorsNeedInit()

◆ setConvectiveOperatorNeedsInit()

◆ initializeHierarchyIntegrator()

◆ getNumberOfCycles()

◆ preprocessIntegrateHierarchy()

◆ postprocessIntegrateHierarchy()

◆ integrateHierarchySpecialized()

◆ resetHierarchyConfigurationSpecialized()

◆ putToDatabaseSpecialized()

◆ operator=()

◆ getFromInput()

◆ getFromRestart()

◆ setDefaultDiffusionTimeSteppingType()

◆ getDefaultDiffusionTimeSteppingType()

◆ setDefaultConvectiveDifferencingType()

◆ getDefaultConvectiveDifferencingType()

◆ registerAdvectionVelocity()

◆ setAdvectionVelocityIsDivergenceFree()

◆ getAdvectionVelocityIsDivergenceFree()

◆ setAdvectionVelocityFunction()

◆ getAdvectionVelocityFunction()

◆ registerSourceTerm()

◆ setSourceTermFunction()

◆ getSourceTermFunction()

◆ setAdvectionVelocity()

◆ getAdvectionVelocity()

◆ setSourceTerm()

◆ getSourceTerm()

◆ setDiffusionTimeSteppingType()

◆ getDiffusionTimeSteppingType()

◆ setConvectiveDifferencingType()

◆ getConvectiveDifferencingType()

◆ setDiffusionCoefficient()