IBTK Namespace Reference

Namespaces
	libMeshWrappers

Classes
class	AppInitializer
	Class AppInitializer provides functionality to simplify the initialization code in an application code. More...
class	BGaussSeidelPreconditioner
	Class BGaussSeidelPreconditioner is a block Gauss-Seidel preconditioner which implements the abstract LinearSolver interface. More...
class	BJacobiPreconditioner
	Class BJacobiPreconditioner is a block Jacobi preconditioner which implements the abstract LinearSolver interface. More...
class	BoxPartitioner
	A libMesh partitioner that partitions a mesh based on PartitioningBox objects owned by each processor. More...
class	CartCellDoubleBoundsPreservingConservativeLinearRefine
	Class CartCellDoubleBoundsPreservingConservativeLinearRefine is a concrete SAMRAI::xfer::RefineOperator object which prolongs cell-centered double precision patch data via conservative linear interpolation with an additional bounds preservation repair step. More...
class	CartCellDoubleCubicCoarsen
	Class CartCellDoubleCubicCoarsen is a concrete SAMRAI::xfer::CoarsenOperator for restricting cell-centered double precision patch data via cubic interpolation. More...
class	CartCellDoubleLinearCFInterpolation
	Class CartCellDoubleLinearCFInterpolation is a concrete SAMRAI::xfer::RefinePatchStrategy which sets coarse-fine interface ghost cell values for cell-centered double precision patch data via linear interpolation in the normal and tangential directions at coarse-fine interfaces. More...
class	CartCellDoubleQuadraticCFInterpolation
	Class CartCellDoubleQuadraticCFInterpolation is a concrete SAMRAI::xfer::RefinePatchStrategy which sets coarse-fine interface ghost cell values for cell-centered double precision patch data via quadratic interpolation in the normal and tangential directions at coarse-fine interfaces. More...
class	CartCellDoubleQuadraticRefine
	Class CartCellDoubleQuadraticRefine is a concrete SAMRAI::xfer::RefineOperator object which prolongs cell-centered double precision patch data via quadratic interpolation. More...
class	CartCellRobinPhysBdryOp
	Class CartCellRobinPhysBdryOp is a concrete SAMRAI::xfer::RefinePatchStrategy for setting Robin boundary conditions at physical boundaries for cell-centered scalar- and vector-valued quantities. More...
class	CartExtrapPhysBdryOp
	Class CartExtrapPhysBdryOp is a concrete SAMRAI::xfer::RefinePatchStrategy for setting ghost cell values at physical boundaries via constant, linear, or quadratic extrapolation from interior values. More...
class	CartGridFunction
	Class CartGridFunction provides an abstract interface for objects for evaluating functions to set values in SAMRAI::hier::PatchData objects. More...
class	CartGridFunctionSet
	Class CartGridFunctionSet is a concrete CartGridFunction that is used to allow multiple CartGridFunction objects to act as a single function. More...
class	CartSideDoubleCubicCoarsen
	Class CartSideDoubleCubicCoarsen is a concrete SAMRAI::xfer::CoarsenOperator for restricting side-centered double precision patch data via cubic interpolation. More...
class	CartSideDoubleDivPreservingRefine
	Class CartSideDoubleDivPreservingRefine is a concrete SAMRAI::xfer::RefinePatchStrategy which prolongs side-centered double precision patch data via conservative linear interpolation with divergence- and curl-preserving corrections. More...
class	CartSideDoubleQuadraticCFInterpolation
	Class CartSideDoubleQuadraticCFInterpolation is a concrete SAMRAI::xfer::RefinePatchStrategy which sets coarse-fine interface ghost cell values for side-centered double precision patch data via quadratic interpolation in the normal and tangential directions at coarse-fine interfaces. More...
class	CartSideDoubleRT0Coarsen
	Class CartSideDoubleRT0Coarsen is a concrete SAMRAI::xfer::CoarsenOperator for restricting side-centered double precision patch data via the adjoint of RT0 interpolation. More...
class	CartSideDoubleRT0Refine
	Class CartSideDoubleRT0Refine is a concrete SAMRAI::xfer::RefineOperator object that prolongs side-centered double precision patch data via RT0-based interpolation. More...
class	CartSideDoubleSpecializedLinearRefine
	Class CartSideDoubleSpecializedLinearRefine is a concrete SAMRAI::xfer::RefineOperator object that prolongs side-centered double precision patch data via linear interpolation in the normal direction and MC-limited piecewise-linear interpolation in the tangential direction. More...
class	CartSideRobinPhysBdryOp
	Class CartSideRobinPhysBdryOp is a concrete SAMRAI::xfer::RefinePatchStrategy for setting Robin boundary conditions at physical boundaries for side-centered vector-valued quantities. More...
class	CCLaplaceOperator
	Class CCLaplaceOperator is a concrete LaplaceOperator which implements a globally second-order accurate cell-centered finite difference discretization of a scalar elliptic operator of the form \( L = C I + \nabla \cdot D \nabla\). More...
class	CCPoissonBoxRelaxationFACOperator
	Class CCPoissonBoxRelaxationFACOperator is a concrete PoissonFACPreconditionerStrategy for solving elliptic equations of the form \( \mbox{$L u$} = \mbox{$(C I + \nabla \cdot D \nabla) u$} = f \) using a globally second-order accurate cell-centered finite-volume discretization, with support for Robin and periodic boundary conditions. More...
class	CCPoissonHypreLevelSolver
	Class CCPoissonHypreLevelSolver is a concrete LinearSolver for solving elliptic equations of the form \( \mbox{$L u$} = \mbox{$(C I + \nabla \cdot D \nabla) u$} = f \) on a single SAMRAI::hier::PatchLevel using hypre. More...
class	CCPoissonLevelRelaxationFACOperator
	Class CCPoissonLevelRelaxationFACOperator is a concrete PoissonFACPreconditionerStrategy for solving elliptic equations of the form \( \mbox{$L u$} = \mbox{$(C I + \nabla \cdot D \nabla) u$} = f \) using a globally second-order accurate cell-centered finite-volume discretization, with support for Robin and periodic boundary conditions. More...
class	CCPoissonPETScLevelSolver
	Class CCPoissonPETScLevelSolver is a concrete PETScLevelSolver for solving elliptic equations of the form \( \mbox{$L u$} = \mbox{$(C I + \nabla \cdot D \nabla) u$} = f \) on a single SAMRAI::hier::PatchLevel. More...
class	CCPoissonPointRelaxationFACOperator
	Class CCPoissonPointRelaxationFACOperator is a concrete PoissonFACPreconditionerStrategy for solving elliptic equations of the form \( \mbox{$L u$} = \mbox{$(C I + \nabla \cdot D \nabla) u$} = f \) using a globally second-order accurate cell-centered finite-volume discretization, with support for Robin and periodic boundary conditions. More...
class	CCPoissonSolverManager
	Class CCPoissonSolverManager is a singleton manager class to provide access to generic cell-centered PoissonSolver implementations. More...
class	CellNoCornersFillPattern
	Class CellCellNoCornersFillPattern is a concrete implementation of the abstract base class SAMRAI::xfer::VariableFillPattern. It is used to calculate overlaps according to a pattern that limits overlaps to the cell-centered ghost region surrounding a patch on the target level, excluding all corners (and, in 3D, patch edges). More...
class	CoarseFineBoundaryRefinePatchStrategy
	Class CoarseFineBoundaryRefinePatchStrategy is a subclass of the abstract base class SAMRAI::xfer::RefinePatchStrategy that extends the functionality of SAMRAI::xfer::RefinePatchStrategy to facilitate the implementation of coarse-fine interface discretizations. More...
class	CoarsenPatchStrategySet
	Class CoarsenPatchStrategySet is a utility class that allows multiple SAMRAI::xfer::CoarsenPatchStrategy objects to be employed by a single SAMRAI::xfer::CoarsenSchedule. More...
class	CopyToRootSchedule
	Class CopyToRootSchedule is used to communicate distributed patch data to a unified patch data object on a root MPI process. More...
class	CopyToRootTransaction
	Class CopyToRootTransaction is a concrete implementation of the abstract base class SAMRAI::tbox::Transaction. It is used to communicate distributed patch data to a unified patch data object on a root MPI process. More...
class	DebuggingUtilities
	Class DebuggingUtilities provides debugging functionality. More...
struct	DofObjectComp
class	EdgeDataSynchronization
	Class EdgeDataSynchronization encapsulates the operations required to "synchronize" edge-centered values defined at patch boundaries. More...
class	EdgeSynchCopyFillPattern
	Class EdgeCellSynchCopyFillPattern is a concrete implementation of the abstract base class SAMRAI::xfer::VariableFillPattern. It is used to calculate overlaps according to a pattern which limits overlaps to the edge-centered ghost region surrounding a patch appropriate for "synchronizing" edge-centered values in an axis-by-axis manner at patch boundaries. More...
class	ExtendedRobinBcCoefStrategy
	Class ExtendedRobinBcCoefStrategy is a subclass of the abstract base class SAMRAI::solv::RobinBcCoefStrategy that extends the functionality of SAMRAI::solv::RobinBcCoefStrategy to allow for the specification of patch data descriptor indices that are required for filling, and the specification of whether homogeneous or inhomogeneous boundary data should be set. More...
class	FaceDataSynchronization
	Class FaceDataSynchronization encapsulates the operations required to "synchronize" face-centered values defined at patch boundaries. More...
class	FaceSynchCopyFillPattern
	Class FaceCellSynchCopyFillPattern is a concrete implementation of the abstract base class SAMRAI::xfer::VariableFillPattern. It is used to calculate overlaps according to a pattern which limits overlaps to the face-centered ghost region surrounding a patch appropriate for "synchronizing" face-centered values at patch boundaries. More...
class	FACPreconditioner
	Class FACPreconditioner is a concrete LinearSolver for implementing FAC (multilevel multigrid) preconditioners. More...
class	FACPreconditionerStrategy
	Class FACPreconditionerStrategy provides an interface for specifying the problem-specific operations needed to implement a specific FAC preconditioner. More...
class	FECache
	Class storing multiple libMesh::FE objects, each corresponding to a different quadrature rule. Each FE object is configured with a quadrature rule corresponding to the provided quad_key parameter. More...
class	FEData
class	FEDataInterpolation
	Class FEDataInterpolation manages data required to evaluate one or more FE field variables at a collection of points, possibly (not not necessarily) corresponding to the points of a quadrature rule. More...
class	FEDataManager
	Class FEDataManager coordinates data required for Lagrangian-Eulerian interaction between a Lagrangian finite element (FE) mesh. In particular, the FEData member object stores the necessary finite element data while this class stores additional data dependent on the Eulerian grid. More...
class	FELagrangeMapping
class	FEMapping
class	FEMappingCache
	Class storing multiple IBTK::FEMapping objects. We assume that quadrature rules are uniquely determined by the element type, quadrature type, and approximation order. There are several places in IBTK where we make this assumption, e.g., we will use data from two quadrature rules assumed to be equal (by this metric) to initialize different libMesh objects. More...
class	FENodalMapping
class	FEProjector
	Class FEProjector coordinates data structures for projecting fields in FE models. More...
class	FEValues
class	FEValuesBase
class	FischerGuess
class	FixedSizedStream
	Class FixedSizedStream provides a fixed-size message buffer used by various communication routines. More...
class	GeneralOperator
	Class GeneralOperator provides an abstract interface for the specification of general operators to compute \( y=F[x] \) and \( z=F[x]+y \). More...
class	GeneralSolver
	Class GeneralSolver provides an abstract interface for the implementation of linear or nonlinear solvers for systems of equations defined on an AMR patch hierarchy. More...
class	Hex27Mapping
class	HierarchyAveragedDataManager
	Class HierarchyAveragedDataManager provides a method of tracking and determining periodic steady states of fields. In particular, this class can be used to determine the average of a field over several instances, for example determining the mean flow of a turbulent flow field. More...
class	HierarchyGhostCellInterpolation
	Class HierarchyGhostCellInterpolation encapsulates the operations required to set ghost cell values at physical and coarse-fine boundaries across a range of levels of a locally refined patch hierarchy. More...
class	HierarchyIntegrator
	Class HierarchyIntegrator provides an abstract interface for a time integrator for a system of equations defined on an AMR grid hierarchy, along with basic data management for variables defined on that hierarchy. More...
class	HierarchyMathOps
	Class HierarchyMathOps provides functionality to perform "composite-grid" mathematical operations on a range of levels in a SAMRAI::hier::PatchHierarchy object. More...
struct	IBTK_MPI
	Provides C++ wrapper around MPI routines. More...
class	IBTKInit
	Initialization for IBAMR programs. More...
struct	IndexOrder
class	IndexUtilities
	Class IndexUtilities is a utility class that defines simple functions such as conversion routines between physical coordinates and Cartesian index space. More...
class	JacobianOperator
	Class JacobianOperator provides an abstract interface for the specification of general operators to compute Jacobian-vector products, i.e., \( F'[x]v \). More...
class	KrylovLinearSolver
	Class KrylovLinearSolver provides an abstract interface for the implementation of Krylov subspace solvers for linear problems of the form \(Ax=b\). More...
class	KrylovLinearSolverManager
	Class KrylovLinearSolverManager is a singleton manager class to provide access to generic KrylovLinearSolver implementations. More...
class	KrylovLinearSolverPoissonSolverInterface
	Class KrylovLinearSolverPoissonSolverInterface provides an interface for KrylovLinearSolvers that are to be used as Poisson solvers. More...
class	LaplaceOperator
	Class LaplaceOperator is an abstract base class for a Laplace-type operators. More...
class	LData
	Class LData provides storage for a single scalar- or vector-valued Lagrangian quantity. More...
class	LDataManager
	Class LDataManager coordinates the irregular distribution of LNode and LData on the patch hierarchy. More...
class	LEInteractor
	Class LEInteractor is a utility class that defines several functions to interpolate data from Eulerian grid patches onto Lagrangian meshes and to spread values (not densities) from Lagrangian meshes to Eulerian grid patches. More...
class	LibMeshSystemIBVectors
	Class LibMeshSystemIBVectors is a convenience class that manages access to libMesh vectors for the same system defined on multiple parts. It extends the base class LibMeshSystemVectors to provide access to vectors ghosted with both the Lagrangian partitioning (i.e., libMesh's computed partitioning, as in the base class) as well as the IB partitioning (i.e., the partitioning based on the distribution of SAMRAI data). More...
class	LibMeshSystemVectors
	Class LibMeshSystemVectors is a convenience class that manages access to libMesh vectors for the same system defined on multiple parts. This class only supports access to vectors ghosted with the Lagrangian partitioning (i.e., libMesh's computed partitioning). The subclass LibMeshSystemIBVectors provides access to the IB partitioning (i.e., the partitioning based on the distribution of SAMRAI data). More...
class	LIndexSetData
	Class LIndexSetData is a specialization of the templated class LSetData that is intended to be used with Lagrangian data objects that provide Lagrangian and PETSc indexing information. More...
class	LIndexSetDataFactory
	Class LIndexSetPatchDataFactory provides a SAMRAI::hier::PatchDataFactory class corresponding to patch data of type LIndexSetData. More...
class	LIndexSetVariable
	Class LIndexSetVariable provides a SAMRAI::hier::Variable class corresponding to patch data of type LIndexSetData. More...
class	LinearOperator
	Class LinearOperator provides an abstract interface for the specification of linear operators to compute \( y=Ax \) and \( z=Ax+y \) and, optionally, \( y=A^{T} x \) and \( z=A^{T}x+y \). More...
class	LinearSolver
	Class LinearSolver provides an abstract interface for the implementation of solvers for linear problems of the form \(Ax=b\). More...
class	LInitStrategy
	Class LInitStrategy provides a mechanism for specifying the initial configuration of the curvilinear mesh. More...
class	LMesh
	Class LMesh is a collection of LNode objects. More...
class	LNode
	Class LNode is the basic element of an LMesh. More...
class	LNodeIndex
	Class LNodeIndex provides Lagrangian and PETSc indexing information for a single node of a Lagrangian mesh. More...
struct	LNodeIndexGlobalPETScIndexComp
	Comparison functor to order on the global PETSc index of the Lagrangian node. More...
struct	LNodeIndexGlobalPETScIndexEqual
	Comparison functor to check for equality between between LNodeIndex objects based on their global PETSc indices. More...
struct	LNodeIndexLagrangianIndexComp
	Comparison functor to order on the Lagrangian index of the Lagrangian node. More...
struct	LNodeIndexLagrangianIndexEqual
	Comparison functor to check for equality between LNodeIndex objects based on their Lagrangian indices. More...
struct	LNodeIndexLocalPETScIndexComp
	Comparison functor to order on the local PETSc index of the Lagrangian node. More...
struct	LNodeIndexLocalPETScIndexEqual
	Comparison functor to check for equality between LNodeIndex objects based on their local PETSc indices. More...
class	LNodeIndexPosnComp
	Comparison functor to order on the physical location of the Lagrangian node. More...
class	LNodeIndexPosnEqual
	Comparison functor to check for equality between LNodeIndex objects based on their positions. More...
class	LSet
	Class LSet provides inter-processor communications and database access functionality to a collection of Lagrangian objects. More...
class	LSetData
	Class LSetData is a specialization of the templated class SAMRAI::pdat::IndexData that provides access to Lagrangian objects that are embedded in the a Cartesian grid patch. More...
class	LSetDataFactory
	Class LSetPatchDataFactory provides a SAMRAI::hier::PatchDataFactory class corresponding to patch data of type LSetData. More...
class	LSetDataIterator
	Class LSetDataIterator is an iterator class which may be used to iterate through LSet objects associated with a specified box in cell-centered index space. More...
class	LSetVariable
	Class LSetVariable provides a SAMRAI::hier::Variable class corresponding to patch data of type LSetData. More...
class	LSiloDataWriter
	Class LSiloDataWriter provides functionality to output Lagrangian data for visualization via the VisIt visualization tool in the Silo data format. More...
class	LTransaction
	Class LTransaction represents a communication transaction between two processors or a local data copy for communicating or copying Lagrangian objects. More...
class	MarkerPatch
class	MarkerPatchHierarchy
class	MergingLoadBalancer
	Class MergingLoadBalancer merges the boxes generated by a load balancer in a final step to decrease the total number of boxes. In essence, it postprocesses the list of boxes generated by its parent class to try and coalesce the set of boxes on each process. More...
class	muParserCartGridFunction
	Class muParserCartGridFunction is an implementation of the strategy class CartGridFunction that allows for the run-time specification of (possibly spatially- and temporally-varying) functions which are used to set double precision values on standard SAMRAI SAMRAI::hier::PatchData objects. More...
class	muParserRobinBcCoefs
	Class muParserRobinBcCoefs is an implementation of the strategy class SAMRAI::solv::RobinBcCoefStrategy that allows for the run-time specification of (possibly spatially- and temporally-varying) Robin boundary conditions. More...
class	NewtonKrylovSolver
	Class NewtonKrylovSolver provides an abstract interface for the implementation of inexact Newton-Krylov solvers for nonlinear problems of the form \( F[x]=b \). More...
class	NewtonKrylovSolverManager
	Class NewtonKrylovSolverManager is a singleton manager class to provide access to generic NewtonKrylovSolver implementations. More...
class	NodeDataSynchronization
	Class NodeDataSynchronization encapsulates the operations required to "synchronize" node-centered values defined at patch boundaries. More...
class	NodeSynchCopyFillPattern
	Class NodeCellSynchCopyFillPattern is a concrete implementation of the abstract base class SAMRAI::xfer::VariableFillPattern. It is used to calculate overlaps according to a pattern which limits overlaps to the node-centered ghost region surrounding a patch appropriate for "synchronizing" node-centered values in an axis-by-axis manner at patch boundaries. More...
class	NormOps
	Class NormOps provides functionality for computing discrete vector norms. More...
class	ParallelEdgeMap
	Class ParallelEdgeMap is a utility class for managing edge maps (i.e., maps from vertices to links between vertices) in parallel. More...
class	ParallelMap
	Class ParallelMap is a utility class for associating integer keys with arbitrary data items in parallel. More...
class	ParallelSet
	Class ParallelSet is a utility class for storing collections of integer keys in parallel. More...
class	PartitioningBox
	Class PartitioningBox implements an NDIM-dimensional bounding box defined by two points. Unlike a standard bounding box, a PartitioningBox is an NDIM-dimensional tensor product of half-open intervals: i.e., it is a half-open box. This property allows one to partition a domain into a set of boxes. More...
class	PartitioningBoxes
	Class PartitioningBoxes stores a set of bounding boxes and can check if a point is in the set of partitioning boxes or not in a more optimized way than just looping over a std::vector<PartitioningBox>. More...
class	PatchMathOps
	Class PatchMathOps provides functionality to perform mathematical operations on individual SAMRAI::hier::Patch objects. More...
class	PETScKrylovLinearSolver
	Class PETScKrylovLinearSolver provides a KrylovLinearSolver interface for a PETSc Krylov subspace iterative linear solver (KSP). More...
class	PETScKrylovPoissonSolver
	Class PETScKrylovPoissonSolver is an extension of class PETScKrylovLinearSolver that provides an implementation of the PoissonSolver interface. More...
class	PETScLevelSolver
	Class PETScLevelSolver is an abstract LinearSolver for solving systems of linear equations on a single SAMRAI::hier::PatchLevel using PETSc. More...
class	PETScMatLOWrapper
	Class PETScMatLOWrapper provides a LinearOperator interface for a PETSc Mat object. More...
class	PETScMatUtilities
	Class PETScMatUtilities provides utility functions for PETSc Mat objects. More...
class	PETScMFFDJacobianOperator
	Class PETScMFFDJacobianOperator provides a method for computing Jacobian-vector products, i.e., \( F'[x]v \), via a matrix-free finite-difference approach. More...
class	PETScNewtonKrylovSolver
	Class PETScNewtonKrylovSolver provides a NewtonKrylovSolver interface for a PETSc inexact Newton-Krylov iterative nonlinear solver (SNES). More...
class	PETScPCLSWrapper
	Class PETScPCLSWrapper provides a LinearSolver interface for a PETSc PC object. More...
class	PETScSAMRAIVectorReal
	Class PETScSAMRAIVectorReal is a class for wrapping SAMRAI::solv::SAMRAIVectorReal objects so that they may be used with the PETSc solver package. More...
class	PETScSNESFunctionGOWrapper
	Class PETScSNESFunctionGOWrapper provides a GeneralOperator interface for a PETSc SNES nonlinear function. More...
class	PETScSNESJacobianJOWrapper
	Class PETScSNESJacobianJOWrapper provides a JacobianOperator interface for a PETSc SNES Jacobian. More...
class	PETScVecUtilities
	Class PETScVecUtilities provides utility functions for PETSc Vec objects. More...
class	PhysicalBoundaryUtilities
	Class PhysicalBoundaryUtilities is a utility class to organize functions related to setting values at physical boundaries. More...
class	PointMap
class	PoissonFACPreconditioner
	Class PoissonFACPreconditioner is a FACPreconditioner that has been specialized for Poisson problems. More...
class	PoissonFACPreconditionerStrategy
	Class PoissonFACPreconditionerStrategy is an abstract FACPreconditionerStrategy implementing many of the operations required by smoothers for the Poisson equation and related problems. More...
class	PoissonSolver
	Class PoissonSolver is an abstract base class for Poisson solvers. More...
class	PoissonUtilities
	Class PoissonUtilities provides utility functions for constructing Poisson solvers. More...
class	Quad4Mapping
class	Quad9Mapping
class	QuadratureCache
	Class storing multiple libMesh quadrature objects. We assume that quadrature rules are uniquely determined by the element type, quadrature type, and approximation order. There are several places in IBTK where we make this assumption, e.g., we will use data from two quadrature rules assumed to be equal (by this metric) to initialize FEMap objects. More...
struct	QuadratureData
class	RefinePatchStrategySet
	Class RefinePatchStrategySet is a utility class that allows multiple SAMRAI::xfer::RefinePatchStrategy objects to be employed by a single SAMRAI::xfer::RefineSchedule. More...
class	RobinPhysBdryPatchStrategy
	Class RobinPhysBdryPatchStrategy is an abstract strategy class that extends the SAMRAI::xfer::RefinePatchStrategy interface to provide routines specific for setting Robin boundary conditions at physical boundaries. This class also provides default implementations of some methods defined in SAMRAI::xfer::RefinePatchStrategy that are generally not needed for filling ghost cell values at physical boundaries. More...
class	SAMRAIDataCache
	Class SAMRAIDataCache is a utility class for caching cloned SAMRAI patch data. Patch data are allocated as needed and should not be deallocated by the caller. More...
class	SAMRAIGhostDataAccumulator
	Class that can accumulate data summed into ghost regions on a patch hierarchy into their correct locations. More...
class	SAMRAIScopedVectorCopy
class	SAMRAIScopedVectorDuplicate
class	SCLaplaceOperator
	Class SCLaplaceOperator is a concrete LaplaceOperator which implements a globally second-order accurate side-centered finite difference discretization of a scalar elliptic operator of the form \( L = C I + \nabla \cdot D \nabla\). More...
class	SCPoissonHypreLevelSolver
	Class SCPoissonHypreLevelSolver is a concrete LinearSolver for solving elliptic equations of the form \( \mbox{$L u$} = \mbox{$(C I + \nabla \cdot D \nabla) u$} = f \) on a single SAMRAI::hier::PatchLevel using hypre. More...
class	SCPoissonPETScLevelSolver
	Class SCPoissonPETScLevelSolver is a concrete PETScLevelSolver for solving elliptic equations of the form \( \mbox{$L u$} = \mbox{$(C I + \nabla \cdot D \nabla) u$} = f \) on a single SAMRAI::hier::PatchLevel using PETSc. More...
class	SCPoissonPointRelaxationFACOperator
	Class SCPoissonPointRelaxationFACOperator is a concrete PoissonFACPreconditionerStrategy for solving elliptic equations of the form \( \mbox{$L u$} = \mbox{$(C I + \nabla \cdot D \nabla) u$} = f \) using a globally second-order accurate side-centered finite-difference discretization, with support for Robin and periodic boundary conditions. More...
class	SCPoissonSolverManager
	Class SCPoissonSolverManager is a singleton manager class to provide access to generic side-centered PoissonSolver implementations. More...
class	SecondaryHierarchy
class	SideDataSynchronization
	Class SideDataSynchronization encapsulates the operations required to "synchronize" side-centered values defined at patch boundaries. More...
class	SideNoCornersFillPattern
	Class SideCellNoCornersFillPattern is a concrete implementation of the abstract base class SAMRAI::xfer::VariableFillPattern. It is used to calculate overlaps according to a pattern that limits overlaps to the cell-centered ghost region surrounding a patch on the target level, excluding all corners (and, in 3D, patch edges). More...
class	SideSynchCopyFillPattern
	Class SideCellSynchCopyFillPattern is a concrete implementation of the abstract base class SAMRAI::xfer::VariableFillPattern. It is used to calculate overlaps according to a pattern which limits overlaps to the side-centered ghost region surrounding a patch appropriate for "synchronizing" side-centered values at patch boundaries. More...
class	SnapshotCache
	Class SnapshotCache provides a method of storing snapshots of patch data on a snapshot of the patch hierarchy. More...
class	StableCentroidPartitioner
	A libMesh partitioner that partitions a mesh based on the x coordinate of each centroid in a numerically stable way. More...
class	StaggeredPhysicalBoundaryHelper
	Class StaggeredPhysicalBoundaryHelper provides helper functions to handle physical boundary conditions for a staggered grid discretizations. More...
class	StandardTagAndInitStrategySet
	Class StandardTagAndInitStrategySet is a utility class that allows multiple SAMRAI::mesh::StandardTagAndInitStrategy objects to be employed by a single SAMRAI::mesh::StandardTagAndInitialize object. More...
class	Streamable
	Class Streamable is an abstract interface for objects that can be packed into SAMRAI::tbox::AbstractStream data streams. More...
class	StreamableFactory
	Class StreamableFactory is an abstract interface for classes that can unpack particular concrete Streamable objects from SAMRAI::tbox::AbstractStream data streams. More...
class	StreamableManager
	Class StreamableManager is a singleton manager class that organizes the actual packing and unpacking of concrete Streamable objects for SAMRAI::tbox::AbstractStream based communication. More...
class	SubdomainToPatchLevelTranslation
struct	SystemData
class	Tet10Mapping
class	Tet4Mapping
class	Tri3Mapping
class	Tri6Mapping
class	VCSCViscousOperator
	Class VCSCViscousOperator is a subclass of SCLaplaceOperator which implements a globally second-order accurate side-centered finite difference discretization of a vector elliptic operator of the form \( L = \beta C I + \alpha \nabla \cdot \mu ( (\nabla u) + (\nabla u)^T ) \). More...
class	VCSCViscousOpPointRelaxationFACOperator
	Class VCSCViscousOpPointRelaxationFACOperator is a specialization of SCPoissonPointRelaxationFACOperator for solving vector elliptic equation of the form \( \mbox{$L u$} = C u + \nabla \cdot \mu (\nabla u + (\nabla u)^T) = f \) using a globally second-order accurate side-centered finite-difference discretization, with support for Robin and periodic boundary conditions. More...
class	VCSCViscousPETScLevelSolver
	Class VCSCViscousPETScLevelSolver is a subclass of SCPoissonPETScLevelSolver class which solves vector-valued elliptic equation of the form \( \mbox{$L u$} = C u + \nabla \cdot \mu (\nabla u + (\nabla u)^T) = f \) on a single SAMRAI::hier::PatchLevel using PETSc. More...

Typedefs
template<typename T >
using	EigenAlignedVector = std::vector< T >
using	Matrix2d = Eigen::Matrix< double, 2, 2 >
using	Vector2d = Eigen::Matrix< double, 2, 1 >
using	ColumnVector2d = Eigen::Matrix< double, 2, 1 >
using	RowVector2d = Eigen::Matrix< double, 1, 2 >
using	Matrix3d = Eigen::Matrix< double, 3, 3 >
using	Vector3d = Eigen::Matrix< double, 3, 1 >
using	ColumnVector3d = Eigen::Matrix< double, 3, 1 >
using	RowVector3d = Eigen::Matrix< double, 1, 3 >
using	MatrixNd = Eigen::Matrix< double, NDIM, NDIM >
using	VectorNd = Eigen::Matrix< double, NDIM, 1 >
using	ColumnVectorNd = Eigen::Matrix< double, NDIM, 1 >
using	RowVectorNd = Eigen::Matrix< double, 1, NDIM >
using	MatrixXd = Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic >
using	VectorXd = Eigen::Matrix< double, Eigen::Dynamic, 1 >
using	ColumnVectorXd = Eigen::Matrix< double, Eigen::Dynamic, 1 >
using	RowVectorXd = Eigen::Matrix< double, 1, Eigen::Dynamic >
using	Matrix = MatrixNd
using	Point = VectorNd
using	Vector = VectorNd
using	RigidDOFVector = Eigen::Matrix< double, s_max_free_dofs, 1 >
using	FreeRigidDOFVector = Eigen::Matrix< int, s_max_free_dofs, 1 >
using	RDV = RigidDOFVector
using	FRDV = FreeRigidDOFVector
using	IndexFortranOrder = struct IndexOrder< SAMRAI::hier::Index< NDIM > >
using	CellIndexFortranOrder = struct IndexOrder< SAMRAI::pdat::CellIndex< NDIM > >
using	quadrature_key_type = std::tuple< libMesh::ElemType, libMesh::QuadratureType, libMesh::Order, bool >
using	ScalarMeshFcnPtr = void(*)(double &F, const libMesh::TensorValue< double > &FF, const libMesh::Point &x, const libMesh::Point &X, libMesh::Elem *elem, const std::vector< const std::vector< double > * > &system_var_data, const std::vector< const std::vector< libMesh::VectorValue< double > > * > &system_grad_var_data, double data_time, void *ctx)
using	VectorMeshFcnPtr = void(*)(libMesh::VectorValue< double > &F, const libMesh::TensorValue< double > &FF, const libMesh::Point &x, const libMesh::Point &X, libMesh::Elem *elem, const std::vector< const std::vector< double > * > &system_var_data, const std::vector< const std::vector< libMesh::VectorValue< double > > * > &system_grad_var_data, double data_time, void *ctx)
using	TensorMeshFcnPtr = void(*)(libMesh::TensorValue< double > &F, const libMesh::TensorValue< double > &FF, const libMesh::Point &x, const libMesh::Point &X, libMesh::Elem *elem, const std::vector< const std::vector< double > * > &system_var_data, const std::vector< const std::vector< libMesh::VectorValue< double > > * > &system_grad_var_data, double data_time, void *ctx)
using	ScalarSurfaceFcnPtr = void(*)(double &F, const libMesh::VectorValue< double > &n, const libMesh::VectorValue< double > &N, const libMesh::TensorValue< double > &FF, const libMesh::Point &x, const libMesh::Point &X, libMesh::Elem *elem, unsigned short int side, const std::vector< const std::vector< double > * > &system_var_data, const std::vector< const std::vector< libMesh::VectorValue< double > > * > &system_grad_var_data, double data_time, void *ctx)
using	VectorSurfaceFcnPtr = void(*)(libMesh::VectorValue< double > &F, const libMesh::VectorValue< double > &n, const libMesh::VectorValue< double > &N, const libMesh::TensorValue< double > &FF, const libMesh::Point &x, const libMesh::Point &X, libMesh::Elem *elem, unsigned short int side, const std::vector< const std::vector< double > * > &system_var_data, const std::vector< const std::vector< libMesh::VectorValue< double > > * > &system_grad_var_data, double data_time, void *ctx)
using	TensorSurfaceFcnPtr = void(*)(libMesh::TensorValue< double > &F, const libMesh::VectorValue< double > &n, const libMesh::VectorValue< double > &N, const libMesh::TensorValue< double > &FF, const libMesh::Point &x, const libMesh::Point &X, libMesh::Elem *elem, unsigned short int side, const std::vector< const std::vector< double > * > &system_var_data, const std::vector< const std::vector< libMesh::VectorValue< double > > * > &system_grad_var_data, double data_time, void *ctx)
using	LNodeIndexSet = LSet< LNodeIndex >
using	LNodeIndexSetData = LIndexSetData< LNodeIndex >
using	LNodeIndexSetDataFactory = LIndexSetDataFactory< LNodeIndex >
using	LNodeIndexSetDataIterator = LSetDataIterator< LNodeIndex >
using	LNodeIndexSetVariable = LIndexSetVariable< LNodeIndex >
using	LNodeIndexTransaction = LTransaction< LNodeIndex >
using	LNodeSet = LSet< LNode >
using	LNodeSetData = LIndexSetData< LNode >
using	LNodeSetDataFactory = LIndexSetDataFactory< LNode >
using	LNodeSetDataIterator = LSetDataIterator< LNode >
using	LNodeSetVariable = LIndexSetVariable< LNode >
using	LNodeTransaction = LTransaction< LNode >

Enumerations
enum	FEUpdateFlags {   update_default = 0, update_phi = 1, update_dphi = 2, update_contravariants = 4,   update_covariants = 8, update_jacobians = 16, update_JxW = 32, update_quadrature_points = 64 }
enum	MGCycleType {   F_CYCLE, FMG_CYCLE, V_CYCLE, W_CYCLE,   UNKNOWN_MG_CYCLE_TYPE = -1 }
	Enumerated type for different multigrid cycle types. More...
enum	RegridMode { STANDARD, AGGRESSIVE, UNKNOWN_REGRID_MODE = -1 }
	Enumerated type for different regridding modes. More...
enum	VariableContextType { CURRENT_DATA, NEW_DATA, SCRATCH_DATA, UNKNOWN_VARIABLE_CONTEXT_TYPE = -1 }
	Enumerated type for different standard data contexts. More...
enum	VCInterpType { VC_AVERAGE_INTERP = 1, VC_HARMONIC_INTERP = 2, UNKNOWN_VC_INTERP_TYPE = -1 }
	Enumerated type for different interpolation types for the material properties of the viscous solver. More...
enum	NodeOutsidePatchCheckType { NODE_OUTSIDE_PERMIT = 1, NODE_OUTSIDE_WARN = 2, NODE_OUTSIDE_ERROR = 3, UNKNOWN_NODE_OUTSIDE_PATCH_CHECK_TYPE = -1 }
enum	TimePoint { TimePoint::CURRENT_TIME, TimePoint::HALF_TIME, TimePoint::NEW_TIME, TimePoint::UNKNOWN_TIME }

Functions
std::vector< SAMRAI::hier::Box< NDIM > >	merge_boxes_by_longest_edge (const std::vector< SAMRAI::hier::Box< NDIM > > &boxes)
FEUpdateFlags	operator& (const FEUpdateFlags f1, const FEUpdateFlags f2)
FEUpdateFlags	operator| (const FEUpdateFlags f1, const FEUpdateFlags f2)
FEUpdateFlags &	operator|= (FEUpdateFlags &f1, const FEUpdateFlags f2)
FEUpdateFlags &	operator&= (FEUpdateFlags &f1, const FEUpdateFlags f2)
template<typename T >
T	string_to_enum (const std::string &)
	Routine for converting strings to enums. More...
template<typename T >
std::string	enum_to_string (T)
	Routine for converting enums to strings. More...
template<>
MGCycleType	string_to_enum< MGCycleType > (const std::string &val)
template<>
std::string	enum_to_string< MGCycleType > (MGCycleType val)
template<>
RegridMode	string_to_enum< RegridMode > (const std::string &val)
template<>
std::string	enum_to_string< RegridMode > (RegridMode val)
template<>
VariableContextType	string_to_enum< VariableContextType > (const std::string &val)
template<>
std::string	enum_to_string< VariableContextType > (VariableContextType val)
template<>
VCInterpType	string_to_enum< VCInterpType > (const std::string &val)
template<>
std::string	enum_to_string< VCInterpType > (VCInterpType val)
template<>
NodeOutsidePatchCheckType	string_to_enum< NodeOutsidePatchCheckType > (const std::string &val)
template<>
std::string	enum_to_string< NodeOutsidePatchCheckType > (NodeOutsidePatchCheckType val)
template<>
TimePoint	string_to_enum< TimePoint > (const std::string &val)
template<>
std::string	enum_to_string< TimePoint > (TimePoint val)
MPI_Datatype	mpi_type_id (const double)
MPI_Datatype	mpi_type_id (const std::pair< double, int >)
MPI_Datatype	mpi_type_id (const int)
MPI_Datatype	mpi_type_id (const std::pair< int, int >)
MPI_Datatype	mpi_type_id (const float)
MPI_Datatype	mpi_type_id (const std::pair< float, int >)
MPI_Datatype	mpi_type_id (const char)
MPI_Datatype	mpi_type_id (const unsigned int)
template<typename T >
MPI_Datatype	mpi_type_id (const T &)
bool	rel_equal_eps (double a, double b, double eps=std::sqrt(std::numeric_limits< double >::epsilon()))
bool	abs_equal_eps (double a, double b, double eps=std::sqrt(std::numeric_limits< double >::epsilon()))
	Check whether the absolute difference between a and b are within the threshold eps. More...
std::string	get_data_time_str (const double data_time, const double current_time, const double new_time)
double	get_min_patch_dx (const SAMRAI::hier::PatchLevel< NDIM > &patch_level)
template<class T , unsigned N>
std::array< T, N >	array_constant (const T &v)
template<class T , unsigned N>
std::array< T, N >	array_one ()
template<class T , unsigned N>
std::array< T, N >	array_zero ()
bool	level_can_be_refined (int level_number, int max_levels)
std::pair< int, int >	voigt_to_tensor_idx (const int k)
int	tensor_idx_to_voigt (const std::pair< int, int > &idx)
double	smooth_heaviside (const double &phi, const double &alpha)
double	smooth_delta (const double &phi, const double &alpha)
double	discontinuous_heaviside (const double &phi)
void	deallocate_vector_data (SAMRAI::solv::SAMRAIVectorReal< NDIM, double > &x, int coarsest_ln=invalid_level_number, int finest_ln=invalid_level_number)
void	free_vector_components (SAMRAI::solv::SAMRAIVectorReal< NDIM, double > &x, int coarsest_ln=invalid_level_number, int finest_ln=invalid_level_number)
template<class T >
const T &	checked_dereference (const SAMRAI::tbox::Pointer< T > &p)
template<class T >
T &	checked_dereference (SAMRAI::tbox::Pointer< T > &p)
std::vector< double >	interpolate (const VectorNd &X, int data_idx, SAMRAI::tbox::Pointer< SAMRAI::hier::Variable< NDIM > > Q_var, int Q_depth, SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > > patch_hierarchy, std::string kernel_fcn="IB_4")
std::vector< double >	interpolate (const std::vector< VectorNd > &X, int data_idx, SAMRAI::tbox::Pointer< SAMRAI::hier::Variable< NDIM > > Q_var, int Q_depth, SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > > patch_hierarchy, std::string kernel_fcn="IB_4")
int	get_dim (const libMesh::ElemType elem_type)
std::size_t	get_n_nodes (const libMesh::ElemType elem_type)
libMesh::Order	get_default_order (const libMesh::ElemType elem_type)
void	copy_and_synch (libMesh::NumericVector< double > &v_in, libMesh::NumericVector< double > &v_out, const bool close_v_in=true, const bool close_v_out=true)
void	batch_vec_copy (const std::vector< libMesh::PetscVector< double > * > &x_vecs, const std::vector< libMesh::PetscVector< double > * > &y_vecs)
void	batch_vec_copy (const std::vector< std::vector< libMesh::PetscVector< double > * > > &x_vecs, const std::vector< std::vector< libMesh::PetscVector< double > * > > &y_vecs)
void	batch_vec_assembly (const std::vector< libMesh::PetscVector< double > * > &vecs)
void	batch_vec_assembly (const std::vector< std::vector< libMesh::PetscVector< double > * > > &vecs)
void	batch_vec_ghost_update (const std::vector< libMesh::PetscVector< double > * > &vecs, const InsertMode insert_mode, const ScatterMode scatter_mode)
void	batch_vec_ghost_update (const std::vector< std::vector< libMesh::PetscVector< double > * > > &vecs, const InsertMode insert_mode, const ScatterMode scatter_mode)
void	setup_system_vectors (libMesh::EquationSystems *equation_systems, const std::vector< std::string > &system_names, const std::vector< std::string > &vector_names, const bool from_restart)
void	setup_system_vector (libMesh::System &system, const std::string &vector_name, const bool from_restart)
void	copy_dof_ids_to_vector (const unsigned int var_n, const boost::multi_array< libMesh::dof_id_type, 2 > &elem_dofs, std::vector< libMesh::dof_id_type > &dofs)
void	apply_transposed_constraint_matrix (const libMesh::DofMap &dof_map, libMesh::PetscVector< double > &rhs)
quadrature_key_type	getQuadratureKey (libMesh::QuadratureType quad_type, libMesh::Order order, bool use_adaptive_quadrature, double point_density, bool allow_rules_with_negative_weights, const libMesh::Elem *elem, const boost::multi_array< double, 2 > &X_node, double dx_min)
template<class MultiArray , class Array >
void	get_values_for_interpolation (MultiArray &U_node, const libMesh::PetscVector< double > &U_petsc_vec, const Array &U_local_soln, const std::vector< unsigned int > &dof_indices)
template<class MultiArray_1 , class MultiArray_2 , class Array >
void	get_values_for_interpolation (MultiArray_1 &U_node, const libMesh::PetscVector< double > &U_petsc_vec, const Array &U_local_soln, const MultiArray_2 &dof_indices)
template<class MultiArray >
void	get_values_for_interpolation (MultiArray &U_node, libMesh::NumericVector< double > &U_vec, const std::vector< unsigned int > &dof_indices)
template<class MultiArray_1 , class MultiArray_2 >
void	get_values_for_interpolation (MultiArray_1 &U_node, libMesh::NumericVector< double > &U_vec, const MultiArray_2 &dof_indices)
template<class MultiArray >
void	interpolate (double &U, const int qp, const MultiArray &U_node, const std::vector< std::vector< double > > &phi)
template<class MultiArray >
double	interpolate (const int qp, const MultiArray &U_node, const std::vector< std::vector< double > > &phi)
template<class MultiArray >
void	interpolate (double *const U, const int qp, const MultiArray &U_node, const std::vector< std::vector< double > > &phi)
template<class MultiArray >
void	interpolate (libMesh::TypeVector< double > &U, const int qp, const MultiArray &U_node, const std::vector< std::vector< double > > &phi)
template<class MultiArray >
void	jacobian (libMesh::TypeTensor< double > &dX_ds, const int qp, const MultiArray &X_node, const std::vector< std::vector< libMesh::VectorValue< double > > > &dphi)
void	tensor_inverse (libMesh::TensorValue< double > &A_inv, const libMesh::TensorValue< double > &A, const int dim=NDIM)
libMesh::TensorValue< double >	tensor_inverse (const libMesh::TensorValue< double > &A, const int dim=NDIM)
void	tensor_inverse_transpose (libMesh::TensorValue< double > &A_inv_trans, const libMesh::TensorValue< double > &A, const int dim=NDIM)
libMesh::TensorValue< double >	tensor_inverse_transpose (const libMesh::TensorValue< double > &A, const int dim=NDIM)
void	outer_product (libMesh::TensorValue< double > &u_prod_v, const libMesh::TypeVector< double > &u, const libMesh::TypeVector< double > &v, const int dim=NDIM)
libMesh::TensorValue< double >	outer_product (const libMesh::TypeVector< double > &u, const libMesh::TypeVector< double > &v, const int dim=NDIM)
bool	intersect_line_with_edge (std::vector< std::pair< double, libMesh::Point > > &t_vals, libMesh::Edge *elem, libMesh::Point r, libMesh::VectorValue< double > q, const double tol=0.0)
bool	intersect_line_with_face (std::vector< std::pair< double, libMesh::Point > > &t_vals, libMesh::Face *elem, libMesh::Point r, libMesh::VectorValue< double > q, const double tol=0.0)
void	get_nodal_dof_indices (const libMesh::DofMap &dof_map, const libMesh::Node *const node, const unsigned int variable_n, std::vector< libMesh::dof_id_type > &nodal_indices)
template<class MultiArray >
double	get_max_edge_length (const libMesh::Elem *const elem, const MultiArray &X_node)
void	write_elem_partitioning (const std::string &file_name, const libMesh::System &position_system)
void	write_node_partitioning (const std::string &file_name, const libMesh::System &position_system)
std::vector< libMesh::BoundingBox >	get_local_element_bounding_boxes (const libMesh::MeshBase &mesh, const libMesh::System &X_system, libMesh::QuadratureType quad_type, libMesh::Order quad_order, bool use_adaptive_quadrature, double point_density, bool allow_rules_with_negative_weights, double patch_dx_min)
std::vector< libMesh::BoundingBox >	get_local_element_bounding_boxes (const libMesh::MeshBase &mesh, const libMesh::System &X_system)
std::vector< libMesh::BoundingBox >	get_global_element_bounding_boxes (const libMesh::MeshBase &mesh, const std::vector< libMesh::BoundingBox > &local_bboxes)
std::vector< libMesh::BoundingBox >	get_global_element_bounding_boxes (const libMesh::MeshBase &mesh, const libMesh::System &X_system)
Vec	setup_petsc_vector (const unsigned int num_local_nodes, const unsigned int depth, const std::vector< int > &nonlocal_petsc_indices)
void	update_snapshot (SnapshotCache &cache, int u_idx, double time, SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > > current_hierarchy, double tol=1.0e-8)
void	fill_snapshot_on_hierarchy (SnapshotCache &cache, int u_idx, double time, SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > > current_hierarchy, const std::string &snapshot_refine_type, double tol=1.0e-8)
void	fill_snapshot_at_time (SnapshotCache &snapshot_cache, int u_idx, double t, int scr_idx, SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > > hierarchy, const std::string &refine_type, SAMRAI::tbox::Pointer< SAMRAI::math::HierarchyDataOpsReal< NDIM, double > > hier_data_ops=nullptr, double period=std::numeric_limits< double >::quiet_NaN())
void	reportPETScKSPConvergedReason (const std::string &object_name, const KSPConvergedReason &reason, std::ostream &os)
	Report the KSPConvergedReason. More...
void	reportPETScSNESConvergedReason (const std::string &object_name, const SNESConvergedReason &reason, std::ostream &os)
	Report the SNESConvergedReason. More...
std::array< HYPRE_Int, NDIM >	hypre_array (const SAMRAI::hier::Index< NDIM > &index)
	Helper function to convert SAMRAI indices to Hypre integers. More...
void	copyFromHypre (SAMRAI::pdat::CellData< NDIM, double > &dst_data, const std::vector< HYPRE_StructVector > &vectors, const SAMRAI::hier::Box< NDIM > &box)
	Copy data from a vector of Hypre vectors to SAMRAI cell centered data with depth equal to number of Hypre vectors. More...
void	copyFromHypre (SAMRAI::pdat::SideData< NDIM, double > &dst_data, HYPRE_SStructVector vector, const SAMRAI::hier::Box< NDIM > &box)
	Copy data from a Hypre vector to SAMRAI side centered data. More...
void	copyToHypre (const std::vector< HYPRE_StructVector > &vectors, SAMRAI::pdat::CellData< NDIM, double > &src_data, const SAMRAI::hier::Box< NDIM > &box)
	Copy data from SAMRAI cell centered data to Hypre vectors. More...
void	copyToHypre (HYPRE_SStructVector &vector, SAMRAI::pdat::SideData< NDIM, double > &src_data, const SAMRAI::hier::Box< NDIM > &box)
	Copy data from SAMRAI side centered data to a Hypre vector. More...

Variables
static const bool	ENABLE_TIMERS = true
static const int	s_max_free_dofs = NDIM * (NDIM + 1) / 2
static const int	invalid_level_number = -1
static const int	invalid_index = -1

Typedef Documentation

EigenAlignedVector

template<typename T >

using IBTK::EigenAlignedVector = typedef std::vector<T>

Eigen types have special alignment requirements and require a specific memory allocator. This is a convenience type alias for a std::vector with the correct allocator.

Deprecated:

This alias is no longer necessary.

Matrix2d

using IBTK::Matrix2d = typedef Eigen::Matrix<double, 2, 2>

Vector2d

using IBTK::Vector2d = typedef Eigen::Matrix<double, 2, 1>

ColumnVector2d

using IBTK::ColumnVector2d = typedef Eigen::Matrix<double, 2, 1>

RowVector2d

using IBTK::RowVector2d = typedef Eigen::Matrix<double, 1, 2>

Matrix3d

using IBTK::Matrix3d = typedef Eigen::Matrix<double, 3, 3>

Vector3d

using IBTK::Vector3d = typedef Eigen::Matrix<double, 3, 1>

ColumnVector3d

using IBTK::ColumnVector3d = typedef Eigen::Matrix<double, 3, 1>

RowVector3d

using IBTK::RowVector3d = typedef Eigen::Matrix<double, 1, 3>

MatrixNd

using IBTK::MatrixNd = typedef Eigen::Matrix<double, NDIM, NDIM>

VectorNd

using IBTK::VectorNd = typedef Eigen::Matrix<double, NDIM, 1>

ColumnVectorNd

using IBTK::ColumnVectorNd = typedef Eigen::Matrix<double, NDIM, 1>

RowVectorNd

using IBTK::RowVectorNd = typedef Eigen::Matrix<double, 1, NDIM>

MatrixXd

using IBTK::MatrixXd = typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>

VectorXd

using IBTK::VectorXd = typedef Eigen::Matrix<double, Eigen::Dynamic, 1>

ColumnVectorXd

using IBTK::ColumnVectorXd = typedef Eigen::Matrix<double, Eigen::Dynamic, 1>

RowVectorXd

using IBTK::RowVectorXd = typedef Eigen::Matrix<double, 1, Eigen::Dynamic>

Matrix

using IBTK::Matrix = typedef MatrixNd

Point

using IBTK::Point = typedef VectorNd

Vector

using IBTK::Vector = typedef VectorNd

RigidDOFVector

using IBTK::RigidDOFVector = typedef Eigen::Matrix<double, s_max_free_dofs, 1>

FreeRigidDOFVector

using IBTK::FreeRigidDOFVector = typedef Eigen::Matrix<int, s_max_free_dofs, 1>

RDV

using IBTK::RDV = typedef RigidDOFVector

FRDV

using IBTK::FRDV = typedef FreeRigidDOFVector

IndexFortranOrder

using IBTK::IndexFortranOrder = typedef struct IndexOrder<SAMRAI::hier::Index<NDIM> >

CellIndexFortranOrder

using IBTK::CellIndexFortranOrder = typedef struct IndexOrder<SAMRAI::pdat::CellIndex<NDIM> >

quadrature_key_type

using IBTK::quadrature_key_type = typedef std::tuple<libMesh::ElemType, libMesh::QuadratureType, libMesh::Order, bool>

ScalarMeshFcnPtr

using IBTK::ScalarMeshFcnPtr = typedef void (*)(double& F, const libMesh::TensorValue<double>& FF, const libMesh::Point& x, const libMesh::Point& X, libMesh::Elem* elem, const std::vector<const std::vector<double>*>& system_var_data, const std::vector<const std::vector<libMesh::VectorValue<double> >*>& system_grad_var_data, double data_time, void* ctx)

VectorMeshFcnPtr

using IBTK::VectorMeshFcnPtr = typedef void (*)(libMesh::VectorValue<double>& F, const libMesh::TensorValue<double>& FF, const libMesh::Point& x, const libMesh::Point& X, libMesh::Elem* elem, const std::vector<const std::vector<double>*>& system_var_data, const std::vector<const std::vector<libMesh::VectorValue<double> >*>& system_grad_var_data, double data_time, void* ctx)

TensorMeshFcnPtr

using IBTK::TensorMeshFcnPtr = typedef void (*)(libMesh::TensorValue<double>& F, const libMesh::TensorValue<double>& FF, const libMesh::Point& x, const libMesh::Point& X, libMesh::Elem* elem, const std::vector<const std::vector<double>*>& system_var_data, const std::vector<const std::vector<libMesh::VectorValue<double> >*>& system_grad_var_data, double data_time, void* ctx)

ScalarSurfaceFcnPtr

using IBTK::ScalarSurfaceFcnPtr = typedef void (*)(double& F, const libMesh::VectorValue<double>& n, const libMesh::VectorValue<double>& N, const libMesh::TensorValue<double>& FF, const libMesh::Point& x, const libMesh::Point& X, libMesh::Elem* elem, unsigned short int side, const std::vector<const std::vector<double>*>& system_var_data, const std::vector<const std::vector<libMesh::VectorValue<double> >*>& system_grad_var_data, double data_time, void* ctx)

VectorSurfaceFcnPtr

using IBTK::VectorSurfaceFcnPtr = typedef void (*)(libMesh::VectorValue<double>& F, const libMesh::VectorValue<double>& n, const libMesh::VectorValue<double>& N, const libMesh::TensorValue<double>& FF, const libMesh::Point& x, const libMesh::Point& X, libMesh::Elem* elem, unsigned short int side, const std::vector<const std::vector<double>*>& system_var_data, const std::vector<const std::vector<libMesh::VectorValue<double> >*>& system_grad_var_data, double data_time, void* ctx)

TensorSurfaceFcnPtr

using IBTK::TensorSurfaceFcnPtr = typedef void (*)(libMesh::TensorValue<double>& F, const libMesh::VectorValue<double>& n, const libMesh::VectorValue<double>& N, const libMesh::TensorValue<double>& FF, const libMesh::Point& x, const libMesh::Point& X, libMesh::Elem* elem, unsigned short int side, const std::vector<const std::vector<double>*>& system_var_data, const std::vector<const std::vector<libMesh::VectorValue<double> >*>& system_grad_var_data, double data_time, void* ctx)

LNodeIndexSet

using IBTK::LNodeIndexSet = typedef LSet<LNodeIndex>

LNodeIndexSetData

using IBTK::LNodeIndexSetData = typedef LIndexSetData<LNodeIndex>

LNodeIndexSetDataFactory

using IBTK::LNodeIndexSetDataFactory = typedef LIndexSetDataFactory<LNodeIndex>

LNodeIndexSetDataIterator

using IBTK::LNodeIndexSetDataIterator = typedef LSetDataIterator<LNodeIndex>

LNodeIndexSetVariable

using IBTK::LNodeIndexSetVariable = typedef LIndexSetVariable<LNodeIndex>

LNodeIndexTransaction

using IBTK::LNodeIndexTransaction = typedef LTransaction<LNodeIndex>

LNodeSet

using IBTK::LNodeSet = typedef LSet<LNode>

LNodeSetData

using IBTK::LNodeSetData = typedef LIndexSetData<LNode>

LNodeSetDataFactory

using IBTK::LNodeSetDataFactory = typedef LIndexSetDataFactory<LNode>

LNodeSetDataIterator

using IBTK::LNodeSetDataIterator = typedef LSetDataIterator<LNode>

LNodeSetVariable

using IBTK::LNodeSetVariable = typedef LIndexSetVariable<LNode>

LNodeTransaction

using IBTK::LNodeTransaction = typedef LTransaction<LNode>

Enumeration Type Documentation

FEUpdateFlags

enum IBTK::FEUpdateFlags

Enumeration describing the various update options available for libMesh::FEBase objects stored by FECache. Multiple flags can be enabled with bitwise or operations, e.g.,

const IBTK::FEUpdateFlags update_flags = IBTK::update_phi | IBTK::update_dphi;

See IBTK::FECache for more information.

Enumerator
update_default	Do not update anything.
update_phi	Update phi (shape function values).
update_dphi	Update dphi (shape function gradients).
update_contravariants	Update mapping contravariants.
update_covariants	Update mapping covariants.
update_jacobians	Update mapping Jacobians.
update_JxW	Update JxW values.
update_quadrature_points	Update mapped quadrature points.

MGCycleType

enum IBTK::MGCycleType

Enumerator
F_CYCLE
FMG_CYCLE
V_CYCLE
W_CYCLE
UNKNOWN_MG_CYCLE_TYPE

RegridMode

enum IBTK::RegridMode

Enumerator
STANDARD
AGGRESSIVE
UNKNOWN_REGRID_MODE

VariableContextType

enum IBTK::VariableContextType

Enumerator
CURRENT_DATA
NEW_DATA
SCRATCH_DATA
UNKNOWN_VARIABLE_CONTEXT_TYPE

VCInterpType

enum IBTK::VCInterpType

Enumerator
VC_AVERAGE_INTERP
VC_HARMONIC_INTERP
UNKNOWN_VC_INTERP_TYPE

NodeOutsidePatchCheckType

enum IBTK::NodeOutsidePatchCheckType

Enumerator
NODE_OUTSIDE_PERMIT
NODE_OUTSIDE_WARN
NODE_OUTSIDE_ERROR
UNKNOWN_NODE_OUTSIDE_PATCH_CHECK_TYPE

TimePoint

enum IBTK::TimePoint

strong

Enumerator
CURRENT_TIME
HALF_TIME
NEW_TIME
UNKNOWN_TIME

Function Documentation

merge_boxes_by_longest_edge()

std::vector<SAMRAI::hier::Box<NDIM> > IBTK::merge_boxes_by_longest_edge

(

const std::vector< SAMRAI::hier::Box< NDIM > > &

boxes

)

Given a set of boxes (which describe a region in index space), return another set of boxes whose union covers the same index space. The returned set of boxes is formed by merging boxes in boxes along their longest edges.

operator&()

FEUpdateFlags IBTK::operator& ( const FEUpdateFlags  f1, const FEUpdateFlags  f2  )

inline

Permit modifying FEUpdateFlags as though it were an integer type.

operator|()

FEUpdateFlags IBTK::operator| ( const FEUpdateFlags  f1, const FEUpdateFlags  f2  )

inline

Permit modifying FEUpdateFlags as though it were an integer type.

operator|=()

FEUpdateFlags& IBTK::operator|= ( FEUpdateFlags &  f1, const FEUpdateFlags  f2  )

inline

Permit modifying FEUpdateFlags as though it were an integer type.

operator&=()

FEUpdateFlags& IBTK::operator&= ( FEUpdateFlags &  f1, const FEUpdateFlags  f2  )

inline

Permit modifying FEUpdateFlags as though it were an integer type.

string_to_enum()

template<typename T >

T IBTK::string_to_enum ( const std::string &  )

inline

enum_to_string()

template<typename T >

std::string IBTK::enum_to_string ( T  )

inline

string_to_enum< MGCycleType >()

template<>

MGCycleType IBTK::string_to_enum< MGCycleType > ( const std::string &  val )

inline

enum_to_string< MGCycleType >()

template<>

std::string IBTK::enum_to_string< MGCycleType > ( MGCycleType  val )

inline

string_to_enum< RegridMode >()

template<>

RegridMode IBTK::string_to_enum< RegridMode > ( const std::string &  val )

inline

enum_to_string< RegridMode >()

template<>

std::string IBTK::enum_to_string< RegridMode > ( RegridMode  val )

inline

string_to_enum< VariableContextType >()

template<>

VariableContextType IBTK::string_to_enum< VariableContextType > ( const std::string &  val )

inline

enum_to_string< VariableContextType >()

template<>

std::string IBTK::enum_to_string< VariableContextType > ( VariableContextType  val )

inline

string_to_enum< VCInterpType >()

template<>

VCInterpType IBTK::string_to_enum< VCInterpType > ( const std::string &  val )

inline

enum_to_string< VCInterpType >()

template<>

std::string IBTK::enum_to_string< VCInterpType > ( VCInterpType  val )

inline

string_to_enum< NodeOutsidePatchCheckType >()

template<>

NodeOutsidePatchCheckType IBTK::string_to_enum< NodeOutsidePatchCheckType > ( const std::string &  val )

inline

enum_to_string< NodeOutsidePatchCheckType >()

template<>

std::string IBTK::enum_to_string< NodeOutsidePatchCheckType > ( NodeOutsidePatchCheckType  val )

inline

string_to_enum< TimePoint >()

template<>

TimePoint IBTK::string_to_enum< TimePoint > ( const std::string &  val )

inline

enum_to_string< TimePoint >()

template<>

std::string IBTK::enum_to_string< TimePoint > ( TimePoint  val )

inline

mpi_type_id() [1/9]

MPI_Datatype IBTK::mpi_type_id ( const double  )

inline

mpi_type_id() [2/9]

MPI_Datatype IBTK::mpi_type_id ( const std::pair< double, int >  )

inline

mpi_type_id() [3/9]

MPI_Datatype IBTK::mpi_type_id ( const int  )

inline

mpi_type_id() [4/9]

MPI_Datatype IBTK::mpi_type_id ( const std::pair< int, int >  )

inline

mpi_type_id() [5/9]

MPI_Datatype IBTK::mpi_type_id ( const float  )

inline

mpi_type_id() [6/9]

MPI_Datatype IBTK::mpi_type_id ( const std::pair< float, int >  )

inline

mpi_type_id() [7/9]

MPI_Datatype IBTK::mpi_type_id ( const char  )

inline

mpi_type_id() [8/9]

MPI_Datatype IBTK::mpi_type_id ( const unsigned int  )

inline

mpi_type_id() [9/9]

template<typename T >

MPI_Datatype IBTK::mpi_type_id ( const T &  )

inline

rel_equal_eps()

bool IBTK::rel_equal_eps ( double  a, double  b, double  eps = std::sqrt(std::numeric_limits<double>::epsilon())  )

inline

Check whether the relative difference between a and b are within the threshold eps.

Note

This function should be used with caution to check numbers close to zero. In this case, consider using the abs_equal_eps function.

abs_equal_eps()

bool IBTK::abs_equal_eps ( double  a, double  b, double  eps = std::sqrt(std::numeric_limits<double>::epsilon())  )

inline

Note

This function should be used with caution to check numbers that have large magnitudes. In these cases, consider using the rel_equal_eps function.

get_data_time_str()

std::string IBTK::get_data_time_str ( const double  data_time, const double  current_time, const double  new_time  )

inline

get_min_patch_dx()

double IBTK::get_min_patch_dx

(

const SAMRAI::hier::PatchLevel< NDIM > &

patch_level

)

Get the smallest cell width on the specified level. This operation is collective.

array_constant()

template<class T , unsigned N>

std::array<T, N> IBTK::array_constant ( const T &  v )

inline

array_one()

template<class T , unsigned N>

std::array<T, N> IBTK::array_one ( )

inline

array_zero()

template<class T , unsigned N>

std::array<T, N> IBTK::array_zero ( )

inline

level_can_be_refined()

bool IBTK::level_can_be_refined ( int  level_number, int  max_levels  )

inline

voigt_to_tensor_idx()

std::pair<int, int> IBTK::voigt_to_tensor_idx ( const int  k )

inline

Convert a Voigt notation index to the corresponding symmetric tensor index. This function only returns the upper triangular index.

tensor_idx_to_voigt()

int IBTK::tensor_idx_to_voigt ( const std::pair< int, int > &  idx )

inline

Convert a symmetric tensor index to the corresponding Voigt notation index.

smooth_heaviside()

double IBTK::smooth_heaviside ( const double &  phi, const double &  alpha  )

inline

Smooth heaviside function.

smooth_delta()

double IBTK::smooth_delta ( const double &  phi, const double &  alpha  )

inline

Smooth delta function.

discontinuous_heaviside()

double IBTK::discontinuous_heaviside ( const double &  phi )

inline

Discontinuous heaviside function.

deallocate_vector_data()

void IBTK::deallocate_vector_data ( SAMRAI::solv::SAMRAIVectorReal< NDIM, double > &  x, int  coarsest_ln = invalid_level_number, int  finest_ln = invalid_level_number  )

inline

Deallocate a SAMRAIVectorReal.

free_vector_components()

void IBTK::free_vector_components ( SAMRAI::solv::SAMRAIVectorReal< NDIM, double > &  x, int  coarsest_ln = invalid_level_number, int  finest_ln = invalid_level_number  )

inline

Free the components of a SAMRAIVectorReal.

checked_dereference() [1/2]

template<class T >

const T& IBTK::checked_dereference

(

const SAMRAI::tbox::Pointer< T > &

p

)

Utility function which asserts that the SAMRAI pointer is not null.

This is useful for writing generic code in which we might want to assert that a pointer is not null in the initialization list where we cannot use the normal assertion macro.

checked_dereference() [2/2]

template<class T >

T& IBTK::checked_dereference

(

SAMRAI::tbox::Pointer< T > &

p

)

Same idea, but for a non-const pointer.

interpolate() [1/6]

std::vector<double> IBTK::interpolate	(	const VectorNd &	X,
		int	data_idx,
		SAMRAI::tbox::Pointer< SAMRAI::hier::Variable< NDIM > >	Q_var,
		int	Q_depth,
		SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > >	patch_hierarchy,
		std::string	kernel_fcn = "IB_4"
	)

interpolate() [2/6]

std::vector<double> IBTK::interpolate	(	const std::vector< VectorNd > &	X,
		int	data_idx,
		SAMRAI::tbox::Pointer< SAMRAI::hier::Variable< NDIM > >	Q_var,
		int	Q_depth,
		SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > >	patch_hierarchy,
		std::string	kernel_fcn = "IB_4"
	)

get_dim()

int IBTK::get_dim ( const libMesh::ElemType  elem_type )

inline

Utility function for getting the dimensionality of a libMesh element type.

get_n_nodes()

std::size_t IBTK::get_n_nodes ( const libMesh::ElemType  elem_type )

inline

Utility function for getting the number of nodes of a libMesh element type.

get_default_order()

libMesh::Order IBTK::get_default_order ( const libMesh::ElemType  elem_type )

inline

Utility function for getting the default order of a libMesh element type.

copy_and_synch()

void IBTK::copy_and_synch ( libMesh::NumericVector< double > &  v_in, libMesh::NumericVector< double > &  v_out, const bool  close_v_in = true, const bool  close_v_out = true  )

inline

batch_vec_copy() [1/2]

void IBTK::batch_vec_copy ( const std::vector< libMesh::PetscVector< double > * > &  x_vecs, const std::vector< libMesh::PetscVector< double > * > &  y_vecs  )

inline

batch_vec_copy() [2/2]

void IBTK::batch_vec_copy ( const std::vector< std::vector< libMesh::PetscVector< double > * > > &  x_vecs, const std::vector< std::vector< libMesh::PetscVector< double > * > > &  y_vecs  )

inline

batch_vec_assembly() [1/2]

void IBTK::batch_vec_assembly ( const std::vector< libMesh::PetscVector< double > * > &  vecs )

inline

batch_vec_assembly() [2/2]

void IBTK::batch_vec_assembly ( const std::vector< std::vector< libMesh::PetscVector< double > * > > &  vecs )

inline

batch_vec_ghost_update() [1/2]

void IBTK::batch_vec_ghost_update ( const std::vector< libMesh::PetscVector< double > * > &  vecs, const InsertMode  insert_mode, const ScatterMode  scatter_mode  )

inline

batch_vec_ghost_update() [2/2]

void IBTK::batch_vec_ghost_update ( const std::vector< std::vector< libMesh::PetscVector< double > * > > &  vecs, const InsertMode  insert_mode, const ScatterMode  scatter_mode  )

inline

setup_system_vectors()

void IBTK::setup_system_vectors	(	libMesh::EquationSystems *	equation_systems,
		const std::vector< std::string > &	system_names,
		const std::vector< std::string > &	vector_names,
		const bool	from_restart
	)

Convenience function that calls setup_system_vector for all specified systems and vector names. This function is aware of System::rhs and will reset it correctly.

setup_system_vector()

void IBTK::setup_system_vector	(	libMesh::System &	system,
		const std::string &	vector_name,
		const bool	from_restart
	)

Setup the vector with name vector_name in the libMesh::System object named system_name.

The behavior of this function depends on whether or not we are working with restart data:

1. If from_restart is false then the vector is added to the system in the normal way.
2. If from_restart is true then the vector stored in the System corresponding to the given name is overwritten and has its type changed from PARALLEL to GHOSTED. This works around a bug in libMesh versions prior to 1.7.0 where vectors are always serialized as PARALLEL.

copy_dof_ids_to_vector()

void IBTK::copy_dof_ids_to_vector ( const unsigned int  var_n, const boost::multi_array< libMesh::dof_id_type, 2 > &  elem_dofs, std::vector< libMesh::dof_id_type > &  dofs  )

inline

Utility function for copying dofs from the format used by IBAMR for caching to the format libMesh expects.

Parameters

[in]	var_n	The variable number.
[in]	elem_dofs	Dofs on the current element, indexed first by variable.
[out]	dofs	vector containing the dofs for the given vector.

apply_transposed_constraint_matrix()

void IBTK::apply_transposed_constraint_matrix	(	const libMesh::DofMap &	dof_map,
		libMesh::PetscVector< double > &	rhs
	)

Apply in-place the action of the transpose of the constraint matrix stored by dof_map to rhs.

This function is necessary (instead of the usual procedure, where we apply constraints to element vectors during assembly) when assembly is done with the IB partitioning since, in that case, the constraints corresponding to the elements used for assembly are not available. To resolve this problem we recommend doing the following:

1. Assemble a RHS vector without considering the constraints (this is done, for example, in FEDataManager::interpWeighted()).
2. Assemble the vector in parallel in the normal way (i.e., via VecGhostUpdateBegin() and VecGhostUpdateEnd()). This function assumes that the input vector contains up-to-date ghost data for all entries relevant to resolving constraints.
3. Call this function. This function replaces the ghost values in the input vector with entries that need to be summed into off-processor entries (i.e., the values generated during constraint resolution when a locally owned dof is constrained by values of off-processor dofs.)
4. Do assembly a second time (i.e., again with VecGhostUpdateBegin() and VecGhostUpdateEnd()).

getQuadratureKey()

quadrature_key_type IBTK::getQuadratureKey	(	libMesh::QuadratureType	quad_type,
		libMesh::Order	order,
		bool	use_adaptive_quadrature,
		double	point_density,
		bool	allow_rules_with_negative_weights,
		const libMesh::Elem *	elem,
		const boost::multi_array< double, 2 > &	X_node,
		double	dx_min
	)

Return the quadrature key description (see QuadratureCache and FECache) of a quadrature rule.

Parameters

[in]	quad_type	The type of quadrature rule to use. At the present time only QGAUSS and QGRID are supported.
[in]	order	The order of the quadrature rule.
[in]	use_adaptive_quadrature	Whether or not the element data should be read (and order possibly modified) to get the correct quadrature point spacing.
[in]	point_density	Parameter for computing the number of points in the quadrature rule. The number of points is computed as ceil(point_density * hmax / dx_min), where hmax is the maximum edge length of the deformed element (i.e., with nodal coordinates given by X_node).
[in]	allow_rules_with_negative_weights	Whether the quadrature rule is allowed to have any negative weights.
[in]	elem	The libMesh element. The quadrature rule generated by this function will always have enough points to integrate the basis functions defined on the element exactly.
[in]	X_node	Values of elem's shape functions of the structure location field (i.e., X): for interpolatory finite elements (e.g., libMesh::LAGRANGE) these the actual coordinates of the node (since shape functions will either be one or zero at nodes). X_node is assumed to be a two-dimensional array whose rows correspond to node number and whose columns correspond to x, y, and (in 3D) z coordinates.
[in]	dx_min	See point_density.

@seealso FEDataManager::updateQuadratureRule.

get_values_for_interpolation() [1/4]

template<class MultiArray , class Array >

void IBTK::get_values_for_interpolation ( MultiArray &  U_node, const libMesh::PetscVector< double > &  U_petsc_vec, const Array &  U_local_soln, const std::vector< unsigned int > &  dof_indices  )

inline

Populate U_node with the finite element solution coefficients on the current element. This particular overload is for scalar finite elements.

Parameters

[out]	U_node	Multidimensional array (usually a boost::multi_array) which will be filled with finite element solution coefficients.
[in]	U_petsc_vec	The relevant finite element solution vector.
[in]	U_local_soln	A localized version of the current solution (i.e., the same information as U_petsc_vec, but accessed with local instead of global indices).
[in]	dof_indices	DoF indices of the current element.

get_values_for_interpolation() [2/4]

template<class MultiArray_1 , class MultiArray_2 , class Array >

void IBTK::get_values_for_interpolation ( MultiArray_1 &  U_node, const libMesh::PetscVector< double > &  U_petsc_vec, const Array &  U_local_soln, const MultiArray_2 &  dof_indices  )

inline

Populate U_node with the finite element solution coefficients on the current element. This particular overload is for vector-valued finite elements.

Parameters

[out]	U_node	Multidimensional array (usually a boost::multi_array) which will be filled with finite element solution coefficients.
[in]	U_petsc_vec	The relevant finite element solution vector.
[in]	U_local_soln	A localized version of the current solution (i.e., the same information as U_petsc_vec, but accessed with local instead of global indices).
[in]	dof_indices	DoF indices of the current element.

get_values_for_interpolation() [3/4]

template<class MultiArray >

void IBTK::get_values_for_interpolation ( MultiArray &  U_node, libMesh::NumericVector< double > &  U_vec, const std::vector< unsigned int > &  dof_indices  )

inline

Populate U_node with the finite element solution coefficients on the current element. This particular overload is for scalar finite elements.

Parameters

[out]	U_node	Multidimensional array (usually a boost::multi_array) which will be filled with finite element solution coefficients.
[in]	U_vec	The relevant finite element solution vector. This must be a libMesh::PetscVector.
[in]	dof_indices	DoF indices of the current element.

get_values_for_interpolation() [4/4]

template<class MultiArray_1 , class MultiArray_2 >

void IBTK::get_values_for_interpolation ( MultiArray_1 &  U_node, libMesh::NumericVector< double > &  U_vec, const MultiArray_2 &  dof_indices  )

inline

Populate U_node with the finite element solution coefficients on the current element. This particular overload is for vector-valued finite elements.

Parameters

[out]	U_node	Multidimensional array (usually a boost::multi_array) which will be filled with finite element solution coefficients.
[in]	U_vec	The relevant finite element solution vector. This must be a libMesh::PetscVector.
[in]	dof_indices	DoF indices of the current element.

interpolate() [3/6]

template<class MultiArray >

void IBTK::interpolate ( double &  U, const int  qp, const MultiArray &  U_node, const std::vector< std::vector< double > > &  phi  )

inline

Compute the current solution at quadrature point number @qp.

Parameters

[out]	U	Value of the finite element solution at the given point.
[in]	qp	Number of the quadrature point at which we will compute the solution value.
[in]	U_node	Multidimensional array containing finite element solution coefficients on the current element.
[in]	phi	Reference values of the shape functions indexed in the usual way (first by basis function number and then by quadrature point number).

interpolate() [4/6]

template<class MultiArray >

double IBTK::interpolate ( const int  qp, const MultiArray &  U_node, const std::vector< std::vector< double > > &  phi  )

inline

Compute the current solution at quadrature point number @qp. Returns the value instead of taking a reference to it as the first argument.

Parameters

[in]	qp	Number of the quadrature point at which we will compute the solution value.
[in]	U_node	Multidimensional array containing finite element solution coefficients on the current element.
[in]	phi	Reference values of the shape functions indexed in the usual way (first by basis function number and then by quadrature point number).

interpolate() [5/6]

template<class MultiArray >

void IBTK::interpolate ( double *const  U, const int  qp, const MultiArray &  U_node, const std::vector< std::vector< double > > &  phi  )

inline

Compute the current solution at quadrature point number @qp. This version of interpolate() is vector-valued.

Parameters

[out]	U	Array containing the output of this function. This function assumes that this array has at least U_node.shape()[1] entries.
[in]	qp	Number of the quadrature point at which we will compute the solution value.
[in]	U_node	Multidimensional array containing finite element solution coefficients on the current element.
[in]	phi	Reference values of the shape functions indexed in the usual way (first by basis function number and then by quadrature point number).

interpolate() [6/6]

template<class MultiArray >

void IBTK::interpolate ( libMesh::TypeVector< double > &  U, const int  qp, const MultiArray &  U_node, const std::vector< std::vector< double > > &  phi  )

inline

Compute the current solution at quadrature point number @qp. This version of interpolate() is vector-valued.

Parameters

[out]	U	Array containing the output of this function. This function assumes that this TypeVector has at least U_node.shape()[1] entries.
[in]	qp	Number of the quadrature point at which we will compute the solution value.
[in]	U_node	Multidimensional array containing finite element solution coefficients on the current element.
[in]	phi	Reference values of the shape functions indexed in the usual way (first by basis function number and then by quadrature point number).

jacobian()

template<class MultiArray >

void IBTK::jacobian ( libMesh::TypeTensor< double > &  dX_ds, const int  qp, const MultiArray &  X_node, const std::vector< std::vector< libMesh::VectorValue< double > > > &  dphi  )

inline

Compute the jacobian with respect to the initial configuration in the deformed configuration X_node at quadrature point number @qp.

\[ J(qp) = \sum_{i = 1}^n \xi_i \otimes \nabla_X \phi_i(qp) \]

Parameters

[out]	dX_ds	Tensor containing the output of this function of size 3x3.
[in]	qp	Number of the quadrature point at which we will compute the solution value.
[in]	X_node	Values of the shape functions of the structure location field (i.e., X): for interpolatory finite elements (e.g., libMesh::LAGRANGE) these the actual coordinates of the node (since shape functions will either be one or zero at nodes). X_node is assumed to be a two-dimensional array whose rows correspond to node number and whose columns correspond to x, y, and (in 3D) z coordinates.
[in]	dphi	Reference values of the gradient of the shape functions indexed in the usual way (first by basis function number and then by quadrature point number).

tensor_inverse() [1/2]

void IBTK::tensor_inverse ( libMesh::TensorValue< double > &  A_inv, const libMesh::TensorValue< double > &  A, const int  dim = NDIM  )

inline

tensor_inverse() [2/2]

libMesh::TensorValue<double> IBTK::tensor_inverse ( const libMesh::TensorValue< double > &  A, const int  dim = NDIM  )

inline

tensor_inverse_transpose() [1/2]

void IBTK::tensor_inverse_transpose ( libMesh::TensorValue< double > &  A_inv_trans, const libMesh::TensorValue< double > &  A, const int  dim = NDIM  )

inline

tensor_inverse_transpose() [2/2]

libMesh::TensorValue<double> IBTK::tensor_inverse_transpose ( const libMesh::TensorValue< double > &  A, const int  dim = NDIM  )

inline

outer_product() [1/2]

void IBTK::outer_product ( libMesh::TensorValue< double > &  u_prod_v, const libMesh::TypeVector< double > &  u, const libMesh::TypeVector< double > &  v, const int  dim = NDIM  )

inline

outer_product() [2/2]

libMesh::TensorValue<double> IBTK::outer_product ( const libMesh::TypeVector< double > &  u, const libMesh::TypeVector< double > &  v, const int  dim = NDIM  )

inline

intersect_line_with_edge()

bool IBTK::intersect_line_with_edge ( std::vector< std::pair< double, libMesh::Point > > &  t_vals, libMesh::Edge *  elem, libMesh::Point  r, libMesh::VectorValue< double >  q, const double  tol = 0.0  )

inline

intersect_line_with_face()

bool IBTK::intersect_line_with_face ( std::vector< std::pair< double, libMesh::Point > > &  t_vals, libMesh::Face *  elem, libMesh::Point  r, libMesh::VectorValue< double >  q, const double  tol = 0.0  )

inline

get_nodal_dof_indices()

void IBTK::get_nodal_dof_indices ( const libMesh::DofMap &  dof_map, const libMesh::Node *const  node, const unsigned int  variable_n, std::vector< libMesh::dof_id_type > &  nodal_indices  )

inline

Recent versions of libMesh acquired a useful function that lets us extract the DoFs corresponding to basis functions with node value functionals. This compatibility function either calls that function directly or uses our own implementation if the present libMesh is too old.

Deprecated:

Use DofMap::dof_indices() instead.

get_max_edge_length()

template<class MultiArray >

double IBTK::get_max_edge_length ( const libMesh::Elem *const  elem, const MultiArray &  X_node  )

inline

Return the maximum edge length of a given element with mapped nodes. If the edges of the mapped element are not straight lines (i.e., a Tet10 element subject to some nonlinear deformation) then the edge length is approximated as the sum of the lengths of the line segments.

Parameters

[in]	elem	The given libMesh element.
[in]	X_node	Values of elem's shape functions of the structure location field (i.e., X): for interpolatory finite elements (e.g., libMesh::LAGRANGE) these the actual coordinates of the node (since shape functions will either be one or zero at nodes). X_node is assumed to be a two-dimensional array whose rows correspond to node number and whose columns correspond to x, y, and (in 3D) z coordinates.

write_elem_partitioning()

void IBTK::write_elem_partitioning	(	const std::string &	file_name,
		const libMesh::System &	position_system
	)

Save, in a plain text file, the libMesh partitioning, with the format

x,y,z,rank

where x, y, and z are the center of an Elem and rank is the current MPI rank.

Note

this function collates the output from all MPI processors in the communicator assigned to position_system, so it is an inherently serial function.

write_node_partitioning()

void IBTK::write_node_partitioning	(	const std::string &	file_name,
		const libMesh::System &	position_system
	)

Save, in a plain text file, the libMesh Node partitioning, with the format

x,y,z,rank

where x, y, and z are the coordinates of a Node and rank is the current MPI rank.

Note

this function collates the output from all MPI processors in the communicator assigned to position_system, so it is an inherently serial function.

get_local_element_bounding_boxes() [1/2]

std::vector<libMesh::BoundingBox> IBTK::get_local_element_bounding_boxes	(	const libMesh::MeshBase &	mesh,
		const libMesh::System &	X_system,
		libMesh::QuadratureType	quad_type,
		libMesh::Order	quad_order,
		bool	use_adaptive_quadrature,
		double	point_density,
		bool	allow_rules_with_negative_weights,
		double	patch_dx_min
	)

Compute bounding boxes based on where an elements quadrature points are. See getQuadratureKey for descriptions of the last five arguments.

Warning

Since non-active elements do not have degrees of freedom assigned to them, this function assigns them bounding boxes that cover the complete range of finite double precision values. They are still included in the output vector so that that vector can be indexed by element ids.

get_local_element_bounding_boxes() [2/2]

std::vector<libMesh::BoundingBox> IBTK::get_local_element_bounding_boxes	(	const libMesh::MeshBase &	mesh,
		const libMesh::System &	X_system
	)

Compute bounding boxes for each local (i.e., owned by the current processor) element in mesh with coordinates given by X_system.

Warning

Since non-active elements do not have degrees of freedom assigned to them, this function assigns them bounding boxes that cover the complete range of finite double precision values. They are still included in the output vector so that that vector can be indexed by element ids.

get_global_element_bounding_boxes() [1/2]

std::vector<libMesh::BoundingBox> IBTK::get_global_element_bounding_boxes	(	const libMesh::MeshBase &	mesh,
		const std::vector< libMesh::BoundingBox > &	local_bboxes
	)

Get the global list of bounding boxes from the local list.

Warning

Since non-active elements do not have degrees of freedom assigned to them, this function assigns them bounding boxes that cover the complete range of finite double precision values. They are still included in the output vector so that that vector can be indexed by element ids.

get_global_element_bounding_boxes() [2/2]

std::vector<libMesh::BoundingBox> IBTK::get_global_element_bounding_boxes	(	const libMesh::MeshBase &	mesh,
		const libMesh::System &	X_system
	)

Compute bounding boxes for all elements in mesh with coordinates given by X_system.

Warning

Since non-active elements do not have degrees of freedom assigned to them, this function assigns them bounding boxes that cover the complete range of finite double precision values. They are still included in the output vector so that that vector can be indexed by element ids.

setup_petsc_vector()

Vec IBTK::setup_petsc_vector ( const unsigned int  num_local_nodes, const unsigned int  depth, const std::vector< int > &  nonlocal_petsc_indices  )

inline

Internal function for setting up a PETSc function of given size and depth. See the documentation of LData for more information.

update_snapshot()

void IBTK::update_snapshot	(	SnapshotCache &	cache,
		int	u_idx,
		double	time,
		SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > >	current_hierarchy,
		double	tol = 1.0e-8
	)

Update a snapshot at the given time. This function copies the data stored in u_idx into the snapshot index in the cache object. The snapshotted hierarchy is also updated to the current hierarchy.

This outputs an error if a snapshot with that time point within the specified tolerance can not be found.

Calls to this function may use a different patch index than the one used in setSnapshot(), but the underlying data layout must be consistent. This data layout is specified by the variable used to construct the cache.

fill_snapshot_on_hierarchy()

void IBTK::fill_snapshot_on_hierarchy	(	SnapshotCache &	cache,
		int	u_idx,
		double	time,
		SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > >	current_hierarchy,
		const std::string &	snapshot_refine_type,
		double	tol = 1.0e-8
	)

Transfer the snapshot at the specified time value within a given tolerance to the patch index u_idx on the supplied patch hierarchy. The patch index u_idx must contain sufficient ghost cell width to perform the operations used by the refinement operator.

Note this can require a significant amount of communication if the supplied patch hierarchy has a different configuration of patches than the snapshot patch hierarchy.

This function does not synchronize the data on the current hierarchy (i.e. no coarsening is performed). It transfers the snapshot using the refinement operator.

fill_snapshot_at_time()

void IBTK::fill_snapshot_at_time	(	SnapshotCache &	snapshot_cache,
		int	u_idx,
		double	t,
		int	scr_idx,
		SAMRAI::tbox::Pointer< SAMRAI::hier::PatchHierarchy< NDIM > >	hierarchy,
		const std::string &	refine_type,
		SAMRAI::tbox::Pointer< SAMRAI::math::HierarchyDataOpsReal< NDIM, double > >	hier_data_ops = nullptr,
		double	period = std::numeric_limits< double >::quiet_NaN()
	)

This function interpolates in time between two snapshots. We find the two closest time points stored in the snapshot cache and linear interpolate in time between them. Each snapshot will be transferred onto the provided hierarchy. A scratch patch index with the same patch layout as u_idx must be provided, and data for both must be already allocated. The refine_type must be a valid refinement operation for the data layout.

This assumes that the time is between two snapshots stored in the cache. An error will occur if two time points can not be found. If there is a single snapshot, this function returns that snapshot.

The hier_data_ops object, if provided, must match the same variable type used in for the snapshots.

If the optional period parameter is provided, this function will treat the first snapshot time point t_1 as also the last snapshot time point t_1 + period.

reportPETScKSPConvergedReason()

void IBTK::reportPETScKSPConvergedReason	(	const std::string &	object_name,
		const KSPConvergedReason &	reason,
		std::ostream &	os
	)

reportPETScSNESConvergedReason()

void IBTK::reportPETScSNESConvergedReason	(	const std::string &	object_name,
		const SNESConvergedReason &	reason,
		std::ostream &	os
	)

hypre_array()

std::array<HYPRE_Int, NDIM> IBTK::hypre_array

(

const SAMRAI::hier::Index< NDIM > &

index

)

Note

Hypre can use 64 bit indices, but SAMRAI IntVectors are always 32.

copyFromHypre() [1/2]

void IBTK::copyFromHypre	(	SAMRAI::pdat::CellData< NDIM, double > &	dst_data,
		const std::vector< HYPRE_StructVector > &	vectors,
		const SAMRAI::hier::Box< NDIM > &	box
	)

Parameters

[out]	dst_data	Reference to destination for data to be copied.
[in]	vectors	Vector of Hypre data to copy.
[in]	box	Box over which to copy.

copyFromHypre() [2/2]

void IBTK::copyFromHypre	(	SAMRAI::pdat::SideData< NDIM, double > &	dst_data,
		HYPRE_SStructVector	vector,
		const SAMRAI::hier::Box< NDIM > &	box
	)

Note

This function is specialized for cases when the Hypre vector has one part with number of variables equal to the spatial dimension.

Parameters

[out]	dst_data	Reference to destination for data to be copied.
[in]	vector	Vector of Hypre data to copy
[in]	box	Box over which to copy.

copyToHypre() [1/2]

void IBTK::copyToHypre	(	const std::vector< HYPRE_StructVector > &	vectors,
		SAMRAI::pdat::CellData< NDIM, double > &	src_data,
		const SAMRAI::hier::Box< NDIM > &	box
	)

Parameters

[out]	vectors	Reference to vector of Hypre vectors to be copied to.
[in]	src_data	Reference to cell centered data to be copied.
[in]	box	Box over which to copy.

copyToHypre() [2/2]

void IBTK::copyToHypre	(	HYPRE_SStructVector &	vector,
		SAMRAI::pdat::SideData< NDIM, double > &	src_data,
		const SAMRAI::hier::Box< NDIM > &	box
	)

Note

This function is specialized for cases when the Hypre vector has one part with number of variables equal to the spatial dimension.

Parameters

[out]	vectors	Reference to Hypre vector to be copied to.
[in]	src_data	Reference to side centered data to be copied.
[in]	box	Box over which to copy.

Variable Documentation

ENABLE_TIMERS

const bool IBTK::ENABLE_TIMERS = true

static

s_max_free_dofs

const int IBTK::s_max_free_dofs = NDIM * (NDIM + 1) / 2

static

invalid_level_number

const int IBTK::invalid_level_number = -1

static

invalid_index

const int IBTK::invalid_index = -1

static