Class AdvDiffPhysicalBoundaryUtilities is a utility class that provides functions useful for dealing with physical boundary conditions for advection-diffusion solvers
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
Class CIBMobilitySolver solves for the constraint forces and rigid body velocity of the structure(s). Specifically, the class solves two types of matrix-equations
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
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
Class StokesSpecifications is a lightweight utility class that is used to specify the physical parameters of the incompressible Navier-Stokes equations
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
Class INSStaggeredStochasticForcing provides an interface for specifying a stochastic forcing term for a staggered-grid incompressible Navier-Stokes solver
Class MarangoniSurfaceTensionForceFunction provides Marangoni forcing due to temperature variations. This class computes the forcing term and add it to the surface tension forcing
Implementation of gravity force. This class can be utilized to apply the gravitational force using the density field, which includes all three phases: liquid, gas, and solid; or using the flow density field, which includes only liquid and gas phases and excludes the solid phase
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 SAMRAISAMRAI::hier::PatchData objects
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
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
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
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
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
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
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
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
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
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
Class VCStaggeredStokesOperator is a concrete IBTK::LinearOperator which implements a staggered-grid (MAC) discretization of the incompressible Stokes operator with variable coefficients
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
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
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
Class GeneralSolver provides an abstract interface for the implementation of linear or nonlinear solvers for systems of equations defined on an AMR patch hierarchy
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
Class StaggeredStokesProjectionPreconditioner is a concrete StokesSolver that implements a staggered grid (MAC) projection solver for the incompressible Stokes operator
Class VCStaggeredStokesProjectionPreconditioner is a concrete StokesSolver that implements a staggered grid (MAC) projection solver for the incompressible Stokes operator with variable coefficients
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
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
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
Class StaggeredStokesPhysicalBoundaryHelper provides helper functions to enforce physical boundary conditions for a staggered grid discretization of the incompressible (Navier-)Stokes equations
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
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
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
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)
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
Class ConstraintIBKinematics encapsulates structure information and provides abstraction to get kinematics (deformational or imposed) of immersed structure to ConstraintIBMethod class
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
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
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
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
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
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
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
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
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
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
Class AdvDiffPredictorCorrectorHierarchyIntegrator manages the spatial discretization and time integration of scalar- and vector-valued quantities whose dynamics are governed by the advection-diffusion equation
Class AdvDiffSemiImplicitHierarchyIntegrator manages the spatial discretization and time integration of scalar- and vector-valued quantities whose dynamics are governed by the advection-diffusion equation
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
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
Class IBImplicitStaggeredHierarchyIntegrator is an implementation of a formally second-order accurate, nonlinearly-implicit version of the immersed boundary method
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
Class INSCollocatedHierarchyIntegrator provides a collocated projection method-based solver for the incompressible Navier-Stokes equations on an AMR grid hierarchy
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
Class INSVCStaggeredConservativeHierarchyIntegrator provides a staggered-grid solver for the incompressible Navier-Stokes equations on an AMR grid hierarchy, with variable coefficients
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
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
Class IndexUtilities is a utility class that defines simple functions such as conversion routines between physical coordinates and Cartesian index space
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
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)
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
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
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>
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
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
Class EnthalpyHierarchyIntegrator is a concrete class that manages the time integration of energy and phase change equations using the enthalpy approach
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
![$ y=F[x] $](form_208_dark.png)
![$ z=F[x]+y
$](form_209_dark.png)
![$ F'[x]v $](form_219_dark.png)
![$ F[x]=b $](form_227_dark.png)
