 |
SheafSystem
0.0.0.0
|
|
SheafSystem
0.0.0.0
|
| ►Nfiber_bundle | Namespace for the fiber_bundles component of the sheaf system |
| Cantisymmetric_matrix_2x2 | Antisymmetric matrix with 2 rows and 2 columns |
| Cantisymmetric_matrix_3x3 | Antisymmetric matrix with 3 rows and 3 columns |
| Cany_lite | Abstract base class with useful features for all volatile objects |
| Carray_field_dof_map | A contiguous tuple, contiguous fiber representation of the abstract map from section_space_schema_member ids to section dof values of homogeneous type double |
| Carray_sec_vd_dof_map | A contiguous tuple, contiguous fiber representation of the abstract map from section dof ids to section dof values of type sec_vd_dof_type |
| Carray_section_dof_map | A contiguous tuple, contiguous fiber representation of the abstract map from section dof ids to section dof values of heterogeneous type |
| Cat0 | A scalar viewed as an antisymmetric tensor of degree 0. As the degree is 0 there is nothing to be symmetric or antisymmetric with respect to. Thus, this could have equivalently been the symmetric tensor with degree=0. The convention is to choose antisymmetric |
| Cat0_lite | Antisymetric tensor of degree 0 (volatile version) |
| Cat0_row_dofs_type | Row dofs type for class at0 |
| Cat0_space | A space of scalars viewed as an antisymmetric tensor space of degree 0 |
| Cat1 | A general antisymmetric tensor of degree 1 over an abstract vector space (persistent version) |
| Cat1_lite | A general antisymmetric tensor of degree 1 over an abstract vector space (volatile version) |
| Cat1_space | An abstract vector space viewed as an antisymmetric tensor space of degree 1 |
| Cat2 | A general antisymmetric tensor of degree 2 over an abstract vector space |
| Cat2_e2 | An antisymmetric rank 2 tensor over a Euclidean vector space of dimension 2 (persistent version) |
| Cat2_e2_lite | An antisymmetric rank 2 tensor over a Euclidean vector space of dimension 2 (volatile version) |
| Cat2_e2_row_dofs_type | Row dofs type for class at2_e2 |
| Cat2_e3 | An antisymmetric rank 2 tensor over a Euclidean vector space of dimension 3. (persistent version) |
| Cat2_e3_lite | An antisymmetric rank 2 tensor over a Euclidean vector space of dimension 3. (volatile version) |
| Cat2_e3_row_dofs_type | Row dofs type for class at2_e3 |
| Cat2_lite | A general antisymmetric tensor of degree 2 over an abstract vector space (volatile version) |
| Cat3 | An antisymmetric rank 3 tensor over an abstract vector space (volatile version) |
| Cat3_e3 | An antisymmetric rank 3 tensor over a 3D Euclidean vector space |
| Cat3_e3_lite | An antisymmetric rank 3 tensor over a Euclidean vector space of dimension 3. (volatile version) |
| Cat3_e3_row_dofs_type | Row dofs type for class at3_e3 |
| Cat3_lite | An antisymmetric rank 3 tensor over an abstract vector space (volatile version) |
| Catp | An antisymmetric tensor of degree p |
| Catp_lite | An antisymmetric tensor of degree p over an abstract vector space (volatile version) |
| Catp_space | An abstract antisymmetric tensor space of degree p |
| Cbase_space_crg_interval | Abstract emulator for a interval of implicit base space members |
| Cbase_space_factory | A factory for making base space objects of type base_type |
| Cbase_space_member | A client handle for a member of a base space poset |
| Cbase_space_member_row_dof_tuple_type | The type of row dof tuple for base_space_member |
| Cbase_space_poset | The lattice of closed cells of a cellular space; a lattice representation of a computational mesh |
| Cbase_space_poset_table_dof_tuple_type | The type of table dof tuple for base_space_poset |
| Cbilinear_2d | A section evaluator using bilinear interpolation over a square 2D domain |
| Cbinary_index | A pair of indices (i,j) |
| Cbinary_index_space | A bounded domain for binary_index objects |
| Cbinary_section_component_iterator | Iterates in postorder over dofs of a schema member anchor. Attaches an a handle of type section_space_schema_member to the current member of the iteration |
| Cbinary_section_dof_iterator | Iterates in postorder over dofs of a schema member anchor. Attaches an a handle of type section_space_schema_member to the current member of the iteration |
| Cbinary_section_space_schema_member | A client handle for a poset member which has been prepared for use as a schema for a section space. See class binary_section_space_schema_poset for a description of the schema represented by this class |
| Cbinary_section_space_schema_poset | A schema poset for a section space. A binary Cartesian product subspace of the binary tensor product of a base space lattice and a fiber schema lattice. The tensor product of two lattices B and F is the finite distributive lattice generated by the poset J(B) x J(F), where J(B) is the poset of jims of B and similarly for J(F). The jims of the tensor product are thus pairs (jB, jF) and the general member of the tensor product lattice is equivalent to a subset (in fact a down set) of J(B) x J(F). This class only represents those members of the tensor product which are equivalent to pairs (pB, pF), where pB and pF are arbitrary members of B and F, respectively. Members of this Cartesian product subspace of the tensor product can be represented more efficiently than the general members, since we do not to store the subset defines the member |
| Cblock_adjacency | Node to zone adjacency relation for a block of zones of a given type |
| Cblock_connectivity | Zone to node connectivity relation for a block of zones of a given type |
| Cblock_relation | Abstract cell relation for a block of zones of a given type |
| Cchart_point | A point in chart space |
| Cchart_point_1d | A point in a 1D chart space |
| Cchart_point_2d | A point in a 2D chart space |
| Cchart_point_3d | A point in a 3D chart space |
| Cconstant_eval_family | A family of section evaluators containing members for constant functions on primitive cells |
| Cconstant_fcn_space | An section evaluator with a constant value over an abstract domain |
| Cconstant_hex | A section evaluator using trilinear interpolation over a cubic 3D domain |
| Cconstant_point | A section evaluator with a constant value over a 1D domain |
| Cconstant_quad | A section evaluator with a constant value over a square 2D domain |
| Cconstant_segment | A section evaluator with a constant value over a 1D domain |
| Cconstant_tet | A section evaluator with a constant value over a tetrahedral 3D domain |
| Cconstant_triangle | A section evaluator with a constant value over a triangular 2D domain |
| Cdifferentiable_section_evaluator | An abstract section evaluator that can be differentiated |
| Cdiscretization_context | A context for discretization members. Intended for implementing various iterators, especially concurrent iterations over multiple sections |
| Cdiscretization_iterator | Iterator over the discretization subposet associated with a section_space_schema_member anchor |
| Cdlinear_eval_family | A family of section evaluators containing uni-, bi-, and tri-linear evaluators |
| Ce1 | Euclidean vector space of dimension 1 (persistent version) |
| Ce1_lite | Euclidean vector space of dimension 1 (volatile version) |
| Ce1_row_dofs_type | Row dofs type for class e1 |
| Ce2 | Euclidean vector space of dimension 2 (persistent version) |
| Ce2_lite | Euclidean vector space of dimension 2 (volatile version) |
| Ce2_row_dofs_type | Row dofs type for class e2 |
| Ce3 | Euclidean vector space of dimension 3 (persistent version) |
| Ce3_lite | Euclidean vector space of dimension 3 (volatile version) |
| Ce3_row_dofs_type | Row dofs type for class e3 |
| Ce4 | Euclidean vector space of dimension 4 (persistent version) |
| Ce4_lite | Euclidean vector space of dimension 4 (volatile version) |
| Ce4_row_dofs_type | Row dofs type for class e4 |
| Ced | Euclidean vector space of dimension d (peresistent version) |
| Ced_lite | Euclidean vector space of dimension d (volatile version) |
| Ceval_family | A family of compatible section evaluators, one for each member of some family of cell types; a map from cell type to section evaluator |
| Ceval_iterator | An iterator over the members of the evaluation subposet contained in the downset of the base space of a section_space_schema_member. Extracts the connectivity (that is, the discretization members in the downset) of each evaluation member |
| Cfiber_bundles_namespace | The standard fiber bundles name space; extends the standard sheaves namespace by defining base space, fiber space and section space schema |
| Cfield_dof_map | OBSOLETE: Use array_sec_vd_dof_map or sparse_section_dof_map. The abstract map from section_space_schema_member ids to section dof values of homogeneous type double |
| Cgeneral_matrix_1x2 | General matrix with 1 row and 2 columns |
| Cgeneral_matrix_1x3 | General matrix with 1 row and 3 columns |
| Cgeneral_matrix_2x1 | General matrix with 2 rows and 1 column |
| Cgeneral_matrix_2x2 | General matrix with 2 rows and 2 columns |
| Cgeneral_matrix_2x3 | General matrix with 2 rows and 3 columns |
| Cgeneral_matrix_3x1 | General matrix with 3 rows and 1 column |
| Cgeneral_matrix_3x2 | General matrix with 3 rows and 2 columns |
| Cgeneral_matrix_3x3 | General matrix with 3 rows and 3 columns |
| Cgl2 | The mathematical group GL(2, R). The group of all invertible, linear transformations on the R2, the 2 dimension vector space over the reals. Equivalent to the set of all invertible 2x2 real matrices |
| Cgl2_lite | The mathematical group GL(2, R). The group of all invertible, linear transformations on the R2, the 2 dimension vector space over the reals. Equivalent to the set of all invertible 2x2 real matrices (volatile version) |
| Cgl2_row_dofs_type | Row dofs type for class gl2 |
| Cgl3 | The mathematical group GL(3, R). The group of all invertible, linear transformations on the R3, the 3 dimension vector space over the reals. Equivalent to the set of all invertible 3x3 real matrices |
| Cgl3_lite | The mathematical group GL(3, R). The group of all invertible, linear transformations on the R3, the 3 dimension vector space over the reals. Equivalent to the set of all invertible 3x3 real matrices (volatile version) |
| Cgl3_row_dofs_type | Row dofs type for class gl3 |
| Cgln | The mathematical group GL(n, R). GL(n,R) is the group of general, invertible, linear transformations on a vector space of dimension n over the reals R |
| Cgln_lite | The mathematical group GL(n, R). GL(n,R) is the group of general, invertible, linear transformations on a vector space of dimension n over the reals R (volatile version) |
| Cgln_row_dofs_type | Row dofs type for class gln |
| Cgln_space | A Cartesian product space |
| Cgln_table_dofs_type | Table dofs of gln |
| Cgroup | The general, abstract mathematical group (persistent version) |
| Cgroup_lite | The general, abstract mathematical group (volatile version) |
| Chex_connectivity | Nodal connectivity for a block containing zones of type hex |
| Chomogeneous_block | A client handle for a base space member which represents a homgeneous collection of local cells, aka "zones" or "elements" |
| Chomogeneous_block_crg_interval | Emulator for a interval of implicit base space members representing a homogeneous collection of cells |
| Ci_adjacency_implicit_index_space_iterator | An implementation of implicit_index_space_iterator for an implicit id space in an i_adjacency_index_space_interval |
| Ci_adjacency_index_space_interval | An implementation of index_space_interval for an interval of implicit id spaces for the adjacency of a 1-dimensional structured block |
| Ci_connectivity_implicit_index_space_iterator | An implementation of implicit_index_space_iterator for an implicit id space in an i_connectivity_index_space_interval |
| Ci_connectivity_index_space_interval | An implementation of index_space_interval for an interval of implicit id spaces for the connectivity of an 2-dimensional structured block |
| Cij_adjacency_implicit_index_space_iterator | An implementation of implicit_index_space_iterator for an implicit id space in an ij_adjacency_index_space_interval |
| Cij_adjacency_index_space_interval | An implementation of index_space_interval for an interval of implicit id spaces for the adjacency of a 2-dimensional structured block |
| Cij_connectivity_implicit_index_space_iterator | An implementation of implicit_index_space_iterator for an implicit id space in an ij_connectivity_index_space_interval |
| Cij_connectivity_index_space_interval | An implementation of index_space_interval for an interval of implicit id spaces for the connectivity of an 2-dimensional structured block |
| Cijk_adjacency_implicit_index_space_iterator | An implementation of implicit_index_space_iterator for an implicit id space in an ijk_adjacency_index_space_interval |
| Cijk_adjacency_index_space_interval | An implementation of index_space_interval for an interval of implicit id spaces for the adjacency of a 3-dimensional structured block |
| Cijk_connectivity_implicit_index_space_iterator | An implementation of implicit_index_space_iterator for an implicit id space in an ijk_connectivity_index_space_interval |
| Cijk_connectivity_index_space_interval | An implementation of index_space_interval for an interval of implicit id spaces for the connectivity of an 3-dimensional structured block |
| Cintegrable_section_evaluator | An abstract section evaluator with a bounded domain that supports integration (volume calculation) as well as differntiation |
| Cjcb | Abstract jacobian class |
| Cjcb_e13 | Jacobian of a map from a 1 dimensional domain (u) to a 3 dimensional Euclidean space (x, y, z) |
| Cjcb_e13_lite | Jacobian of a map from a 1 dimensional domain (u) to a 3 dimensional Euclidean space (x, y, z) (volatile version) |
| Cjcb_e13_row_dofs_type | Row dofs type for class jcb_e13 |
| Cjcb_e23 | Jacobian of a map from a 2 dimensional domain (u, v) to a 3 dimensional Euclidean space (x, y, z) |
| Cjcb_e23_lite | Jacobian of a map from a 2 dimensional domain (u, v) to a 3 dimensional Euclidean space (x, y, z) (volatile version) |
| Cjcb_e23_row_dofs_type | Row dofs type for class jcb_e23 |
| Cjcb_e33 | Jacobian of a map from a 3 dimensional domain (u, v, w) to a 3 dimensional Euclidean space (x, y, z) |
| Cjcb_e33_lite | Jacobian of a map from a 3 dimensional domain (u, v, w) to a 3 dimensional Euclidean space (x, y, z) (volatile version) |
| Cjcb_e33_row_dofs_type | Row dofs type for class jcb_e33 |
| Cjcb_ed | Abstract jacobian for d dimensional Euclidean space (persistent version) |
| Cjcb_ed_lite | Abstract jacobian for d dimensional Euclidean space (volatile version) |
| Cjcb_lite | Abstract jacobian class (volatile version) |
| Cjcb_space | An abstract space of Jacobians |
| Cjcb_table_dofs_type | Table dofs type for class jcb |
| Cline_connectivity | Nodal connectivity for a block containing zones of type segment |
| Clinear_1d | A section evaluator using linear interpolation over a 1D domain |
| Clinear_2d | A section evaluator using linear interpolation over a triangular 2D domain |
| Clinear_3d | A section evaluator using linear interpolation over a tetrahedral 3D domain |
| Clinear_fcn_space | An abstract integrable section evaluator which is a member of a linear function space |
| Clocal_base_space_member | A client handle for a member of a base space poset |
| Cmesh_partition | A decomposition of a mesh into non-overlapping scopes |
| Cmet | A metric tensor over an abstract vector space (persistent version) |
| Cmet_e1 | A metric tensor over a 1 dimensional Euclidean vector space |
| Cmet_e1_lite | A metric tensor over a 1 dimensional Euclidean vector space (volatile version) |
| Cmet_e1_row_dofs_type | Row dofs type for class met_e1 |
| Cmet_e2 | A metric tensor over a 2 dimensional Euclidean vector space (persistent version) |
| Cmet_e2_lite | A metric tensor over a 2 dimensional Euclidean vector space (volatile version) |
| Cmet_e2_row_dofs_type | Row dofs type for class met_e2 |
| Cmet_e3 | A metric tensor over a 3 dimensional Euclidean vector space (persistent version) |
| Cmet_e3_lite | A metric tensor over a 1 dimensional Euclidean vector space (volatile version) |
| Cmet_e3_row_dofs_type | Row dofs type for class met_e3 |
| Cmet_ed | A metric tensor over a d-dimensional Euclidean vector space (persistent version) |
| Cmet_ed_lite | A metric tensor over a d-dimensional Euclidean vector space (volatile version) |
| Cmet_lite | A metric tensor over an abstract vector space (volatile version) |
| Cpoint_block_1d | A homogeneous collection of i_size() disconnected points; similar to a structured_block_1d, but without the segments |
| Cpoint_block_2d | A homogeneous collection of i_size() * j_size() disconnected points similar to a structured_block_2d, but without the quads |
| Cpoint_block_3d | A homogeneous collection of i_size()*j_size()*k_size() disconnected points similar to a structured_block_3d, but without the hexs |
| Cpoint_block_crg_interval | Emulator for a interval of implicit base space members representing a homogeneous collection of unconnected points |
| Cpoint_connectivity | Nodal connectivity for a block containing zones of type point. Since a point block is just a collection of disconnected points, the "connectivity" list for each point contains just the point itself |
| Cproduct_section_dof_iterator | Iterates in postorder over dofs of a schema member anchor. Attaches an a handle of type section_space_schema_member to the current member of the iteration |
| Cproduct_section_space_schema_crg_range | Emulator for a range of implicit section space schema members representing the Cartesian product the mesh poset and the attribute schema poset |
| Cproduct_section_space_schema_member | A client handle for a poset member which has been prepared for use as a schema for a section space. See class product_section_space_schema_poset for a description of the schema represented by this class |
| Cproduct_section_space_schema_poset | An schema poset for a section space represented by a Cartesian product subspace of the tensor product of a base space lattice, and a fiber schema lattice |
| Cquad_connectivity | Nodal connectivity for a block containing zones of type quad |
| Cquadratic_1d | A section evaluator using quadratic interpolation over a 1D domain |
| Cquadratic_2d | A section evaluator using quadratic interpolation over a triangular 2D domain |
| Cquadratic_3d | A section evaluator using quadratic interpolation over a tetrahedral 3D domain |
| Csec_at0 | Antisymetric tensor of degree 0. As the degree is 0 there is nothing to be symmetric or antisymmetric with respect to. Thus, this could have equivalently been the symmetric tensor with degree=0. The convention is to choose antisymmetric |
| Csec_at0_space | A space of scalars viewed as an antisymmetric tensor section space of degree 0 |
| Csec_at1 | A section of a bundle with fiber type at1 |
| Csec_at1_space | A space of scalars viewed as an antisymmetric tensor section space of degree 1 |
| Csec_at2 | A section of a bundle with fiber type at2 |
| Csec_at2_e2 | A section of a bundle with fiber type at2_e2 |
| Csec_at2_e3 | A section of a bundle with fiber type at2_e3 |
| Csec_at3 | A section of a bundle with fiber type at3 |
| Csec_at3_e3 | A section of a bundle with fiber type at3_e3 |
| Csec_atp | A section of a bundle with fiber type atp |
| Csec_atp_space | An abstract antisymmetric tensor section space of degree p |
| Csec_e1 | A section of a fiber bundle with a 1-dimensional Euclidean vector space fiber |
| Csec_e1_uniform | A section of a fiber bundle with a 1-dimensional Euclidean vector space fiber |
| Csec_e2 | A section of a fiber bundle with a 2-dimensional Euclidean vector space fiber |
| Csec_e2_uniform | A section of a fiber bundle with a 2-dimensional Euclidean vector space fiber |
| Csec_e3 | A section of a fiber bundle with a 3-dimensional Euclidean vector space fiber |
| Csec_e3_uniform | A section of a fiber bundle with a 3-dimensional Euclidean vector space fiber |
| Csec_e4 | A section of a fiber bundle with a 4-dimensional Euclidean vector space fiber |
| Csec_ed | A section of a fiber bundle with a d-dimensional Euclidean vector space fiber |
| Csec_jcb | A section of a bundle with fiber type jcb |
| Csec_jcb_e13 | A section of a bundle with fiber type jcb_e13 |
| Csec_jcb_e23 | A section of a bundle with fiber type jcb_e23 |
| Csec_jcb_e33 | A section of a bundle with fiber type jcb_e33 |
| Csec_jcb_ed | A section of a bundle with fiber type jcb_ed |
| Csec_jcb_space | An abstract section space of Jacobians |
| Csec_met | A section of a bundle with fiber type met |
| Csec_met_e1 | A section of a bundle with fiber type met_e1 |
| Csec_met_e2 | A section of a bundle with fiber type met_e2 |
| Csec_met_e3 | A section of a bundle with fiber type met_e3 |
| Csec_met_ed | A section of a bundle with fiber type met_ed |
| Csec_rep_descriptor | A description for a section representation scheme |
| Csec_rep_descriptor_poset | The poset for sec_rep_descriptors |
| Csec_rep_descriptor_table_dofs_type | Table dofs type for class sec_rep_descriptor_poset |
| Csec_rep_space | A handle for a poset whose members are numerical representations of sections of a fiber bundle |
| Csec_rep_space_member | A member of a sec_rep_space; a section |
| Csec_st2 | A section of a bundle with fiber type st2 |
| Csec_st2_e2 | A section of a bundle with fiber type st2_e2 |
| Csec_st2_e3 | A section of a bundle with fiber type st2_e3 |
| Csec_st3 | A section of a bundle with fiber type st3 |
| Csec_st3_e3 | A section of a bundle with fiber type st3_e3 |
| Csec_st4 | A section of a bundle with fiber type st4 |
| Csec_st4_e2 | A section of a bundle with fiber type st4_e2 |
| Csec_st4_e3 | A section of a bundle with fiber type st4_e3 |
| Csec_stp | A section of a bundle with fiber type stp |
| Csec_stp_space | An abstract symmetric tensor section space of degree p |
| Csec_t2 | A section of a bundle with fiber type tp |
| Csec_t2_e2 | A section of a bundle with fiber type t2_e2 |
| Csec_t2_e3 | A section of a bundle with fiber type t2_e3 |
| Csec_t3 | A section of a bundle with fiber type t3 |
| Csec_t3_e3 | A section of a bundle with fiber type t3_e3 |
| Csec_t4 | A section of a bundle with fiber type t4 |
| Csec_t4_e2 | A section of a bundle with fiber type t4_e2 |
| Csec_t4_e3 | A section of a bundle with fiber type t4_e3 |
| Csec_tp | A section of a bundle with fiber type tp |
| Csec_tp_space | An abstract tensor section space of degree p |
| Csec_tuple | A section of a bundle with fiber type tuple |
| Csec_tuple_space | A Cartesian product section space |
| Csec_vd | A section of a fiber bundle with a d-dimensional vector space fiber |
| Csec_vd_space | An abstract vector section space of dimension d |
| Csection_component_iterator | Iterates in postorder over components of a section_space_schema_member anchor. The components of a section_space_schema_member m are those members m' <= m such that m'.base_space().is_same_state(m.base_space()) and m'.fiber_schema().is_component(). Attaches an a handle of type section_space_schema_member to the current member of the iteration |
| Csection_dof_iterator | Iterates in postorder over dofs of a schema member anchor. Attaches an a handle of type section_space_schema_member to the current member of the iteration |
| Csection_dof_map | The abstract map from section dof ids to section dof values of heterogeneous type |
| Csection_eval_iterator | Iterates over the evaluation members of a section space schema anchor; gathers the dof ids for each evaluation member |
| Csection_evaluator | An abstract local section evaluator; a map from {local coordinates x dofs} to section value |
| Csection_iteration_state | Descriptor for iteration state of individual section. Intended for implementing various iterators, especially concurrent iterations over multiple sections |
| Csection_space_schema_crg_range | Abstract emulator for a range of implicit section space schema members |
| Csection_space_schema_jims_index_space_handle | An implementation of class explicit_index_space_handle that has a section space schema jims id space state |
| Csection_space_schema_jims_index_space_iterator | An iterator over an id space in which the equivalence between the ids in the space and the hub id space is stored in an array |
| Csection_space_schema_jims_index_space_state | An implementation class explicit_index_space_state for the jims id space of the section space schema |
| Csection_space_schema_member | A client handle for a poset member which has been prepared for use as a schema for a section space |
| Csection_space_schema_poset | An abstract schema poset for a section space. A Cartesian product subspace of the tensor product of a base space lattice, a fiber schema lattice, and possibly a local schema lattice |
| Csection_space_schema_table_dof_crg_range | Abstract emulator for a range of implicit section space schema members |
| Csection_space_schema_table_dofs_type | Table dofs type for class section_space_schema_poset |
| Csection_traits | Features describing a section type. Declaration only; there is no generic implementation for this template. It is implemented only via specializations |
| Csection_traits< sec_at0 > | Features describing a sec_at0 as a section type |
| Csection_traits< sec_at1 > | Features describing a sec_at1 as a section type |
| Csection_traits< sec_at2_e2 > | Features describing a sec_at2_e2 as a section type |
| Csection_traits< sec_at2_e3 > | Features describing a sec_at2_e3 as a section type |
| Csection_traits< sec_at3_e3 > | Features describing a sec_at3_e3 as a section type |
| Csection_traits< sec_e1 > | Features describing a sec_e1 as a section type |
| Csection_traits< sec_e1_uniform > | Features describing a sec_e1_uniform as a section type |
| Csection_traits< sec_e2 > | Features describing a sec_e2 as a section type |
| Csection_traits< sec_e2_uniform > | Features describing a sec_e2_uniform as a section type |
| Csection_traits< sec_e3 > | Features describing a sec_e3 as a section type |
| Csection_traits< sec_e3_uniform > | Features describing a sec_e3_uniform as a section type |
| Csection_traits< sec_jcb_e13 > | Features describing a sec_sec_jcb_e13 as a section type |
| Csection_traits< sec_jcb_e23 > | Features describing a sec_jcb_e23 as a section type |
| Csection_traits< sec_jcb_e33 > | Features describing a sec_jcb_e33 as a section type |
| Csection_traits< sec_met_e1 > | Features describing a sec_met_e1 as a section type |
| Csection_traits< sec_met_e2 > | Features describing a sec_met_e2 as a section type |
| Csection_traits< sec_met_e3 > | Features describing a sec_met_e3 as a section type |
| Csection_traits< sec_st2_e2 > | Features describing a sec_st2_e2 as a section type |
| Csection_traits< sec_st2_e3 > | Features describing a sec_st2_e3 as a section type |
| Csection_traits< sec_st3_e3 > | Features describing a sec_st3_e3 as a section type |
| Csection_traits< sec_st4_e2 > | Features describing a sec_st4_e2 as a section type |
| Csection_traits< sec_st4_e3 > | Features describing a sec_t3_e3 as a section type |
| Csection_traits< sec_t2_e2 > | Features describing a sec_t2_e2 as a section type |
| Csection_traits< sec_t2_e3 > | Features describing a sec_t2_e3 as a section type |
| Csection_traits< sec_t3_e3 > | Features describing a sec_t3_e3 as a section type |
| Csection_traits< sec_t4_e2 > | Features describing a sec_t4_e2 as a section type |
| Csection_traits< sec_t4_e3 > | Features describing a sec_t3_e3 as a section type |
| Csection_traits< sec_vd > | Features describing a sec_vd as a section type |
| Csparse_field_dof_map | OBSOLETE: Use array_sec_vd_dof_map or sparse_section_dof_map. A representation of the abstract map from section_space_schema_member ids to section dof values of homogeneous type double optimized for the case in which most dofs have the same value |
| Csparse_section_dof_map | A discontiguous tuple, discontiguous fiber representation of the abstract map from section dof ids to section dof values of type sec_vd_dof_type. This class assumes most of the dofs have some given value (0.0 by default) and only stores dofs with a non-default value |
| Cst2 | A general symmetric tensor of degree 2 over an abstract vector space (persistent version) |
| Cst2_e2 | A symmetric tensor of degree 2 over a Euclidean vector space of dimension 2 (persistent version) |
| Cst2_e2_lite | A symmetric tensor of degree 2 over a Euclidean vector space of dimension 2 (volatile version) |
| Cst2_e2_row_dofs_type | Row dofs type for class st2_e2 |
| Cst2_e3 | A symmetric tensor of degree 2 over a Euclidean vector space of dimension 3 (persistent version) |
| Cst2_e3_lite | A symmetric tensor of degree 2 over a Euclidean vector space of dimension 3 (volatile version) |
| Cst2_e3_row_dofs_type | Row dofs type for class st2_e3 |
| Cst2_lite | A general symmetric tensor of degree 2 over an abstract vector space (volatile version) |
| Cst3 | A symmetric rank 3 tensor over an abstract vector space (persistent version) |
| Cst3_e3 | A symmetric rank 3 tensor over a 3D Euclidean vector space (persistent version) |
| Cst3_e3_lite | A symmetric rank 3 tensor over a Euclidean vector space of dimension 3. (volatile version) |
| Cst3_e3_row_dofs_type | Row dofs type for class st3_e3 |
| Cst3_lite | A symmetric rank 3 tensor over an abstract vector space. (volatile version) |
| Cst4 | A symmetric rank 4 tensor over an abstract vector space (persistent version) |
| Cst4_e2 | A symmetric rank 3 tensor over a 3D Euclidean vector space (persistent version) |
| Cst4_e2_lite | A symmetric rank 4 tensor over a Euclidean vector space of dimension 3. (volatile version) |
| Cst4_e2_row_dofs_type | Row dofs type for class st4_e2 |
| Cst4_e3 | A symmetric rank 3 tensor over a 3D Euclidean vector space (persistent version) |
| Cst4_e3_lite | A symmetric rank 4 tensor over a Euclidean vector space of dimension 3. (volatile version) |
| Cst4_e3_row_dofs_type | Row dofs type for class st4_e3 |
| Cst4_lite | A symmetric rank 4 tensor over an abstract vector space. (volatile version) |
| Cstp | A symmetric tensor of degree p over an abstract vector space |
| Cstp_lite | A symmetric tensor of degree p over an abstract vector space (volatile version) |
| Cstp_space | An abstract symmetric tensor space of degree p |
| Cstructured_block | A client handle for a base space member which represents a homgeneous collection of local cells |
| Cstructured_block_1d | A homogeneous collection of connected segments arranged in an i_size() array |
| Cstructured_block_1d_crg_interval | Emulator for a interval of implicit base space members representing a 1 dimensional structured block, that is, a homogeneous collection of connected quads arranged in an i_size() array |
| Cstructured_block_2d | A homogeneous collection of connected quads arranged in an i_size() x j_size() array |
| Cstructured_block_2d_crg_interval | Emulator for a interval of implicit base space members representing a 2 dimensional structured block, that is, a homogeneous collection of connected quads arranged in an i_size() x j_size() array |
| Cstructured_block_3d | A homogeneous collection of connected hexahedra arranged in an i_size() x j_size() x k_size() array |
| Cstructured_block_3d_crg_interval | Emulator for a interval of implicit base space members representing a 3 dimensional structured block, that is, a homogeneous collection of connected hexahedra arranged in an i_size() x j_size() x k_size() array |
| Csymmetric_matrix_2x2 | Symmetric matrix with 2 rows and 2 columns |
| Csymmetric_matrix_3x3 | Symmetric matrix with 3 rows and 3 columns |
| Ct02_e2_row_dofs_type | |
| Ct02_e3_row_dofs_type | |
| Ct11_e2_row_dofs_type | |
| Ct2 | A tensor of degree 2 over an abstract vector space (persistent version) |
| Ct2_e2 | A tensor of degree 2 over a Euclidean vector space of dimension 2 (persistent version) |
| Ct2_e2_lite | A tensor of degree 2 over a Euclidean vector space of dimension 2 (volatile version) |
| Ct2_e2_row_dofs_type | Row dofs type for class t2_e2 |
| Ct2_e3 | A tensor of degree 2 over a Euclidean vector space of dimension 3 (persistent version) |
| Ct2_e3_lite | A tensor of degree 2 over a Euclidean vector space of dimension 3 (volatile version) |
| Ct2_e3_row_dofs_type | Row dofs type for class t2_e3 |
| Ct2_lite | A tensor of degree 2 over an abstract vector space (volatile version) |
| Ct3 | A tensor of degree 3 over an abstract vector space (persistent version) |
| Ct3_e3 | A tensor of degree 3 over a Euclidean vector space of dimension 3 (persistent version) |
| Ct3_e3_lite | A tensor of degree 3 over a Euclidean vector space of dimension 3 (volatile version) |
| Ct3_e3_row_dofs_type | Row dofs type for class t3_e3 |
| Ct3_lite | A tensor of degree 3 over an abstract vector space (volatile version) |
| Ct4 | A tensor of degree 4 over an abstract vector space (persistent version) |
| Ct4_e2 | A tensor of degree 4 over a Euclidean vector space of dimension 2 (persistent version) |
| Ct4_e2_lite | A tensor of degree 4 over a Euclidean vector space of dimension 2 (volatile version) |
| Ct4_e2_row_dofs_type | Row dofs type for class t4_e2 |
| Ct4_e3 | A tensor of degree 4 over a Euclidean vector space of dimension 3 (persistent version) |
| Ct4_e3_lite | A tensor of degree 4 over a Euclidean vector space of dimension 3 (volatile version) |
| Ct4_e3_row_dofs_type | Row dofs type for class t4_e3 |
| Ct4_lite | A tensor of degree 4 over an abstract vector space (volatile version) |
| Ctensor_section_traits | Tensor types of degree P over VECTOR_TYPE. Must be specialized for every supported combination of VECTOR_TYPE and P |
| Ctensor_section_traits< 0, sec_e2 > | Specialization for degree 0 tensors over sec_e2 |
| Ctensor_section_traits< 0, sec_e3 > | Specialization for degree 0 tensors over sec_e3 |
| Ctensor_section_traits< 0, sec_e4 > | Specialization for degree 0 tensors over sec_e4 |
| Ctensor_section_traits< 0, sec_vd > | Tensor types of degree 0 over sec_vd; full specialization |
| Ctensor_section_traits< 1, sec_e2 > | Specialization for degree 1 tensors over sec_e2 |
| Ctensor_section_traits< 1, sec_e3 > | Specialization for degree 1 tensors over sec_e3 |
| Ctensor_section_traits< 1, sec_e4 > | Specialization for degree 1 tensors over sec_e4 |
| Ctensor_section_traits< 1, sec_vd > | Tensor types of degree 1 over sec_vd; full specialization |
| Ctensor_section_traits< 2, sec_e2 > | Specialization for degree 2 tensors over sec_e2 |
| Ctensor_section_traits< 2, sec_e3 > | Specialization for degree 2 tensors over sec_e3 |
| Ctensor_section_traits< 2, sec_e4 > | Specialization for degree 2 tensors over sec_e4 |
| Ctensor_section_traits< 2, sec_vd > | Tensor types of degree 2 over sec_vd; full specialization |
| Ctensor_section_traits< 3, sec_e3 > | Specialization for degree 3 tensors over sec_e3 |
| Ctensor_section_traits< 3, sec_e4 > | Specialization for degree 3 tensors over sec_e4 |
| Ctensor_section_traits< 3, sec_vd > | Tensor types of degree 3 over sec_vd; full specialization |
| Ctensor_section_traits< 4, sec_vd > | Tensor types of degree 4 over sec_vd; full specialization |
| Ctensor_section_traits< P, sec_vd > | Tensor types of degree P over sec_vd; partial specialization |
| Ctensor_traits | Tensor types of degree P over VECTOR_TYPE. No generic implementation defined, must be specialized for every supported combination of VECTOR_TYPE and P |
| Ctensor_traits< 0, e2 > | Specialization for degree 0 tensors over e2 |
| Ctensor_traits< 0, e2_lite > | Specialization for degree 0 tensors over e2_lite |
| Ctensor_traits< 0, e3 > | Specialization for degree 0 tensors over e3 |
| Ctensor_traits< 0, e3_lite > | Specialization for degree 0 tensors over e3_lite |
| Ctensor_traits< 0, e4 > | Specialization for degree 0 tensors over e4 |
| Ctensor_traits< 0, e4_lite > | Specialization for degree 0 tensors over e4_lite |
| Ctensor_traits< 0, vd_lite > | Tensor types of degree 0 over vd_lite; full specialization |
| Ctensor_traits< 1, e2 > | Specialization for degree 1 tensors over e2 |
| Ctensor_traits< 1, e2_lite > | Specialization for degree 1 tensors over e2_lite |
| Ctensor_traits< 1, e3 > | Specialization for degree 1 tensors over e3 |
| Ctensor_traits< 1, e3_lite > | Specialization for degree 1 tensors over e3_lite |
| Ctensor_traits< 1, e4 > | Specialization for degree 1 tensors over e4 |
| Ctensor_traits< 1, e4_lite > | Specialization for degree 1 tensors over e4_lite |
| Ctensor_traits< 1, vd_lite > | Tensor types of degree 1 over vd_lite; full specialization |
| Ctensor_traits< 2, e2 > | Specialization for degree 2 tensors over e2 |
| Ctensor_traits< 2, e2_lite > | Specialization for degree 2 tensors over e2_lite |
| Ctensor_traits< 2, e3 > | Specialization for degree 2 tensors over e3 |
| Ctensor_traits< 2, e3_lite > | Specialization for degree 2 tensors over e3_lite |
| Ctensor_traits< 2, e4 > | Specialization for degree 2 tensors over e4 |
| Ctensor_traits< 2, e4_lite > | Specialization for degree 2 tensors over e4_lite |
| Ctensor_traits< 2, vd_lite > | Tensor types of degree 2 over vd_lite; full specialization |
| Ctensor_traits< 3, e2 > | Specialization for degree 3 tensors over e2 |
| Ctensor_traits< 3, e2_lite > | Specialization for degree 3 tensors over e2_lite |
| Ctensor_traits< 3, e3 > | Specialization for degree 3 tensors over e3 |
| Ctensor_traits< 3, e3_lite > | Specialization for degree 3 tensors over e3_lite |
| Ctensor_traits< 3, e4 > | Specialization for degree 3 tensors over e4 |
| Ctensor_traits< 3, e4_lite > | Specialization for degree 3 tensors over e4_lite |
| Ctensor_traits< 3, vd_lite > | Tensor types of degree 3 over vd_lite; full specialization |
| Ctensor_traits< 4, e2 > | Specialization for degree 4 tensors over e2 |
| Ctensor_traits< 4, e2_lite > | Specialization for degree 4 tensors over e2_lite |
| Ctensor_traits< 4, e3 > | Specialization for degree 4 tensors over e3 |
| Ctensor_traits< 4, e3_lite > | Specialization for degree 4 tensors over e3_lite |
| Ctensor_traits< 4, e4 > | Specialization for degree 4 tensors over e4 |
| Ctensor_traits< 4, e4_lite > | Specialization for degree 4 tensors over e4_lite |
| Ctensor_traits< 4, vd_lite > | Tensor types of degree 4 over vd_lite; full specialization |
| Ctensor_variance | The "type" of a tensor; specifies the degree and the co- or contra-variance for each index of a tensor |
| Cternary_index | A triple of indices (i,j, k) |
| Cternary_index_space | A bounded domain for ternary_index objects |
| Ctetra_connectivity | Nodal connectivity for a block containing zones of type tetra |
| Ctp | A general tensor of "degree" p and given "variance" over an abstract vector space |
| Ctp_lite | A general tensor of degree p over an abstract vector space (volatile version). Volatile version does not support tensor type ("variance"); see further comments in class tp |
| Ctp_space | An abstract tensor space of degree p |
| Ctp_table_dofs_type | Table dofs type for class tp |
| Ctriangle_connectivity | Nodal connectivity for a block containing zones of type triangle |
| Ctrilinear_3d | A section evaluator using trilinear interpolation over a cubic 3D domain |
| Ctuple | A member of a Cartesian product space; a tuple of attributes (persistent version) |
| Ctuple_lite | A member of a Cartesian product space; a tuple of attributes (volatile version) |
| Ctuple_space | A Cartesian product space |
| Ctuple_table_dofs_type | Table dofs type for class tuple_table_dofs_type |
| Cunary_index_space | A bounded domain for unary_index objects |
| Cuniform_1d | A section evaluator using linear interpolation over a 1D domain which is refined into a uniform mesh |
| Cuniform_2d | A section evaluator using bilinear interpolation over a square 2D domain. Intended for use with uniform meshes |
| Cuniform_3d | A section evaluator using trilinear interpolation over a cubic 3D domain. Intended for use with uniform meshes |
| Cuniform_eval_family | A family of evaluators for uniform meshes |
| Cunstructured_block | OBSOLETE: use zone_nodes_block or point_block_*d. A client handle for a base space member which represents a "unstructured" homogeneous collection of local cells. $$HACK: unstructured_block hack; must use unstructured_block::new_host |
| Cunstructured_block_builder | OBSOLETE: use zone_nodes_block or point_block_*d. A builder object for constructing unstructured blocks given a local cell template and atomic equivalences ("connectivity") |
| Cvd | Abstract vector space over dof_type |
| Cvd_lite | Abstract vector space over dof_type (volatile version) |
| Cvd_row_dofs_type | Row dofs type for class vd |
| Cvd_space | An abstract vector space of dimension d |
| Cvd_table_dofs_type | Table dofs type for class vd_table_dofs_type |
| Czone_nodes_block | A homogeneous collection of zones with nodal connectivity |
| Czone_nodes_block_crg_interval | Emulator for a interval of implicit base space members representing an unstructured block, that is, a homogeneous collection of zones of a given type with nodal connectivity |
| ►Nfields | Namespace for fields component of sheaf system |
| Caverage_base_space_map_push_action | Functor to compute the dofs at a output discretization point by averaging the input values from all branches containing the point |
| Caverage_push_action | Functor to compute the dofs at a destination discretization point by averaging the source values form all branches containing the point |
| Cavg_section_pusher | A section pusher that uses extension by averaging to define the target outside the domain of the source; an incomplete implementation intended mostly as an example of how the section_pusher hierarchy differentiates |
| Cbarycentric_quad_refiner | A field refiner that subdivides a quad into 4 quads by introducing a new vertex in the center of the quad and each of its edges |
| Cbarycentric_refiner_family | A family of field refiners that introduce a new vertex in in the barycenter of each cell (zone, face, edge, vertex) in the down set of a zone |
| Cbarycentric_triangle_refiner | A field refiner that subdivides a triangle into 6 triangles by introducing a new vertex in the center of the triangle and each of its edges |
| Cbase_space_map | A map from one base space to another generated by coordinate sections |
| Cbase_space_map_push_action | Abstract functor to compute the dofs at a destination discretization point |
| Cbody_builder | A simple body builder; creates base space members equivalent to subsets defined by a field classification criterion |
| Cbody_factory | Test case generator for classes body_builder and body_pusher |
| Cbody_pusher | The general push-forward operator for base space members; moves a base space member from one base space to another using the map implied by the global coordinate fields on each base space |
| Cbody_pusher_pullback_action | A discretization push action for body_pusher; pulls a vertex back into the domain base space |
| Cconstant_base_space_map_push_action | Abstract functor to compute the dofs at a destination discretization point |
| Cconstant_push_action | Abstract functor to compute the dofs at a destination discretization point |
| Ccopy_base_space_map_push_action | Functor to compute the dofs at a destination discretization point by copying the source value to the dst dofs |
| Ccopy_push_action | Functor to compute the dofs at a destination discretization point by copying the source value to the dst dofs |
| Cdepth_bound_refinement_policy | A policy that determines a zone should be refined if the refinement depth is less than a given upper bound. Intended mostly for use debugging the refinement machinery |
| Cdiscretization_hash | A hash function class for discretization map entries |
| Cdiscretization_push_action | The action to executed by discretization_pusher::push on each member of a discretization subposet |
| Cdiscretization_pusher | A push-forward operator for discretization subposets; pushes members into the global coordinate space |
| Cedge_centered_polygon_refiner | An abstract field refiner that subdivides a polygon by introducing new vertices into the centers of the edges |
| Cedge_centered_refiner_family | A family of field refiners that introduce a new vertex in each edge, but avoid introducing new vertices in the center of the zone whenever possible. / |
| Cedge_centered_triangle_refiner | A field refiner that subdivides a triangle into 4 triangles by introducing a new vertex in the center of each edge |
| Cfield_at0 | A property of type sec_at0 as a function of global coordinates |
| Cfield_at1 | A property of type sec_at1 as a function of global coordinates |
| Cfield_at2 | A property of type sec_at2 as a function of global coordinates |
| Cfield_at2_e2 | A property of type sec_at2_e2 as a function of global coordinates |
| Cfield_at2_e3 | A property of type sec_at2_e3 as a function of global coordinates |
| Cfield_at3 | A property of type sec_at3 as a function of global coordinates |
| Cfield_at3_e3 | A property of type sec_at3_e3 as a function of global coordinates |
| Cfield_atp | A property of type sec_atp as a function of global coordinates |
| Cfield_e1 | A property of type sec_e1 as a function of global coordinates |
| Cfield_e1_uniform | A property of type sec_e1_uniform as a function of global coordinates |
| Cfield_e2 | A property of type sec_e2 as a function of global coordinates |
| Cfield_e2_uniform | A property of type sec_e2_uniform as a function of global coordinates |
| Cfield_e3 | A property of type sec_e3 as a function of global coordinates |
| Cfield_e3_uniform | A property of type sec_e3_uniform as a function of global coordinates |
| Cfield_e4 | A property of type sec_e4 as a function of global coordinates |
| Cfield_ed | A property of type sec_ed as a function of global coordinates |
| Cfield_eval_iterator | An iterator which concurrently traverses the schema of both the coordinates and property sections of a field. The two schema must share the same base space and evaluation subposet |
| Cfield_factory | Test case generator for fields cluster |
| Cfield_factory_2 | A factory for making field_vd objects with coordinates section of type coord_type, property section of type prop_type and base space of type base_type |
| Cfield_jcb | A property of type sec_jcb as a function of global coordinates |
| Cfield_jcb_e13 | A property of type sec_jcb_e13 as a function of global coordinates |
| Cfield_jcb_e23 | A property of type sec_jcb_e23 as a function of global coordinates |
| Cfield_jcb_e33 | A property of type sec_jcb_e33 as a function of global coordinates |
| Cfield_jcb_ed | A property of type sec_jcb_ed as a function of global coordinates |
| Cfield_met | A property of type sec_met as a function of global coordinates |
| Cfield_met_e1 | A property of type sec_met_e1 as a function of global coordinates |
| Cfield_met_e2 | A property of type sec_met_e2 as a function of global coordinates |
| Cfield_met_e3 | A property of type sec_met_e3 as a function of global coordinates |
| Cfield_met_ed | A property of type sec_met_ed as a function of global coordinates |
| Cfield_refinement_buffer | A buffer for data which is used by both a local_field_refiner object and its associated field_refinement_policy object |
| Cfield_refinement_policy | An abstract policy that determines the conditions under which a zone should be refined |
| Cfield_refiner | Refines a given field and its base space using a given refinement policy and refiner family |
| Cfield_refiner_family | A family of compatible local_field_refiners, one for each member of some family of cell types; a map from cell type to field_type |
| Cfield_st2 | A property of type sec_st2 as a function of global coordinates |
| Cfield_st2_e2 | A property of type sec_st2_e2 as a function of global coordinates |
| Cfield_st2_e3 | A property of type sec_st2_e3 as a function of global coordinates |
| Cfield_st3 | A property of type sec_st3 as a function of global coordinates |
| Cfield_st3_e3 | A property of type sec_st3_e3 as a function of global coordinates |
| Cfield_st4 | A property of type sec_st4 as a function of global coordinates |
| Cfield_st4_e2 | A property of type sec_st4_e2 as a function of global coordinates |
| Cfield_st4_e3 | A property of type sec_st4_e3 as a function of global coordinates |
| Cfield_stp | A property of type sec_stp as a function of global coordinates |
| Cfield_t2 | A property of type sec_t2 as a function of global coordinates |
| Cfield_t2_e2 | A property of type sec_t2_e2 as a function of global coordinates |
| Cfield_t2_e3 | A property of type sec_t2_e3 as a function of global coordinates |
| Cfield_t3 | A property of type sec_t3 as a function of global coordinates |
| Cfield_t3_e3 | A property of type sec_t3_e3 as a function of global coordinates |
| Cfield_t4 | A property of type sec_t4 as a function of global coordinates |
| Cfield_t4_e2 | A property of type sec_t4_e2 as a function of global coordinates |
| Cfield_t4_e3 | A property of type sec_t4_e3 as a function of global coordinates |
| Cfield_tp | A property of type sec_tp as a function of global coordinates |
| Cfield_traits | Features describing a field type. Declaration only; there is no generic implementation for this template. It is implemented only via specializations |
| Cfield_traits< sec_at0 > | |
| Cfield_traits< sec_at1 > | |
| Cfield_traits< sec_at2 > | |
| Cfield_traits< sec_at2_e2 > | |
| Cfield_traits< sec_at2_e3 > | |
| Cfield_traits< sec_at3 > | |
| Cfield_traits< sec_at3_e3 > | |
| Cfield_traits< sec_atp > | |
| Cfield_traits< sec_e1 > | |
| Cfield_traits< sec_e1_uniform > | |
| Cfield_traits< sec_e2 > | |
| Cfield_traits< sec_e2_uniform > | |
| Cfield_traits< sec_e3 > | |
| Cfield_traits< sec_e3_uniform > | |
| Cfield_traits< sec_e4 > | |
| Cfield_traits< sec_ed > | |
| Cfield_traits< sec_jcb > | |
| Cfield_traits< sec_jcb_e13 > | |
| Cfield_traits< sec_jcb_e23 > | |
| Cfield_traits< sec_jcb_e33 > | |
| Cfield_traits< sec_jcb_ed > | |
| Cfield_traits< sec_met > | |
| Cfield_traits< sec_met_e1 > | |
| Cfield_traits< sec_met_e2 > | |
| Cfield_traits< sec_met_e3 > | |
| Cfield_traits< sec_met_ed > | |
| Cfield_traits< sec_st2 > | |
| Cfield_traits< sec_st2_e2 > | |
| Cfield_traits< sec_st2_e3 > | |
| Cfield_traits< sec_st3 > | |
| Cfield_traits< sec_st3_e3 > | |
| Cfield_traits< sec_st4 > | |
| Cfield_traits< sec_st4_e2 > | |
| Cfield_traits< sec_st4_e3 > | |
| Cfield_traits< sec_stp > | |
| Cfield_traits< sec_t2 > | |
| Cfield_traits< sec_t2_e2 > | |
| Cfield_traits< sec_t2_e3 > | |
| Cfield_traits< sec_t3 > | |
| Cfield_traits< sec_t3_e3 > | |
| Cfield_traits< sec_t4 > | |
| Cfield_traits< sec_t4_e2 > | |
| Cfield_traits< sec_t4_e3 > | |
| Cfield_traits< sec_tp > | |
| Cfield_vd | A vd-valued property as a function of global coordinates |
| Clocal_field_refiner | An abstract refiner for a field over a local region (primitive cell) in the base space |
| Cprint_property_dofs_action | A discretization push action for field_vds::print_property_dofs |
| ►Cproperty_disc_iterator | Abstract iterator over the discretization of the property section of a field_vd. Concurrently traverses the schema of both the coordinates and property sections of a field, returning to the client at each property discretization member, with enough context to evaluate the coordinate section at the property discretization point |
| Cdepth_flags_type | Relative depth flags type |
| Cproperty_disc_iterator_1_1 | A property discretization iterator for a property section with the same discretization as the coordinates section |
| Cproperty_disc_iterator_1_2 | A property discretization iterator for a proerty section with the same evaluation subposet as the coordinates section and with the property evaluation strictly above the property discretization |
| Cproperty_disc_iterator_1_3 | A property discretization iterator for a property section with the same evaluation subposet as the coordinates section and with the property evaluation at or below the property discretization |
| Cproperty_disc_iterator_4_2 | A property discretization iterator for a field with uniform coordinates section and a property section with the evaluation strictly above the discretization |
| Cproperty_disc_iterator_4_3 | A property discretization iterator for a field with uniform coordinates section and a property section with the discretization at or above the evaluation |
| Cpullback_map | A map from members of a discretization subposet to points in a base space |
| Cpullback_map_entry | An entry in a discretization map |
| Cput_property_dofs_action | An abstract discretization push action for field_vds::put_property_dofs |
| Cput_property_dofs_fcn_action | A discretization push action for field_vds::put_property_dofs that uses a client provided function to compute the dofs |
| Crefining_section_pusher | A refining section push-forward operator. Moves sections from one sec_rep_space to another using extension by zero to define the target outside the domain of the source. Refines the base of the target as specfied by a given refinement policy |
| Csection_pusher | The general section push-forward operator; moves sections from one sec_rep_space to another using extension by zero to define the target outside the domain of the source |
| Csection_pusher_pullback_action | A discretization push action for section_pusher; pulls a range discretization member back into the domain base space |
| Csection_pusher_push_action | Abstract functor to compute the dofs at a destination discretization point |
| Cvariance_bound_refinement_policy | A policy that determines a zone should be refined if the variance using the L1 norm of any discretization member exceeds a given upper bound |
| Czone_centered_error_bound_refinement_policy | A policy that determines a zone should be refined if the error with respect to the source field at the zone center exceeds a given upper bound |
| Czone_centered_refiner_family | A family of field refiners that introduce a new vertex in the center of a zone, but not in the boundary of a zone |
| Czone_centered_segment_refiner | A field refiner that introduces a new vertex in the center of a segment |
| Czone_centered_tet_refiner | A field refiner that subdivides a tet into 4 tets by introducing a new vertex in the center |
| Czone_centered_triangle_refiner | A field refiner that introduces a new vertex in the center of a triangle, but not in the edges |
| ►Ngeometry | Namespace for geometry component of sheaf system |
| Carray_cylindrical_point_locator | A point location query in domains with global coordinate dimension DC and local coordinate dimension DB implemented using a DC index array search structure. Efficient for for compact (axis-aligned, box-shaped) domains |
| Ccylindrical_point_locator | An abstract point location query in domains with global coordinate dimension dc and local coordinate dimension db using a search structure based on sorting bounding boxes into a set of bins |
| Cd_array_point_locator | A point location query in domains with global coordinate dimension DC and local coordinate dimension DB implemented using a DC index array search structure. Efficient for for compact (axis-aligned, box-shaped) domains |
| Cd_bin_coordinates | Fixed point relative coordinates for a tree domain |
| Cd_bin_point_locator | An abstract point location query in domains with global coordinate dimension dc and local coordinate dimension db using a search structure based on sorting bounding boxes into a set of bins |
| Cd_bounding_box | A bounding box that can be strung together into a list |
| Cd_tree_point_locator | A point location query in domains with global coordinate dimension dc and local coordinate dimension db. implemented using a 2^DC tree search structure. Efficient for non-compact domains |
| Cd_tree_point_locator_node | A node in a d_tree_point_locator search structure |
| Cd_tree_point_locator_path | A path in an d_tree_point_locator search structure |
| Cd_uniform_point_locator | A point location query in domains with uniform global coordinates of dimension dc and local coordinate dimension db |
| ►Cdb0_point_locator | An abstract point location query in domains with global coordinate dimension DC and local coordinate dimension 0 using a search structure based on sorting bounding boxes into a regular array of bins |
| Cvertex_type | The information stored in the search structure for each vertex |
| Cgeometry_namespace | Namespace for GEOMETRY component |
| ►Cline_surface_intersecter | A line-surface intersection query |
| Creally_less_than | Compare functor makes sure surface values are really different |
| Cpoint_locator | An abstract point location query in domains with global coordinate dimension dc and local coordinate dimension db |
| Csec_ed_invertible | An abstract invertible section of a fiber bundle with a d-dimensional base space and a d-dimensional Euclidean vector space fiber |
| ►Nsheaf | Namespace for the sheaves component of the sheaf system |
| Cabstract_poset_member | An abstract client handle for a member of a poset |
| Cabstract_poset_member_row_dofs_type | Row dofs type for class abstract_poset_member |
| Cabstract_poset_member_table_dofs_type | Table dofs type for class abstract_poset_member |
| Cabstract_product_structure | An abstract class that defines the product structure for an id space |
| Cany | Abstract base class with useful features for all objects |
| ►Carg_list | A whitespace separated list of arguments. Insertion operaters are used to insert arguments into the list. C++ strings are treated as string literals. The value of the string is inserted into arg_list |
| Carg_type | The internal argument type |
| Carray_implicit_index_space_iterator | An implementation of implicit_index_space_iterator for an implicit id space in an array_index_space_interval. The equivalence between the ids in the space and the hub id space is stored in an array |
| Carray_index_space_handle | An array implementation of class scattered_insertion_index_space_handle. This representation is intended to efficiently represent id spaces that are positive and dense, that is, the domain ids are in the domain (~0, ~end()) and hence the id to hub id map can be efficiently stored in an array. In particular it is intended for id spaces used to index arrays, in which case the ids are in the domain [0, end()) |
| Carray_index_space_interval | An implementation of index_space_interval for an interval of implicit id spaces in which the hub ids are stored in a two dimensional array |
| Carray_index_space_iterator | An iterator over an id space in which the equivalence between the ids in the space and the hub id space is stored in an array |
| Carray_index_space_state | An array implementation of class scattered_insertion_index_space_state. This representation is intended to efficiently represent id spaces that are positive and dense, that is, the domain ids are in the domain (~0, ~end()) and hence the id to hub id map can be efficiently stored in an array. In particular it is intended for id spaces used to index arrays, in which case the ids are in the domain [0, end()) |
| Carray_poset_dof_map | An array representation of abstract class poset_dof_map |
| Cattributes_record | An abstract wrapper/adapter for attributes records. Intended for transferring data between the kernel and the i/o subsystem |
| Cattributes_record_set | A record set for storing various poset attributes |
| Cauto_block | A contiguously allocated array of items of type T with size information and automatic resizing |
| Cbinary_index_block | A block which can be accessed using two indices, similarly to a two index array |
| Cbiorder_iterator | Specialization of the filtered depth-first iterator which exposes the PREVISIT_ACTION and the POSTVISIT_ACTION to the client |
| Cbiorder_itr | Specialization of the filtered depth-first iterator which exposes the PREVISIT_ACTION and the POSTVISIT_ACTION to the client |
| Cblock | An auto_block with a no-initialization initialization policy |
| Cconstant_implicit_index_space_iterator | An implementation of implicit_index_space_iterator for an implicit id space in an constant_index_space_interval |
| Cconstant_index_space_interval | An implementation of index_space_interval for an interval of implicit id spaces with a single id and in which the hub ids can be calculated by an offset |
| Ccrg_interval | Abstract emulator for an interval of cover relation graph members |
| Cdata_converter | Function object to convert between internal and external data formats |
| Cdata_type_map | A collection of data converters that map data types between internal and external representations |
| Cdepth_first_iterator | |
| Cdepth_first_itr | The general depth-first iterator over the intersection of a poset member anchor's whole with its down set. Implemented as a finite state machine with a client selectable state transition function that can be chosen to provide various iteration orders. The iterator returns control to the client so that the it can perform client-defined actions. There are three action types, the PREVISIT_ACTION, the POSTVISIT_ACTION, and the LINK_ACTION, each associated with specific positions in the iteration. The previsit position is immediately before iteration over the cover of the current member begins. The postvisit position is immediately after iteration over the cover ends. The link position is on the current link, immediately after the lesser end of the link has been visited and context has ascended to the current link. The link action thus immediately follows the postvisit action of the lesser member, but the context is different. This iterator visits every link in the cover relation graph below the anchor of the iteration, maintaining a path to the current member. Conceptually, the path is a list of pointers to lower cover iterators. The current member of each iterator is a node in the path. Physically, the path is stored in two parts. _index is the head of the list. The tail of the list is stored in the variable _path. The current link in the graph is the link between the front of _path and _index, with _index being the lesser member of the link |
| ►Cdof_descriptor_array | An array for storing structs which describe the size, alignment, and offset of dofs within a dof tuple |
| Cdof_descriptor | Basic description of a dof |
| Cdof_map_factory | A factory for creating dof maps |
| Cdof_tuple_class_names_record | A wrapper/adapter for the dof tuple class names record. Intended for transferring index-name map data between the kernel and the i/o subsystem |
| Cdof_tuple_col_bounds_record | A wrapper/adapter for the dof tuple column bounds record. Intended for transferring index-bounds map data between the kernel and the i/o subsystem |
| Cdof_tuple_domain_offsets_record | A wrapper/adapter for the dof tuple domain offsets record. Intended for transferring index-offsets map data between the kernel and the i/o subsystem |
| Cdof_tuple_record_set | A record_set which contains dof tuple records. Supports both record selection and record restriction (partial records) |
| Cdof_tuple_schema_ids_record | A wrapper/adapter for the dof tuple schema ids record. Intended for transferring index-id map data between the kernel and the i/o subsystem |
| Cdof_tuple_schema_versions_record | A wrapper/adapter for the dof tuple schema versions record. Intended for transferring index-version map data between the kernel and the i/o subsystem |
| Cdof_tuple_types_record | A wrapper/adapter for the dof type types record. Intended for transferring dof tuple type id data between the kernel and the i/o subsystem |
| Cequivalence_compare_policy | A stl_scoped_index comparison policy for equivalence comparison |
| Cerror_message | A message to report error conditions |
| Cexplicit_crg_interval | Implementation of crg_interval for explicit members of the poset |
| Cexplicit_index_space_collection | An implementation of index_space_collection for a sparse collection of explicit id spaces |
| Cexplicit_index_space_handle | An implementation of class index_space_handle for an explicit_index_space_state |
| Cexplicit_index_space_interval | An implementation of index_space_interval for an interval of explicit id spaces |
| Cexplicit_index_space_iterator | An implementation of class index_space_iterator for an explicit_index_space_state |
| Cexplicit_index_space_state | An immutable abstract state for a space of alternate integer identifiers (aliases) for a subset of the hub set of integer identifiers |
| Cfactory | A factory for instanting descendants of an abstract type T, given the class name of the descendant. Requires: virtual const string& T::class_name() the actual (descendant) class name of the prototype. virtual T* T::clone() virtual default constructor virtual bool is_initialized() true if instance is fully initialized |
| Cfactory_2 | A factory for instanting descendants of an abstract type T, given the class name of the descendant. Requires: virtual const string& T::class_name() the actual (descendant) class name of the prototype. virtual R T::clone() virtual default constructor virtual R T::clone(S& xarg) virtual constructor |
| Cfile_data_type_map | A collection of data converters that map data types between internal and external representations associated with a specific file |
| Cfiltered_depth_first_iterator | |
| Cfiltered_depth_first_itr | The general depth-first iterator over the intersection of a subposet filter with a directional (up or down) set of a poset member anchor. Implemented as a finite state machine with a client selectable state transition function that can be chosen to provide various iteration orders. The iterator returns control to the client so that the it can perform client-defined actions. There are three action types, the PREVISIT_ACTION, the POSTVISIT_ACTION, and the LINK_ACTION, each associated with specific positions in the iteration. The previsit position is immediately before iteration over the cover of the current member begins. The postvisit position is immediately after iteration over the cover ends. The link position is on the current link, immediately after the lesser end of the link has been visited and context has ascended to the current link. The link action thus immediately follows the postvisit action of the lesser member, but the context is different. This iterator visits every link in the cover relation graph above/below the anchor of the iteration, maintaining a path to the current member. Conceptually, the path is a list of pointers to lower cover iterators. The current member of each iterator is a node in the path. Physically, the path is stored in two parts. _index is the head of the list. The tail of the list is stored in the variable _path. The current link in the graph is the link between the front of _path and _index, with _index being the lesser member of the link |
| Cfiltered_depth_first_member_iterator | |
| Cforwarding_index_space_handle | An implementation of class index_space_handle for an forwarding_index_space_state |
| Cgathered_insertion_index_space_handle | A handle for a gathered_insertion_index_space_state |
| Cgathered_insertion_index_space_state | An implementation of class explicit_index_space_state that supports gathered insertion of new members, that is, new members can only be inserted within the existing domain interval or at the end of it |
| Chash_index_space_handle | An hash map implementation of class scattered_insertion_index_space_handle. This representation is intended to efficiently represent id spaces that are possibly negative and are sparse, that is, end() is much greater than ct() and hence uses hash maps to represent both directions of the map |
| Chash_index_space_iterator | An iterator over an id space in which the equivalence between the ids in the space and the hub id space is stored in an hash |
| Chash_index_space_state | An hash map implementation of class scattered_insertion_index_space_state. This representation is intended to efficiently represent id spaces that are possibly negative and are sparse, that is, end() is much greater than ct() and hence uses hash maps to represent both directions of the map |
| Chub_index_space_handle | An implementation of class sum_index_space_handle that has a primary sum id space state |
| Chub_index_space_iterator | An iterator over an id space which is the sum of the primary id spaces |
| Cid_block | A block of ids all in the same id space |
| Cid_space_names_record | A wrapper/adapter for the id space names record. Intended for transferring id map data between the kernel and the i/o subsystem |
| Cij_product_structure | A 2D implementation of abstract_product_structure |
| Cijk_product_structure | A 3D implementation of abstract_product_structure |
| Cimplicit_crg_interval | Abstract implementation of crg_interval for an interval of implicit cover relation graph members |
| Cimplicit_entry_map | A map in which the entries may be implicit |
| Cimplicit_entry_map_iterator | An iterator over the entries in an implicit_entry_map. This iteration is NOT order preserving |
| Cimplicit_index_space_iterator | An implementation of class index_space_iterator for id spaces that are implicitly represtented |
| Cindex_equivalence_class | Data structure containing the id equivalence class for ab id space family. This class is used as a temporary data structured to be used by id equivalence iterator. This class consists of a block of lists. Each list has the equivalence id for the representive id in a given scope |
| Cindex_equivalence_iterator | An iterator over members of an id equivalence class |
| Cindex_iterator | Iterates over the subset of Zn defined by the characteristic function host() |
| Cindex_scope | Default id map for objects of type scoped_index. A convenient and safe mechanism for managing scoped_index::default_scope() |
| Cindex_space_collection | A collection of id space states. This is a virtual class with provides an interface for accessing the id space states via the collection's local indexing |
| Cindex_space_family | Factory and container for a family of id spaces |
| Cindex_space_family_iterator | An abstract iterator over the id spaces of a interval |
| Cindex_space_handle | An abstract handle to a space of alternate integer identifiers (aliases) for a subset of a hub set of integer identifiers |
| Cindex_space_interval | An implemenation of index_space_collection that adds an interface for the interval [begin(), end()) in the id space family |
| Cindex_space_interval_iterator | An abstract iterator over the id spaces of a interval |
| Cindex_space_iterator | An abstract iterator over the ids of an id space |
| Cindex_traits | Features describing T as an index type |
| Cindex_traits< scoped_index > | Features describing scoped_index as an index type |
| Cint_set | An STL set representation for a set of integers |
| Cinterval | Struct representing the closed interval [_begin, _end] |
| Cinterval_index_space_handle | An implementation of class scattered_insertion_index_space_handle that has a interval id space state |
| Cinterval_index_space_iterator | An iterator over an id space in which the equivalence between the ids in the space and the hub id space is stored in intervals |
| Cinterval_index_space_record | A record buffer for transferring file id id space data for the member record data set between the kernel and the i/o subsystem |
| Cinterval_index_space_state | An STL map implementation of class scattered_insertion_index_space_state optimized to efficiently represent id spaces that consist of a collection of closed intervals [begin, end] in both the domain id space and the range id space. Each entry (domain_end, range_end) in the _to_domain map represents the end of a interval in the range id space. If the range interval is not mapped to an domain interval, domain_end is the invalid index value. _to_domain.lower_bound(i) returns the end of the interval containing i and, if domain_end is valid, pod(i) can be computed from i, range_end, and domain_end |
| Cinterval_set | Set of integers optimized for when the integers are concentrated in closed intervals |
| Cinterval_set_iterator | An iterator over the integers in an interval_set |
| Cinvalid_block_initialization_policy | A auto_block initialization policy that initializes the values to invalid |
| Cinvalid_block_initialization_policy< double > | |
| Cinvalid_block_initialization_policy< float > | |
| Ckey_deep_size_policy | Call deep_size on the key |
| Ckey_value_deep_size_policy | Call deep_size on the key and the value |
| Clexographical_compare_policy | A stl_scoped_index comparison policy for lexographical comparison |
| Clinkorder_iterator | |
| Clinkorder_itr | Specialization of the general depth-first iterator which exposes the LINK_ACTION to the client |
| Clist_index_space_handle | An map implementation of class scattered_insertion_index_space_handle. This representation is intended to efficiently represent id spaces that are positive and dense, that is, the domain ids are in the domain (~0, ~end()). This representation is optimized for sequential access and will have a linear asymptotic performance in both time and storage for random access lookup and insertion respectively |
| Clist_index_space_iterator | An iterator over an id space in which the equivalence between the ids in the space and the hub id space is stored in a list |
| Clist_index_space_state | An list implementation of class gathered_insertion_index_space_state. This representation is intended to efficiently represent id spaces that are gathered, that is, the domain ids are in the domain [0, end()). This representation is optimized for sequential access and will have linear asymptotic performance in time for random access lookup and remove |
| Clist_pool | A reallocated pool of objects of type T. Objects in the pool are either allocated or stored in a free list. The object allocated by the pool are tracked. Intended to support efficient allocation and deallocation for small numbers of objects |
| Cmap_record | A record buffer for transferring file id map data for the member record data set between the kernel and the i/o subsystem |
| Cmember_class_names_record | A wrapper/adapter for the member class names record. Intended for transferring index-name map data between the kernel and the i/o subsystem |
| Cmember_member_poset_bounds | A poset bounds pair with lower and upper bounds each specified by a single member |
| Cmember_names_record | A wrapper/adapter for the member names record. Intended for transferring index-name map data between the kernel and the i/o subsystem |
| Cmember_record | A record buffer for transferring member data between the kernel and the i/o subsystem |
| Cmember_record_set | A record_set containing records of type member_record |
| Cname_multimap | A partial multi-valued relation with total injective inverse between names and indices of type index_type |
| Cnamespace_poset | The default name space; a poset which contains other posets as members |
| Cnamespace_poset_dof_map | A map from schema poset member ids to dof values for namespace_poset members |
| Cnamespace_poset_member | A client handle for a member of a namespace poset |
| Cnamespace_poset_schema | The schema poset for the namespace |
| Cnamespace_relative_member_index | Index for identifying a poset member relative to a given name space |
| Cnamespace_relative_member_index_pod_type | POD type for namespace_relative_member_index |
| Cnamespace_relative_record_index | Record index equivalent to namespace_relative_member_index and namespace_relative_subposet_index |
| Cnamespace_relative_record_index_pod_type | The POD (plain old data) type associated with this |
| Cnamespace_relative_subposet_index | Index for identifying a subposet relative to a given name space |
| Cnamespace_relative_subposet_index_pod_type | POD type associated with namespace_relative_subposet_index |
| Cno_deep_size_policy | Do not call deep_size on either the key or value |
| Coffset_index_space_handle | An implementation of class explicit_index_space_handle that has a offset id space state |
| Coffset_index_space_iterator | An iterator over a gathered id space in which the equivlence between the ids in the space and the hub id space is computed using an offset |
| Coffset_index_space_state | A computed implementation of abstract class explicit_index_space_state. This representation assumes the ids are an open gathered set of ids. The equivalence between the ids in this space and the hub id space is computed using an offset |
| Cpartial_poset_member | A client handle for a possibly restricted member of a poset. A partial_poset_member is a poset_member which may be restricted to a subset of the host row schema, but does not export the interface for changing the restriction. / |
| Cplot | A class for constructing files to be read by gnuplot |
| Cpool | A reallocatable pool of objects of type T. Objects in the pool are either "allocated" or linked together into a "free" list. Intended to support efficient allocation and deallocation of nodes in a graph or other dynamic data structure. There is an implicit constraint on T: it must have a next() feature |
| Cposet | A client handle for a mutable partially ordered set |
| Cposet_bounds | A (lower, upper) bounds pair for a poset. Specifies a portion of a poset for a bounded i/o operation |
| Cposet_bounds_descriptor | A description of a (lower, upper) bounds pair for a poset. Specifies a portion of a poset for a bounded i/o operation |
| Cposet_component | Features shared by poset_member and subposet. Subposet and poset_member objects can be attached, detached, and reattached to the poset_state object in a manner similar to the way object references can be attached, detached, and reattached to objects in Eiffel and in Java. This class provides the routines for managing the state attachment for these 2 poset component types. Note: this class is intended only for convenience of implementation. It is is not intended to be used as an abstract interface by clients and may not reliably function as such |
| Cposet_crg_state | The data structure representing the cover relation graph of a poset |
| Cposet_data_type_map | A poset specific collection of data converters, various buffers and other data used while transferring posets between internal and external representations |
| Cposet_dft | Abstract traverser (internal iterator) for poset which traverses the cover relation graph in depth first order |
| Cposet_dof_iterator | Iterates in postorder over dofs of a schema member anchor. Attaches a handle of type schema_poset_member to the current member of the iteration |
| Cposet_dof_map | The general, abstract map from dof ids to dof values |
| Cposet_general_record | A wrapper/adapter for the poset general attributes record. Intended for transferring data between the kernel and the i/o subsystem |
| Cposet_handle_factory | A factory for creating poset handles |
| Cposet_joiner | Computes the join of given poset members |
| Cposet_member | A client handle for a restrictable member of a poset. A poset_member is a poset_member which can be restricted to a subset of the host row schema |
| Cposet_member_iterator | |
| Cposet_orderer | Traverser to ensure validity of order relation |
| Cposet_path | A path defined by a poset name and a member name separated by a forward slash ('/'). For example: "cell_definitions/triangle" |
| Cposet_powerset_state | The set of subsets of a poset |
| Cposet_scaffold | A poset specific collection of data converters, various buffers and other data used while transferring posets between internal and external representations |
| Cposet_slicer | Traverser to compute intersection of the down set (up set) of the anchor with a given subposet. The typical use of this traverser is to compute the maximal (minimal) members of the down set (up set) which are also contained in the given subset. This produces a slice subposet, hence the name of the class |
| Cposet_state | The private state of a partially ordered set |
| Cposet_state_handle | A client handle for a general, abstract partially order set |
| Cposet_table_state | The data structure representing the table containing the dof tuples of the members of a poset |
| Cposet_traverser | Abstract traverser (internal iterator) for poset |
| Cpostorder_iterator | Dperecated. Use postorder_itr. Specialization of the filtered depth-first iterator which exposes the POSTVISIT_ACTION to the client |
| Cpostorder_itr | Specialization of the filtered depth-first iterator which exposes the POSTVISIT_ACTION to the client |
| Cpostorder_member_iterator | |
| Cpreorder_iterator | |
| Cpreorder_itr | Specialization of the filtered depth-first iterator which exposes the PREVISIT_ACTION to the client |
| Cpreorder_member_iterator | |
| Cprimary_index_space_handle | An implementation of class explicit_index_space_handle that has a primary id space state |
| Cprimary_index_space_iterator | An iterator over a gathered id space in which the equivlence between the ids in the space and the hub id space is computed using an offset |
| Cprimary_index_space_state | A computed implementation class explicit_index_space_state that is used for the terms of the primary sum id space |
| Cprimary_sum_index_space_state | An implementation of class sum_index_space_state intended for use as the sum of the primary id spaces |
| Cprimitive_attributes | Abstract object wrapper for an instance of a primitive type |
| Cprimitive_buffer_type | Type of buffer large enough to hold any primitive type |
| Cprimitive_descriptor | |
| Cprimitive_traits | Traits for primitive type T |
| Cprimitive_traits< bool > | |
| Cprimitive_traits< c_string > | |
| Cprimitive_traits< char > | |
| Cprimitive_traits< char const *> | |
| Cprimitive_traits< double > | |
| Cprimitive_traits< float > | |
| Cprimitive_traits< int > | |
| Cprimitive_traits< long double > | |
| Cprimitive_traits< long int > | |
| Cprimitive_traits< long long int > | |
| Cprimitive_traits< namespace_relative_member_index_pod_type > | |
| Cprimitive_traits< namespace_relative_subposet_index_pod_type > | |
| Cprimitive_traits< short int > | |
| Cprimitive_traits< signed char > | |
| Cprimitive_traits< unsigned char > | |
| Cprimitive_traits< unsigned int > | |
| Cprimitive_traits< unsigned long int > | |
| Cprimitive_traits< unsigned long long int > | |
| Cprimitive_traits< unsigned short int > | |
| Cprimitive_traits< void > | |
| Cprimitive_traits< void_star > | |
| Cprimitive_value | Abstract object wrapper for an instance of a primitive type |
| Cprimitives_index_space_handle | An implementation of class explicit_index_space_handle that has a primitives id space state |
| Cprimitives_index_space_iterator | An iterator over the id space for the primitives row dof id space |
| Cprimitives_index_space_state | A implementation of abstract class explicit_index_space_state for the primitives row dof id space |
| Cprimitives_poset | The poset containing the primitive type definitions |
| Cprimitives_poset_dof_map | A map from schema poset member ids to dof values for primitives_poset members |
| Cprimitives_poset_schema | The schema poset for the primitives |
| Cptr_hash | Hash function for pointers |
| Cptr_key_test | Hash set key test for a pointer to type T |
| Cptr_linked_pool | A reallocatable pool of objects of type T. Objects in the pool are either "allocated" or linked together via pointers into a "free" list. Intended to support efficient allocation and deallocation of nodes in a graph or other dynamic data structure. There is an implicit constraint on T: it must have a next() feature |
| Cragged_array | A two index array with variable length rows |
| Cragged_array_implicit_index_space_iterator | An implementation of implicit_index_space_iterator for an implicit id space in an ragged_array_index_space_interval. The equivalence between the ids in the space and the hub id space is stored in a two dimensional array with variable length rows |
| Cragged_array_index_space_interval | An implementation of index_space_interval for an interval of implicit id spaces in which the hub ids are stored in a two dimensional array with variable length rows |
| Crc_any | Base class for reference counting |
| Crc_ptr | Reference-counted pointer to object of type T. T must be an implementation of concept class rc_any |
| Cread_write_monitor | The monitor concurrency control interface. Class READ_WRITE_MONITOR implements the monitor concurrency control paradigm, as described in Andrews, "Concurrent Programming Principles
and Practice". We have extended Andrews design to incorporate two kinds of clients: threads and objects. The thread client interface corresponds to Andrew's design and is intended to mediate access by multiple clients, each of which is expected to gain appropriate access, execute some piece of code and release access. The object client interface is intended for use when a client object depends on the monitored object not changing during the lifetime of the client object. The client gains read-only access to the monitored object and releases the access only when it (the client) is deleted. The read access prevents any thread from gaining write access and hence locks the monitored object for the life of the client. The motivating application for the object client interface is the need to lock poset objects which are being used as the schema for some other (client) poset object. Note that the monitor protocol for the per-thread access control only works if three conditions are satisfied: request_precedes_access: every client always requests access before accessing the object request_precedes_release: every release call by this thread is always preceded by a request call by this thread release_follows_request: every request call by this thread is always followed by a release call by this thread The latter two conditions require that request/release always occur in matching pairs. We are currently enforcing request_precedes_access and request_precedes_release via precondition assertions but we are not enforcing release_follows_request because we don't see any way to do it. We sometimes refer to a client that satisfies request_precedes_access as a "polite" client, and a client that satisfies request_precedes_release and release_follows_request as a "proper" client. The read_write_monitor protocol implemented here requires clients to be both polite and proper. A note on constness. "Logically" const member functions (queries) of monitored classes must be able to get and release read access. This implies that get_read_access and release_access must be const; which in turn requires that in this class most of the other member functions are const and all the data members are mutable |
| Cread_write_monitor_handle | A handle for a hidden read_write_monitor state |
| Crecord | The general variable length record wrapper/adapter for transferring data between the kernel and the i/o subsystem |
| Crecord_map | Insert record_map& p into ostream& os |
| Crecord_queue | A queue for record read requests |
| Crecord_set | An abstract, indexed collection of records on secondary storage |
| Crefinable_poset | A client handle for a partially order set that can be refined, that is, a jim can be converted to a jrm by expanding its down set |
| Creport | A report generating class |
| Creserved_primary_index_space_handle | An implementation of class primary_index_space_handle that has a reserved primary id space state |
| Creserved_primary_index_space_iterator | An iterator over a reserved term in the primary sum id space in which the equivlence between the ids in the space and the hub id space. This iterator can run in two modes. If is_active_only(), only the active interval of ids will be iterated over. If !is_active_only(), all the ids of the space will be iterated over. is_active_only() is the default mode |
| Creserved_primary_index_space_state | A computed implementation of abstract class primary_index_space_state. This representation is used for the reserved term of the hub id space |
| Cscattered_insertion_index_space_handle | A handle for a scattered_insertion_index_space_state |
| Cscattered_insertion_index_space_state | An implementation of class explicit_index_space_state that supports either gathered or scattered insertion of new members, that is, new members can be inserted within the existing domain interval, at the end of it, or discontiguously |
| Cschema_descriptor | A description of a dof in a schema |
| Cschema_poset_member | A client handle for a poset member which has been prepared for use as a schema |
| Cscoped_index | An index within the external ("client") scope of a given id space |
| Cscoped_index_hub_pod | An encapsulated hub pod_index; intended only for implementing scoped_index "operators" ==~ and !=~; see bool scoped_index::operator==(scoped_index_hub_pod) and scoped_index_interal_pod scoped_index::operator~(const scoped_index&) |
| Cset_filter | Set implementation of filter concept |
| Csheaf_constants | OBSOLETE: use sheaf::poset_type, sheaf::dof_tuple_type, etc. Retained only because swig wraps only class members |
| Csheaf_file | An encapsulation of an HDF file containing sheaf data |
| Csheaves_namespace | The standard sheaves name space |
| Csingleton_implicit_index_space_iterator | An implementation of implicit_index_space_iterator for an implicit id space in an singleton_index_space_interval |
| Csingleton_index_space_handle | An implementation of class explicit_index_space_handle that has a singleton id space state |
| Csingleton_index_space_interval | An implementation of index_space_interval for an interval of implicit id spaces with a single id and in which the hub ids can be calculated by an offset |
| Csingleton_index_space_iterator | An iterator over an id space in which contains only one id |
| Csingleton_index_space_state | An implementation of explicit_index_space_state for an id space containing a single id |
| Csingly_linked_list | Wrapper class for forward_list or slist depending on compiler. The class replicates the minimum subset of the forward_list and slist classes. It also implements a push_front function that takes a range |
| Cstandard_member_hack_crg_interval | Implementation of explicit_crg_interval intended only to support the product poset hack in section_space_schema_poset |
| Cstl_scoped_index | Wrapper for scoped_index used for standard template library tree containers (set, multiset, map, multimap). This class redefines operator< to guarantee strict work ordering regardless of the id space |
| Cstop_watch | A clock for timing intervals |
| ►Cstorage_agent | Agent responsible for importing and exporting posets from an external name space which resides on disk |
| Ctransaction | A transaction entity |
| Csubposet | A client handle for a subposet. |
| Csubposet_member_iterator | |
| Csubposet_names_record | A wrapper/adapter for the subposet names record. Intended for transferring subposet name data between the kernel and the i/o subsystem |
| Csubposet_state | The data structure representing the state of a subposet |
| Csum_index_space_handle | An implemenation of class explicit_index_space_handle that has a sum id space state |
| Csum_index_space_state | An abstract id space of alternate integer identifiers which is the sum (disjoint union) of two or more id spaces |
| Ctable_dof_tuple_record | A wrapper/adapter for the table dof tuple record. Intended for transferring data between the kernel and the i/o subsystem |
| Ctern | A three state "bool". Does not provide the operations of ternary logic and is intended for use mostly as a convenient, three-way input argument. Can not be used as a base class since it does not have a virtual destructor |
| Ctotal_poset_member | A client handle for an unrestricted member of a poset. A total_poset_member is guaranteed not to be restricted and its restriction state can not be changed |
| Ctriorder_iterator | |
| Ctriorder_itr | Specialization of the filtered depth-first iterator which exposes all three actions to the client; the PREVISIT_ACTION, the POSTVISIT_ACTION and the LINK_ACTION |
| Cun_block_initialization_policy | An auto_block value initialization policy that leaves the values uninitialized |
| Cunordered_set_filter | Hash set implementation of filter concept |
| Cvalue_deep_size_policy | Call deep_size on the value |
| Cvalue_ptr_deep_size_policy | Call deep_size on the dereferenced pointer of the value |
| Cvariable_length_record | The general variable length record wrapper/adapter for transferring data between the kernel and the i/o subsystem |
| Cwsv_block | Whitespace-separated-value block; A block of objects of type T that can be conveniently initialized by a whitespace-separated list |
| Czero_block_initialization_policy | A auto_block initialization policy that initializes the values to zero |
| Czn_to_bool | A map from Zn (the integers mod n) to bools. A characteristic function used to represent subsets of Zn |
| Czn_to_bool_filter | Zn_to_bool implementation of filter concept |
| ►Ntool | Namespace for the tools component of the sheaf system |
| ►Cvisualization_iterator | Abstract iterator over the schema of both the coordinates and property sections of a visualization |
| Cdepth_flags_type | Relative depth flags type |
| Cvisualization_iterator_1_1 | A visualization iterator for coordinate and property section representations both having discretization equal to vertices |
| Cvisualization_iterator_1_3 | A visualization iterator for a coordinate section with discretization equal to vertices and property section with evaluation at elements and discretization at or above the elements |
| Cvisualization_iterator_4_2 | A visualization iterator for uniform coordinates and property section with discretization equal to vertices |
| Cvisualization_iterator_4_3 | A visualization iterator for uniform coordinates and property section with evaluation at elements and discretization at or above the elements |
| Cvtk_abstract_grid_builder | Abstract class for creating a vtkUnstructuredGrid from sheaf field objects |
| Cvtk_poly_data_builder | Creates a vtkPolyData from sheaf field objects |
| Cvtk_unstructured_grid_builder | Creates a vtkUnstructuredGrid from sheaf field objects |
| Chash< sheaf::scoped_index > | Specialization of hash function to scoped_index |
| Chash_cstr | |
| Cjvm_launcher | Launcher for the Java virtual machine |
| Ckey_test |
1.8.13