Namespace List

Here is a list of all documented namespaces with brief descriptions:

[detail level 123]

N__gnu_cxx
N__gnu_debug
N__gnu_parallel
N__gnu_pbds
►NIBAMR
►NLevelSetUtilities	Class LevelSetUtilities provides implementation of some helper functions to enforce mass/volume conservation of phases
CLevelSetContainer	A lightweight class to hold the level set variable and the associated hierarchy integrator (AdvDiffHierarchyIntegrator)
CTagLSRefinementCells	A lightweight class to tag grid cells containing the level set variable for grid refinement
CLevelSetMassLossFixer	A lightweight class that stores the current value of the Lagrange multiplier for the level set variable
CSetLSProperties	Class SetLSProperties is a utility class which sets (or resets after reinitialization) level set values on the patch hierarchy
NWaveDampingFunctions
NWaveGenerationFunctions
CAdvDiffCenteredConvectiveOperator	Class AdvDiffCenteredConvectiveOperator is a concrete ConvectiveOperator that implements a centered convective differencing operator
CAdvDiffConservativeMassScalarTransportRKIntegrator	Class AdvDiffConservativeMassScalarTransportRKIntegrator is a concrete class that integrates the collocated density field
CAdvDiffConvectiveOperatorManager	Class AdvDiffConvectiveOperatorManager is a singleton manager class to provide access to generic cell-centered ConvectiveOperator implementations suitable for use with class AdvDiffHierarchyIntegrator
CAdvDiffCUIConvectiveOperator	Class AdvDiffCUIConvectiveOperator is a concrete ConvectiveOperator that implements a upwind convective differencing operator based on the cubic upwind interpolation (CUI)
CAdvDiffHierarchyIntegrator	Class AdvDiffHierarchyIntegrator provides an abstract interface for a time integrator for advection-diffusion or advection-reaction-diffusion equations on an AMR grid hierarchy, along with basic data management for variables defined on that hierarchy
CAdvDiffPhysicalBoundaryUtilities	Class AdvDiffPhysicalBoundaryUtilities is a utility class that provides functions useful for dealing with physical boundary conditions for advection-diffusion solvers
CAdvDiffPPMConvectiveOperator	Class AdvDiffPPMConvectiveOperator is a concrete ConvectiveOperator that implements a upwind convective differencing operator based on the piecewise parabolic method (PPM)
CAdvDiffPredictorCorrectorHierarchyIntegrator	Class AdvDiffPredictorCorrectorHierarchyIntegrator manages the spatial discretization and time integration of scalar- and vector-valued quantities whose dynamics are governed by the advection-diffusion equation
CAdvDiffPredictorCorrectorHyperbolicPatchOps	Class AdvDiffPredictorCorrectorHyperbolicPatchOps is a specialization of class AdvectorPredictorCorrectorHyperbolicPatchOps for use with a linearly-implicit time integrator for the advection-diffusion equation
CAdvDiffSemiImplicitHierarchyIntegrator	Class AdvDiffSemiImplicitHierarchyIntegrator manages the spatial discretization and time integration of scalar- and vector-valued quantities whose dynamics are governed by the advection-diffusion equation
CAdvDiffStochasticForcing	Class AdvDiffStochasticForcing provides an interface for specifying a stochastic forcing term for cell-centered advection-diffusion solver solver
CAdvDiffWavePropConvectiveOperator	Class AdvDiffWavePropConvectiveOperator is a concrete ConvectiveOperator that implements a convective operator based on the wave propagation method
CAdvectorExplicitPredictorPatchOps	Class AdvectorExplicitPredictorPatchOps provides patch-based operations required to implement a second-order Godunov method for the linear advection equation in conservative and non-conservative forms
CAdvectorPredictorCorrectorHyperbolicPatchOps	Class AdvectorPredictorCorrectorHyperbolicPatchOps is a concrete SAMRAI::algs::HyperbolicPatchStrategy that makes use of class AdvectorExplicitPredictorPatchOps to solve the linear advection equation
CAllenCahnHierarchyIntegrator	Class AllenCahnHierarchyIntegrator is a concrete class that manages the time integration of the Allen-Cahn and energy equation
CBrinkmanAdvDiffBcHelper	BrinkmanAdvDiffBcHelper is an abstract class that provides an interface to implement Brinkman penalization body force in the advection-diffusion equation in order to enforce Dirichlet, Neumann and Robin boundary conditions on surfaces of rigid immersed bodies. A single instance of this class is meant to handle all of the Brinkman penalization zones for multiple transported quantities with various boundary conditions
CBrinkmanAdvDiffSemiImplicitHierarchyIntegrator	Class BrinkmanAdvDiffSemiImplicitHierarchyIntegrator manages the spatial discretization and time integration of scalar- and vector-valued quantities whose dynamics are governed by the advection-diffusion equation. If the variable is registered with penalization boundary conditions, this class computes the additional diffusion coefficient and the forcing term from BrinkmanAdvDiffBcHelper class and solves a penalized advection-diffusion equation for that variable
CBrinkmanPenalizationStrategy	BrinkmanPenalizationStrategy is an abstract class that provides an interface to implement Brinkman penalization body force in the momentum equation
CCarmanKozenyDragForce	CarmanKozenyDragForce provides an implementation of Carman-Kozeny drag force to impose zero velocity inside the solid
CCellConvectiveOperator	Class CellConvectiveOperator is an abstract class for an implementation of a convective differencing operator
CCFGiesekusStrategy	Class CFGiesekusStrategy is a concrete CFStrategy that computes the relaxation function for the Giesekus fluid model
CCFINSForcing	Class CFINSForcing provides an interface for specifying a viscoelastic stress to be added to the Navier-Stokes equations. The class uses the advection diffusion integrator to update the viscoelastic stress
CCFOldroydBStrategy	Class CFOldroydBStrategy is a concrete CFStrategy that computes the relaxation function for an Oldroyd-B fluid model
CCFRoliePolyStrategy	Class CFRoliePolyStrategy is a concrete CFStrategy that computes the relaxation function for the Rolie-Poly fluid model
CCFStrategy	Class CFStrategy is an abstract class that provides an interface for specifying the details of a complex fluid model
CCFUpperConvectiveOperator	Class CFUpperConvectiveOperator is a concrete ConvectiveOperator that implements the upper convective derivative. This uses second order finite differences to compute the velocity gradients. The transport component can be chosen from any current convective operators. If the advected quantity allows for a square root or logarithmic decomposition, this class can advect the symmetric square root or logarithm of the tensor. Note that this class requires the registration of a source funtion before it can be applied
►CCIBMethod	Class CIBMethod is a concrete CIBStrategy and IBMethod class which implements the motion of rigid bodies using the constraint formulation. The immersed structure is discretized using standard IB markers
CConstrainedVelocityFcnsData	Struct encapsulating constrained velocity functions data
CExternalForceTorqueFcnData	Struct encapsulating external force and torque function data
CCIBMobilitySolver	Class CIBMobilitySolver solves for the constraint forces and rigid body velocity of the structure(s). Specifically, the class solves two types of matrix-equations
CCIBSaddlePointSolver	Class CIBSaddlePointSolver solves for the fluid velocity , fluid pressure , and the Lagrange multiplier maintaining the rigidity constraint
CCIBStaggeredStokesOperator	Class CIBStaggeredStokesOperator is a concrete IBTK::LinearOperator which implements a staggered-grid (MAC) discretization of the incompressible Stokes operator while maintaining the constraint of rigidity for the immersed structures
CCIBStaggeredStokesSolver	Class CIBStaggeredStokesSolver is an extension of IBAMR::StaggeredStokesSolver class that solves for the Langrange multiplier field which imposes the rigidity constraint and solves for rigid body velocity (if it is freely-moving) along with the fluid velocity and pressure
CCIBStrategy	Class CIBStrategy is a lightweight abstract strategy class which provides support for constraint based IB methods for rigid bodies
►CConstraintIBKinematics	Class ConstraintIBKinematics encapsulates structure information and provides abstraction to get kinematics (deformational or imposed) of immersed structure to ConstraintIBMethod class
CStructureParameters
CConstraintIBMethod	Class ConstraintIBMethod implements the rigidity constraint for rigid and deforming bodies using the constraint based IB method
CConvectiveOperator	Class ConvectiveOperator is a abstract class for an implementation of a convective differencing operator
CDirectMobilitySolver	Class DirectMobilitySolver solves the mobility and body-mobility sub-problem by employing direct solvers
CEnthalpyHierarchyIntegrator	Class EnthalpyHierarchyIntegrator is a concrete class that manages the time integration of energy and phase change equations using the enthalpy approach
CFastSweepingLSMethod	Class FastSweepingLSMethod provides a fast-sweeping algorithm implementation of the level set method. Specifically, this class produces a solution to the Eikonal equation , which produces the signed distance away from an interface
CFEMechanicsExplicitIntegrator	Class FEMechanicsExplicitIntegrator is an implementation of the abstract base class FEMechanicsBase that provides a simple explicit elastodynamics time integrator with an interface that is similar to IBFEMethod to facilitate model re-use
CFifthOrderStokesWaveGenerator	Class for generating fifth order Stokes wave using Fenton's (Stokes) wave theory
CFirstOrderStokesWaveGenerator	Class for generating first order water waves based upon linear wave theory
CGeneralizedIBMethod	Class GeneralizedIBMethod is an extension of class IBMethod that provides functionality required by the generalized IB (gIB) method
CHeavisideForcingFunction	Class HeavisideForcingFunction computes . This is required to solve the advection equation for Heaviside in conservative form
CIBAnchorPointSpec	Class IBAnchorPointSpec is used to indicate that a particular node of the curvilinear mesh is anchored in place
CIBBeamForceSpec	Class IBBeamForceSpec encapsulates the data necessary to compute the forces generated by a collection of linear beams (i.e., structures that resist bending) at a single node of the Lagrangian mesh
CIBExplicitHierarchyIntegrator	Class IBExplicitHierarchyIntegrator is an implementation of a formally second-order accurate, semi-implicit version of the immersed boundary method
►CIBFEDirectForcingKinematics	Class IBFEDirectForcingKinematics is a helper class that provides direct forcing IBMethod functionality to the IBFEMethod class
CKinematicsFcnData
►CIBHierarchyIntegrator	Class IBHierarchyIntegrator provides an abstract interface for a time integrator for various versions of the immersed boundary method on an AMR grid hierarchy, along with basic data management for variables defined on that hierarchy
CIBEulerianForceFunction	A class to communicate the Eulerian body force computed by class IBHierarchyIntegrator to the incompressible Navier-Stokes solver
CIBEulerianSourceFunction	A class to communicate the Eulerian fluid source-sink distribution computed by class IBHierarchyIntegrator to the incompressible Navier-Stokes solver
►CIBHydrodynamicForceEvaluator	Class IBHydrodynamicForceEvaluator computes hydrodynamic force and torque on immersed bodies. The class uses Reynolds transport theorem to integrate momentum over a Cartesian box region that moves with an arbitrary rigid body translation velocity
CIBHydrodynamicForceObject
CIBHydrodynamicSurfaceForceEvaluator	Class IBHydrodynamicSurfaceForceEvaluator computes hydrodynamic force on immersed bodies. The class uses a level set indicator for the solid body to add up surface forces in the cells adjacent to the immersed structure
CIBImplicitStaggeredHierarchyIntegrator	Class IBImplicitStaggeredHierarchyIntegrator is an implementation of a formally second-order accurate, nonlinearly-implicit version of the immersed boundary method
CIBImplicitStrategy	Class IBImplicitStrategy provides a generic interface for specifying the implementation details of a particular implicit version of the IB method
CIBInstrumentationSpec	Class IBInstrumentationSpec encapsulates the data required to initialize distributed internal flow meters and pressure gauges
CIBInstrumentPanel	Class IBInstrumentPanel provides support for flow meters and pressure gauges
CIBInterpolantHierarchyIntegrator	Class IBInterpolantHierarchyIntegrator is an implementation of Brinkman penalization immersed boundary method
CIBInterpolantMethod	Class IBInterpolantMethod is an implementation of the abstract base class IBStrategy that provides a simple functionality of interpolating and spreading scalar or vector-valued quantities to and from the moving IB structure on the background Cartesian grid
CIBKirchhoffRodForceGen	Class IBKirchhoffRodForceGen computes the forces and torques generated by a collection of linear elements based on Kirchhoff rod theory
CIBLagrangianForceStrategy	Class IBLagrangianForceStrategy provides a generic interface for specifying nodal forces (not force densities) on the Lagrangian curvilinear mesh
CIBLagrangianForceStrategySet	Class IBLagrangianForceStrategySet is a utility class that allows multiple IBLagrangianForceStrategy objects to be employed by a single IBHierarchyIntegrator
CIBLagrangianSourceStrategy	Class IBLagrangianForceStrategy provides a generic interface for specifying the positions and magnitudes of distributed internal fluid source-sinks
CIBLevelSetMethod	Class IBLevelSetMethod is a concrete IBStrategy class that uses IBInterpolantMethod and IBFEMethod objects to initialize and transport rigid body level sets for Brinkman penalized IBMethod. This class is supposed to be used with INSVCHierarchyIntegrator class
CIBMethod	Class IBMethod is an implementation of the abstract base class IBImplicitStrategy that provides functionality required by the standard IB method
CIBMethodPostProcessStrategy	Class IBMethodPostProcessStrategy provides a generic interface for specifying post-processing code for use in an IB computation
►CIBRedundantInitializer	Class IBRedundantInitializer is an abstract LInitStrategy that initializes the configuration of one or more Lagrangian structures from input files
CAnchorSpec
CBdryMassSpec
CBeamSpec
CEdgeComp
CRodSpec
CSpringSpec
CTargetSpec
CXSpringSpec
CIBRodForceSpec	Class IBRodForceSpec encapsulates the data necessary to compute the forces generated by a network of Kirchhoff rods at a single node of the Lagrangian mesh
CIBSourceSpec	Class IBSourceSpec encapsulates the data required to initialize distributed internal sources and sinks
CIBSpringForceSpec	Class IBSpringForceSpec encapsulates the data necessary to compute the forces generated by a network of linear or nonlinear springs (i.e., structures that resist extension and/or compression) at a single node of the Lagrangian mesh
CIBStandardForceGen	Class IBStandardForceGen is a concrete IBLagrangianForceStrategy that is intended to be used in conjunction with curvilinear mesh data generated by class IBStandardInitializer
CIBStandardInitializer	Class IBStandardInitializer is a concrete LInitStrategy that initializes the configuration of one or more Lagrangian structures from input files
CIBStandardSourceGen	Class IBStandardSourceGen provides support for distributed internal fluid sources/sinks
CIBStrategy	Class IBStrategy provides a generic interface for specifying the implementation details of a particular version of the IB method
CIBStrategySet	Class IBStrategySet is a utility class that allows multiple IBStrategy objects to be employed by a single IBHierarchyIntegrator
CIBTargetPointForceSpec	Class IBTargetPointForceSpec encapsulates the data necessary to compute the penalty force generated by a single fixed target point (i.e., a force that approximately imposes a Dirichlet boundary condition at a single node of the Lagrangian mesh)
►CIIMethod	Class IIMethod is an implementation of the abstract base class IBStrategy that provides functionality required by the IB method with a finite element representation of a surface mesh
CCoordinateMappingFcnData
CInitialVelocityFcnData
CLagSurfaceForceFcnData
CLagSurfacePressureFcnData
CINSCollocatedCenteredConvectiveOperator	Class INSCollocatedCenteredConvectiveOperator is a concrete ConvectiveOperator which implements a centered convective differencing operator
CINSCollocatedConvectiveOperatorManager	Class INSCollocatedConvectiveOperatorManager is a singleton manager class to provide access to generic cell-centered ConvectiveOperator implementations suitable for use with class INSCollocatedHierarchyIntegrator
CINSCollocatedHierarchyIntegrator	Class INSCollocatedHierarchyIntegrator provides a collocated projection method-based solver for the incompressible Navier-Stokes equations on an AMR grid hierarchy
CINSCollocatedPPMConvectiveOperator	Class INSCollocatedPPMConvectiveOperator is a concrete ConvectiveOperator that implements a upwind convective differencing operator based on the piecewise parabolic method (PPM)
CINSCollocatedVelocityBcCoef	Class INSCollocatedVelocityBcCoef is a concrete StokesBcCoefStrategy that is used to specify velocity boundary conditions for the staggered grid incompressible Navier-Stokes solver
CINSCollocatedWavePropConvectiveOperator	Class INSCollocatedWavePropConvectiveOperator is a concrete ConvectiveOperator that implements a convective operator based on the wave propagation method
CINSHierarchyIntegrator	Class INSHierarchyIntegrator provides an abstract interface for a time integrator for the incompressible Navier-Stokes equations on an AMR grid hierarchy, along with basic data management for variables defined on that hierarchy
CINSIntermediateVelocityBcCoef	Class INSIntermediateVelocityBcCoef is a concrete SAMRAI::solv::RobinBcCoefStrategy that is used to specify boundary conditions for the intermediate velocity solve embedded in a projection method or in a block preconditioner for the incompressible Navier-Stokes equations
CINSProjectionBcCoef	Class INSIntermediateVelocityBcCoef is a concrete SAMRAI::solv::RobinBcCoefStrategy that is used to specify boundary conditions for the projection Poisson problem embedded in a projection method or in a block preconditioner for the incompressible Navier-Stokes equations
CINSStaggeredCenteredConvectiveOperator	Class INSStaggeredCenteredConvectiveOperator is a concrete ConvectiveOperator which implements a centered convective differencing operator
CINSStaggeredConvectiveOperatorManager	Class INSStaggeredConvectiveOperatorManager is a singleton manager class to provide access to generic cell-centered ConvectiveOperator implementations suitable for use with class INSStaggeredHierarchyIntegrator
CINSStaggeredCUIConvectiveOperator	Class INSStaggeredCUIConvectiveOperator is a concrete ConvectiveOperator that implements a upwind convective differencing operator based on the cubic upwind interpolation (CUI)
CINSStaggeredHierarchyIntegrator	Class INSStaggeredHierarchyIntegrator provides a staggered-grid solver for the incompressible Navier-Stokes equations on an AMR grid hierarchy
CINSStaggeredPPMConvectiveOperator	Class INSStaggeredPPMConvectiveOperator is a concrete ConvectiveOperator that implements a upwind convective differencing operator based on the piecewise parabolic method (PPM)
CINSStaggeredPressureBcCoef	Class INSStaggeredPressureBcCoef is a concrete StokesBcCoefStrategy that is used to specify pressure boundary conditions for the staggered grid incompressible Navier-Stokes solver
CINSStaggeredStabilizedPPMConvectiveOperator	Class INSStaggeredStabilizedPPMConvectiveOperator is a concrete ConvectiveOperator that implements a upwind convective differencing operator based on the piecewise parabolic method (PPM). This discretization is "stabilized" at open boundaries by blending the higher-order discretization with first-order upwind
CINSStaggeredStochasticForcing	Class INSStaggeredStochasticForcing provides an interface for specifying a stochastic forcing term for a staggered-grid incompressible Navier-Stokes solver
CINSStaggeredUpwindConvectiveOperator	Class INSStaggeredUpwindConvectiveOperator is a concrete ConvectiveOperator that implements a first-order upwind convective differencing operator
CINSStaggeredVelocityBcCoef	Class INSStaggeredVelocityBcCoef is a concrete StokesBcCoefStrategy that is used to specify velocity boundary conditions for the staggered grid incompressible Navier-Stokes solver
CINSStaggeredWavePropConvectiveOperator	Class INSStaggeredWavePropConvectiveOperator is a concrete ConvectiveOperator that implements a convective operator based on the wave propagation method
CINSVCStaggeredConservativeHierarchyIntegrator	Class INSVCStaggeredConservativeHierarchyIntegrator provides a staggered-grid solver for the incompressible Navier-Stokes equations on an AMR grid hierarchy, with variable coefficients
CINSVCStaggeredConservativeMassMomentumRKIntegrator	Class INSVCStaggeredConservativeMassMomentumRKIntegrator integrates the staggered density field
CINSVCStaggeredConservativeMassMomentumSSPRKIntegrator	Class INSVCStaggeredConservativeMassMomentumSSPRKIntegrator is a derived class that integrates the staggered density field
CINSVCStaggeredHierarchyIntegrator	Class INSVCStaggeredHierarchyIntegrator provides an abstract interface for time integrator for a staggered-grid, incompressible Navier-Stokes solver on an AMR grid hierarchy with variable coefficients
CINSVCStaggeredNonConservativeHierarchyIntegrator	Class INSVCStaggeredNonConservativeHierarchyIntegrator provides a staggered-grid solver for the incompressible Navier-Stokes equations on an AMR grid hierarchy, with variable coefficients
CINSVCStaggeredPressureBcCoef	Class INSVCStaggeredPressureBcCoef is a concrete StokesBcCoefStrategy that is used to specify pressure boundary conditions for the staggered grid incompressible Navier-Stokes solver with variable coefficients
CINSVCStaggeredVelocityBcCoef	Class INSVCStaggeredVelocityBcCoef is a concrete StokesBcCoefStrategy that is used to specify velocity boundary conditions for the staggered grid incompressible Navier-Stokes solver with variable coefficents
CIrregularWaveBcCoef	Class IrregularWaveBcCoef is an implementation of the strategy class SAMRAI::solv::RobinBcCoefStrategy that provides Dirichlet velocity boundary condition based upon linear wave theory of water waves to generate irregular waves at the inlet of the wave tank. The class is meant to be used with INSVCStaggeredHierarchyIntegrator
CIrregularWaveGenerator	Class for generating Irregular waves
CKrylovFreeBodyMobilitySolver
CKrylovLinearSolverStaggeredStokesSolverInterface	Class KrylovLinearSolverStaggeredStokesSolverInterface provides an interface for KrylovLinearSolvers that are to be used as staggered Stokes solvers
CKrylovMobilitySolver
CLSInitStrategy	Class LSInitStrategy provides a generic interface for initializing the implementation details of a particular version of the level set method
CMarangoniSurfaceTensionForceFunction	Class MarangoniSurfaceTensionForceFunction provides Marangoni forcing due to temperature variations. This class computes the forcing term and add it to the surface tension forcing
CMobilityFunctions	Class MobilityFunctions provides empirical functions/fits for forming mobility matrix needed for fully constraint based IB method
CNonbondedForceEvaluator
CPenaltyIBMethod	Class PenaltyIBMethod is an implementation of the abstract base class IBStrategy that provides functionality required by the penalty IB (pIB) method
CPETScKrylovStaggeredStokesSolver	Class PETScKrylovStaggeredStokesSolver is an extension of class PETScKrylovLinearSolver that provides an implementation of the StaggeredStokesSolver interface
CPhaseChangeDivUSourceFunction	Class PhaseChangeDivUSourceFunction class set the RHS of the Div U equation computed from the PhaseChangeHierarchyIntegrator class
CRelaxationLSBcCoefs	Class RelaxationLSBcCoefs is an implementation of the strategy class RobinBcCoefStrategy that is used to specify fixed Dirichlet boundary conditions for the level set function during reinitialization step
CRelaxationLSMethod	Class RelaxationLSMethod provides a relaxation algorithm implementation of the level set method. Specifically, this class iterates (to steady-state) the PDE , which produces a solution to the Eikonal equation . The solution of the Eikonal equation produces the signed distance away from an interface
CRNG	Class RNG organizes functions that provide random-number generator functionality
CSpongeLayerForceFunction	Class SpongeLayerForceFunction provides forcing at physical boundaries that weakly imposes homogeneous Dirichlet boundary conditions
CStaggeredStokesBlockFactorizationPreconditioner	Class StaggeredStokesBlockFactorizationPreconditioner is a concrete StaggeredStokesBlockPreconditioner that implements a staggered grid (MAC) block factorization (approximate Schur complement) preconditioner for the incompressible Stokes equations
CStaggeredStokesBlockPreconditioner	Class StaggeredStokesBlockPreconditioner is an abstract base class for Stokes solvers that are implemented using block (subdomain) solvers
CStaggeredStokesBoxRelaxationFACOperator	Class StaggeredStokesBoxRelaxationFACOperator is a concrete StaggeredStokesFACPreconditionerStrategy implementing a box relaxation (Vanka-type) smoother for use as a multigrid preconditioner
CStaggeredStokesFACPreconditioner	Class StaggeredStokesFACPreconditioner is a FACPreconditioner that has been specialized for Stokes problems
CStaggeredStokesFACPreconditionerStrategy	Class StaggeredStokesFACPreconditionerStrategy is an abstract FACPreconditionerStrategy implementing many of the operations required by smoothers for staggered-grid (MAC) discretizations of the incompressible Stokes equations and related problems
CStaggeredStokesIBLevelRelaxationFACOperator	Class StaggeredStokesIBLevelRelaxationFACOperator is a concrete FACPreconditionerStrategy class that implements the operations required by smoothers for staggered-grid (MAC) discretizations of the implicit incompressible Stokes-IB equations
CStaggeredStokesLevelRelaxationFACOperator	Class StaggeredStokesLevelRelaxationFACOperator is a concrete StaggeredStokesFACPreconditionerStrategy implementing a level relaxation smoother for use as a multigrid preconditioner
CStaggeredStokesOpenBoundaryStabilizer	Class StaggeredStokesOpenBoundaryStabilizer provides forcing at physical boundaries that attempts to stabilize flows at open boundaries
CStaggeredStokesOperator	Class StaggeredStokesOperator is a concrete IBTK::LinearOperator which implements a staggered-grid (MAC) discretization of the incompressible Stokes operator
CStaggeredStokesPETScLevelSolver	Class StaggeredStokesPETScLevelSolver is a concrete PETScLevelSolver for a staggered-grid (MAC) discretization of the incompressible Stokes equations
CStaggeredStokesPETScMatUtilities	Class StaggeredStokesPETScMatUtilities provides utility functions for PETSc Mat objects
CStaggeredStokesPETScVecUtilities	Class StaggeredStokesPETScVecUtilities provides utility functions for PETSc Vec objects
CStaggeredStokesPhysicalBoundaryHelper	Class StaggeredStokesPhysicalBoundaryHelper provides helper functions to enforce physical boundary conditions for a staggered grid discretization of the incompressible (Navier-)Stokes equations
CStaggeredStokesProjectionPreconditioner	Class StaggeredStokesProjectionPreconditioner is a concrete StokesSolver that implements a staggered grid (MAC) projection solver for the incompressible Stokes operator
CStaggeredStokesSolver	Class StaggeredStokesSolver is an abstract base class for staggered-grid Stokes solvers
CStaggeredStokesSolverManager	Class StaggeredStokesSolverManager is a singleton manager class to provide access to generic staggered-grid Stokes solver implementations
CStokesBcCoefStrategy	Class StokesBcCoefStrategy is a subclass of the abstract base class IBTK::ExtendedRobinBcCoefStrategy to allow for specialization needed to treat physical boundary conditions for coupled Stokes solvers
CStokesFifthOrderWaveBcCoef	Class StokesFifthOrderWaveBcCoef is an implementation of the strategy class SAMRAI::solv::RobinBcCoefStrategy that provides Dirichlet velocity boundary condition based upon Stokes' fifth-order theory of water waves at the inlet of the wave tank. The class is meant to be used with INSVCStaggeredHierarchyIntegrator
CStokesFirstOrderWaveBcCoef	Class StokesFirstOrderWaveBcCoef is an implementation of the strategy class SAMRAI::solv::RobinBcCoefStrategy that provides Dirichlet velocity boundary condition based upon Stokes' lineary theory of water waves at the inlet of the wave tank. This class is meant to be used with INSVCStaggeredHierarchyIntegrator
CStokesSecondOrderWaveBcCoef	Class StokesSecondOrderWaveBcCoef is an implementation of the strategy class SAMRAI::solv::RobinBcCoefStrategy that provides Dirichlet velocity boundary condition based upon Stokes' second order theory of water waves at the inlet of the wave tank. This class is meant to be used with INSVCStaggeredHierarchyIntegrator
CStokesSpecifications	Class StokesSpecifications is a lightweight utility class that is used to specify the physical parameters of the incompressible Navier-Stokes equations
CStokesWaveGeneratorStrategy	Strategy class for generating Stokes wave
CSTSMassFluxIntegrator	Class STSMassFluxIntegrator is an abstract class which integrates the density field
CSurfaceTensionForceFunction	Class SurfaceTensionForceFunction provides surface tension forcing using the continuum surface tension force model of Brackbill, Kothe, and Zemach
CVCStaggeredStokesOperator	Class VCStaggeredStokesOperator is a concrete IBTK::LinearOperator which implements a staggered-grid (MAC) discretization of the incompressible Stokes operator with variable coefficients
CVCStaggeredStokesProjectionPreconditioner	Class VCStaggeredStokesProjectionPreconditioner is a concrete StokesSolver that implements a staggered grid (MAC) projection solver for the incompressible Stokes operator with variable coefficients
CWall
CWallForceEvaluator
CWaveGenerationData
CWaveDampingData
►NIBTK
CAppInitializer	Class AppInitializer provides functionality to simplify the initialization code in an application code
CBGaussSeidelPreconditioner	Class BGaussSeidelPreconditioner is a block Gauss-Seidel preconditioner which implements the abstract LinearSolver interface
CBJacobiPreconditioner	Class BJacobiPreconditioner is a block Jacobi preconditioner which implements the abstract LinearSolver interface
CCartCellDoubleBoundsPreservingConservativeLinearRefine	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
CCartCellDoubleCubicCoarsen	Class CartCellDoubleCubicCoarsen is a concrete SAMRAI::xfer::CoarsenOperator for restricting cell-centered double precision patch data via cubic interpolation
CCartCellDoubleLinearCFInterpolation	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
CCartCellDoubleQuadraticCFInterpolation	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
CCartCellDoubleQuadraticRefine	Class CartCellDoubleQuadraticRefine is a concrete SAMRAI::xfer::RefineOperator object which prolongs cell-centered double precision patch data via quadratic interpolation
CCartCellRobinPhysBdryOp	Class CartCellRobinPhysBdryOp is a concrete SAMRAI::xfer::RefinePatchStrategy for setting Robin boundary conditions at physical boundaries for cell-centered scalar- and vector-valued quantities
CCartExtrapPhysBdryOp	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
CCartGridFunction	Class CartGridFunction provides an abstract interface for objects for evaluating functions to set values in SAMRAI::hier::PatchData objects
CCartGridFunctionSet	Class CartGridFunctionSet is a concrete CartGridFunction that is used to allow multiple CartGridFunction objects to act as a single function
CCartSideDoubleCubicCoarsen	Class CartSideDoubleCubicCoarsen is a concrete SAMRAI::xfer::CoarsenOperator for restricting side-centered double precision patch data via cubic interpolation
CCartSideDoubleDivPreservingRefine	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
CCartSideDoubleQuadraticCFInterpolation	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
CCartSideDoubleRT0Coarsen	Class CartSideDoubleRT0Coarsen is a concrete SAMRAI::xfer::CoarsenOperator for restricting side-centered double precision patch data via the adjoint of RT0 interpolation
CCartSideDoubleRT0Refine	Class CartSideDoubleRT0Refine is a concrete SAMRAI::xfer::RefineOperator object that prolongs side-centered double precision patch data via RT0-based interpolation
CCartSideDoubleSpecializedLinearRefine	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
CCartSideRobinPhysBdryOp	Class CartSideRobinPhysBdryOp is a concrete SAMRAI::xfer::RefinePatchStrategy for setting Robin boundary conditions at physical boundaries for side-centered vector-valued quantities
CCCLaplaceOperator	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
CCCPoissonBoxRelaxationFACOperator	Class CCPoissonBoxRelaxationFACOperator is a concrete PoissonFACPreconditionerStrategy for solving elliptic equations of the form using a globally second-order accurate cell-centered finite-volume discretization, with support for Robin and periodic boundary conditions
CCCPoissonHypreLevelSolver	Class CCPoissonHypreLevelSolver is a concrete LinearSolver for solving elliptic equations of the form on a single SAMRAI::hier::PatchLevel using hypre
CCCPoissonLevelRelaxationFACOperator	Class CCPoissonLevelRelaxationFACOperator is a concrete PoissonFACPreconditionerStrategy for solving elliptic equations of the form using a globally second-order accurate cell-centered finite-volume discretization, with support for Robin and periodic boundary conditions
CCCPoissonPETScLevelSolver	Class CCPoissonPETScLevelSolver is a concrete PETScLevelSolver for solving elliptic equations of the form on a single SAMRAI::hier::PatchLevel
CCCPoissonPointRelaxationFACOperator	Class CCPoissonPointRelaxationFACOperator is a concrete PoissonFACPreconditionerStrategy for solving elliptic equations of the form using a globally second-order accurate cell-centered finite-volume discretization, with support for Robin and periodic boundary conditions
CCCPoissonSolverManager	Class CCPoissonSolverManager is a singleton manager class to provide access to generic cell-centered PoissonSolver implementations
CCellNoCornersFillPattern	Class CellCellNoCornersFillPattern 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 cell-centered ghost region surrounding a patch, excluding all corners. In 3D, it is also possible to configure this fill pattern object also to exclude all edges
CCoarseFineBoundaryRefinePatchStrategy	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
CCoarsenPatchStrategySet	Class CoarsenPatchStrategySet is a utility class that allows multiple SAMRAI::xfer::CoarsenPatchStrategy objects to be employed by a single SAMRAI::xfer::CoarsenSchedule
CCopyToRootSchedule	Class CopyToRootSchedule is used to communicate distributed patch data to a unified patch data object on a root MPI process
CCopyToRootTransaction	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
CDebuggingUtilities	Class DebuggingUtilities provides debugging functionality
►CEdgeDataSynchronization	Class EdgeDataSynchronization encapsulates the operations required to "synchronize" edge-centered values defined at patch boundaries
CSynchronizationTransactionComponent	Class EdgeDataSynchronization::SynchronizationTransactionComponent encapsulates options for filling ghost cell values via class EdgeDataSynchronization
CEdgeSynchCopyFillPattern	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
CExtendedRobinBcCoefStrategy	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
►CFaceDataSynchronization	Class FaceDataSynchronization encapsulates the operations required to "synchronize" face-centered values defined at patch boundaries
CSynchronizationTransactionComponent	Class FaceDataSynchronization::SynchronizationTransactionComponent encapsulates options for filling ghost cell values via class FaceDataSynchronization
CFaceSynchCopyFillPattern	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
CFACPreconditioner	Class FACPreconditioner is a concrete LinearSolver for implementing FAC (multilevel multigrid) preconditioners
CFACPreconditionerStrategy	Class FACPreconditionerStrategy provides an interface for specifying the problem-specific operations needed to implement a specific FAC preconditioner
CFixedSizedStream	Class FixedSizedStream provides a fixed-size message buffer used by various communication routines
CGeneralOperator	Class GeneralOperator provides an abstract interface for the specification of general operators to compute and
CGeneralSolver	Class GeneralSolver provides an abstract interface for the implementation of linear or nonlinear solvers for systems of equations defined on an AMR patch hierarchy
►CHierarchyGhostCellInterpolation	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
CInterpolationTransactionComponent	Class HierarchyGhostCellInterpolation::InterpolationTransactionComponent encapsulates options for filling ghost cell values via class HierarchyGhostCellInterpolation
CHierarchyIntegrator	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
CHierarchyMathOps	Class HierarchyMathOps provides functionality to perform "composite-grid" mathematical operations on a range of levels in a SAMRAI::hier::PatchHierarchy object
CIBTK_MPI	Provides C++ wrapper around MPI routines
CIBTKInit	Initialization for IBAMR programs
CIndexOrder
CIndexUtilities	Class IndexUtilities is a utility class that defines simple functions such as conversion routines between physical coordinates and Cartesian index space
CJacobianOperator	Class JacobianOperator provides an abstract interface for the specification of general operators to compute Jacobian-vector products, i.e.,
CKrylovLinearSolver	Class KrylovLinearSolver provides an abstract interface for the implementation of Krylov subspace solvers for linear problems of the form
CKrylovLinearSolverManager	Class KrylovLinearSolverManager is a singleton manager class to provide access to generic KrylovLinearSolver implementations
CKrylovLinearSolverPoissonSolverInterface	Class KrylovLinearSolverPoissonSolverInterface provides an interface for KrylovLinearSolvers that are to be used as Poisson solvers
CLaplaceOperator	Class LaplaceOperator is an abstract base class for a Laplace-type operators
CLData	Class LData provides storage for a single scalar- or vector-valued Lagrangian quantity
CLDataManager	Class LDataManager coordinates the irregular distribution of LNode and LData on the patch hierarchy
CLIndexSetData	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
CLEInteractor	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
CLibMeshSystemIBVectors	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)
CLIndexSetDataFactory	Class LIndexSetPatchDataFactory provides a SAMRAI::hier::PatchDataFactory class corresponding to patch data of type LIndexSetData
CLIndexSetVariable	Class LIndexSetVariable provides a SAMRAI::hier::Variable class corresponding to patch data of type LIndexSetData
CLinearOperator	Class LinearOperator provides an abstract interface for the specification of linear operators to compute and and, optionally, and
CLinearSolver	Class LinearSolver provides an abstract interface for the implementation of solvers for linear problems of the form
CLInitStrategy	Class LInitStrategy provides a mechanism for specifying the initial configuration of the curvilinear mesh
CLMesh	Class LMesh is a collection of LNode objects
CLNode	Class LNode is the basic element of an LMesh
CLNodeIndex	Class LNodeIndex provides Lagrangian and PETSc indexing information for a single node of a Lagrangian mesh
CLNodeIndexPosnComp	Comparison functor to order on the physical location of the Lagrangian node
CLNodeIndexLagrangianIndexComp	Comparison functor to order on the Lagrangian index of the Lagrangian node
CLNodeIndexGlobalPETScIndexComp	Comparison functor to order on the global PETSc index of the Lagrangian node
CLNodeIndexLocalPETScIndexComp	Comparison functor to order on the local PETSc index of the Lagrangian node
CLNodeIndexPosnEqual	Comparison functor to check for equality between LNodeIndex objects based on their positions
CLNodeIndexLagrangianIndexEqual	Comparison functor to check for equality between LNodeIndex objects based on their Lagrangian indices
CLNodeIndexGlobalPETScIndexEqual	Comparison functor to check for equality between between LNodeIndex objects based on their global PETSc indices
CLNodeIndexLocalPETScIndexEqual	Comparison functor to check for equality between LNodeIndex objects based on their local PETSc indices
CLSet	Class LSet provides inter-processor communications and database access functionality to a collection of Lagrangian objects
CLSetData	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
CLSetDataFactory	Class LSetPatchDataFactory provides a SAMRAI::hier::PatchDataFactory class corresponding to patch data of type LSetData
CLSetDataIterator	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
CLSetVariable	Class LSetVariable provides a SAMRAI::hier::Variable class corresponding to patch data of type LSetData
CLSiloDataWriter	Class LSiloDataWriter provides functionality to output Lagrangian data for visualization via the VisIt visualization tool in the Silo data format
►CLTransaction	Class LTransaction represents a communication transaction between two processors or a local data copy for communicating or copying Lagrangian objects
CLTransactionComponent	Struct LTransaction::LTransactionComponent encapsulates the individual data items that are communicated via class LTransaction
CMarkerPatch
CMarkerPatchHierarchy
CMergingLoadBalancer	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
CmuParserCartGridFunction	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
CmuParserRobinBcCoefs	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
CNewtonKrylovSolver	Class NewtonKrylovSolver provides an abstract interface for the implementation of inexact Newton-Krylov solvers for nonlinear problems of the form
CNewtonKrylovSolverManager	Class NewtonKrylovSolverManager is a singleton manager class to provide access to generic NewtonKrylovSolver implementations
►CNodeDataSynchronization	Class NodeDataSynchronization encapsulates the operations required to "synchronize" node-centered values defined at patch boundaries
CSynchronizationTransactionComponent	Class NodeDataSynchronization::SynchronizationTransactionComponent encapsulates options for filling ghost cell values via class NodeDataSynchronization
CNodeSynchCopyFillPattern	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
CNormOps	Class NormOps provides functionality for computing discrete vector norms
CParallelEdgeMap	Class ParallelEdgeMap is a utility class for managing edge maps (i.e., maps from vertices to links between vertices) in parallel
CParallelMap	Class ParallelMap is a utility class for associating integer keys with arbitrary data items in parallel
CParallelSet	Class ParallelSet is a utility class for storing collections of integer keys in parallel
CPartitioningBox	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
CPartitioningBoxes	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>
CPatchMathOps	Class PatchMathOps provides functionality to perform mathematical operations on individual SAMRAI::hier::Patch objects
CPETScKrylovLinearSolver	Class PETScKrylovLinearSolver provides a KrylovLinearSolver interface for a PETSc Krylov subspace iterative linear solver (KSP)
CPETScKrylovPoissonSolver	Class PETScKrylovPoissonSolver is an extension of class PETScKrylovLinearSolver that provides an implementation of the PoissonSolver interface
CPETScLevelSolver	Class PETScLevelSolver is an abstract LinearSolver for solving systems of linear equations on a single SAMRAI::hier::PatchLevel using PETSc
CPETScMatLOWrapper	Class PETScMatLOWrapper provides a LinearOperator interface for a PETSc Mat object
CPETScMatUtilities	Class PETScMatUtilities provides utility functions for PETSc Mat objects
CPETScMFFDJacobianOperator	Class PETScMFFDJacobianOperator provides a method for computing Jacobian-vector products, i.e., , via a matrix-free finite-difference approach
CPETScNewtonKrylovSolver	Class PETScNewtonKrylovSolver provides a NewtonKrylovSolver interface for a PETSc inexact Newton-Krylov iterative nonlinear solver (SNES)
CPETScPCLSWrapper	Class PETScPCLSWrapper provides a LinearSolver interface for a PETSc PC object
CPETScSAMRAIVectorReal	Class PETScSAMRAIVectorReal is a class for wrapping SAMRAI::solv::SAMRAIVectorReal objects so that they may be used with the PETSc solver package
CPETScSNESFunctionGOWrapper	Class PETScSNESFunctionGOWrapper provides a GeneralOperator interface for a PETSc SNES nonlinear function
CPETScSNESJacobianJOWrapper	Class PETScSNESJacobianJOWrapper provides a JacobianOperator interface for a PETSc SNES Jacobian
CPETScVecUtilities	Class PETScVecUtilities provides utility functions for PETSc Vec objects
CPhysicalBoundaryUtilities	Class PhysicalBoundaryUtilities is a utility class to organize functions related to setting values at physical boundaries
CPoissonFACPreconditioner	Class PoissonFACPreconditioner is a FACPreconditioner that has been specialized for Poisson problems
CPoissonFACPreconditionerStrategy	Class PoissonFACPreconditionerStrategy is an abstract FACPreconditionerStrategy implementing many of the operations required by smoothers for the Poisson equation and related problems
CPoissonSolver	Class PoissonSolver is an abstract base class for Poisson solvers
CPoissonUtilities	Class PoissonUtilities provides utility functions for constructing Poisson solvers
CRefinePatchStrategySet	Class RefinePatchStrategySet is a utility class that allows multiple SAMRAI::xfer::RefinePatchStrategy objects to be employed by a single SAMRAI::xfer::RefineSchedule
CRobinPhysBdryPatchStrategy	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
►CSAMRAIDataCache	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
CCachedPatchDataIndex	Class for accessing cached patch data indices
CSAMRAIGhostDataAccumulator	Class that can accumulate data summed into ghost regions on a patch hierarchy into their correct locations
CSAMRAIScopedVectorCopy
CSAMRAIScopedVectorDuplicate
CSCLaplaceOperator	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
CSCPoissonHypreLevelSolver	Class SCPoissonHypreLevelSolver is a concrete LinearSolver for solving elliptic equations of the form on a single SAMRAI::hier::PatchLevel using hypre
CSCPoissonPETScLevelSolver	Class SCPoissonPETScLevelSolver is a concrete PETScLevelSolver for solving elliptic equations of the form on a single SAMRAI::hier::PatchLevel using PETSc
CSCPoissonPointRelaxationFACOperator	Class SCPoissonPointRelaxationFACOperator is a concrete PoissonFACPreconditionerStrategy for solving elliptic equations of the form using a globally second-order accurate side-centered finite-difference discretization, with support for Robin and periodic boundary conditions
CSCPoissonSolverManager	Class SCPoissonSolverManager is a singleton manager class to provide access to generic side-centered PoissonSolver implementations
CSecondaryHierarchy
►CSideDataSynchronization	Class SideDataSynchronization encapsulates the operations required to "synchronize" side-centered values defined at patch boundaries
CSynchronizationTransactionComponent	Class SideDataSynchronization::SynchronizationTransactionComponent encapsulates options for filling ghost cell values via class SideDataSynchronization
CSideNoCornersFillPattern	Class SideCellNoCornersFillPattern 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 cell-centered ghost region surrounding a patch, excluding all corners. In 3D, it is also possible to configure this fill pattern object also to exclude all edges
CSideSynchCopyFillPattern	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
CSnapshotCache	Class SnapshotCache provides a method of storing snapshots of patch data on a snapshot of the patch hierarchy
CStaggeredPhysicalBoundaryHelper	Class StaggeredPhysicalBoundaryHelper provides helper functions to handle physical boundary conditions for a staggered grid discretizations
CStandardTagAndInitStrategySet	Class StandardTagAndInitStrategySet is a utility class that allows multiple SAMRAI::mesh::StandardTagAndInitStrategy objects to be employed by a single SAMRAI::mesh::StandardTagAndInitialize object
CStreamable	Class Streamable is an abstract interface for objects that can be packed into SAMRAI::tbox::AbstractStream data streams
CStreamableFactory	Class StreamableFactory is an abstract interface for classes that can unpack particular concrete Streamable objects from SAMRAI::tbox::AbstractStream data streams
CStreamableManager	Class StreamableManager is a singleton manager class that organizes the actual packing and unpacking of concrete Streamable objects for SAMRAI::tbox::AbstractStream based communication
CVCSCViscousOperator	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
CVCSCViscousOpPointRelaxationFACOperator	Class VCSCViscousOpPointRelaxationFACOperator is a specialization of SCPoissonPointRelaxationFACOperator for solving vector elliptic equation of the form using a globally second-order accurate side-centered finite-difference discretization, with support for Robin and periodic boundary conditions
CVCSCViscousPETScLevelSolver	Class VCSCViscousPETScLevelSolver is a subclass of SCPoissonPETScLevelSolver class which solves vector-valued elliptic equation of the form on a single SAMRAI::hier::PatchLevel using PETSc
NlibMesh
NSAMRAI
►Nstd
N__debug
N__detail
N__parallel
Nchrono
Ndecimal
Nexperimental
Nfilesystem
Nnumbers
Nregex_constants
Nrel_ops
Nthis_thread
Ntr1
Ntr2
Cless< SAMRAI::tbox::Pointer< T > >