Class representing axis-aligned bounding box. More...

Namespaces
	_bvh

	_element_tree

	common_tree

	Element

	element_utility

	ElemUtil

	GeomUtil

	Matrix

	point_locator

	SysUtil

Classes
struct	NodeDistance

struct	NodeSeg

struct	SimpleStat

class	AEntityFactory
	class AEntityFactory More...

class	AffineXform
	Define an affine transformation. More...

class	AxisBox
	Class representing axis-aligned bounding box. More...

class	BitPage
	bit tag data More...

class	BitTag
	data for a single bit tag More...

class	BoxPlaneIter

class	BSPTreePlaneIter

class	FILEDebugStream

class	CxxDebugStream

class	DebugOutput
	Utility class for printing debug output. More...

class	DebugOutputStream

class	DenseTag
	Dense storage of fixed-length tag data. More...

class	ElementSequence

class	EntitySequence

class	FILEErrorStream

class	CxxErrorStream

class	ErrorOutput
	Utility class for printing error output. More...

class	ErrorOutputStream

class	ComponentFactory

class	FindVolumeIntRegCtxt

class	GQT_IntRegCtxt
	An implementation of an Intersection Registration Context for use GQT ray-firing. More...

struct	angleAndIndex

class	DamselUtil

class	ExoIIUtil

class	FileTokenizer
	Parse a file as space-separated tokens. More...

struct	GmshElemType
	Structure defining relation between MOAB and VTK element types. VTK had different types for quadratic than linear elements, so a tuple of the MOAB type and number of elements maps to a VTK type. More...

class	GmshUtil
	General data about GMsh files for use by read and write code. More...

class	IODebugTrack
	Tool for debugging binary IO. More...

class	ExoIIInterface

struct	VtkElemType
	Structure defining relation between MOAB and VTK element types. VTK had different types for quadratic than linear elements, so a tuple of the MOAB type and number of elements maps to a VTK type. More...

class	VtkUtil
	General data about VTK files for use by read and write code. More...

class	NCHelper
	Helper class to isolate reading of several different nc file formats. More...

class	ScdNCHelper
	Child helper class for scd mesh, e.g. CAM_EL or CAM_FV. More...

class	UcdNCHelper
	Child helper class for ucd mesh, e.g. CAM_SE (HOMME) or MPAS. More...

class	NCHelperDomain
	Child helper class for Domain grid. More...

class	NCHelperESMF

class	NCHelperEuler
	Child helper class for Eulerian Spectral grid (CAM_EUL) More...

class	NCHelperFV
	Child helper class for Finite Volume grid (CAM_FV) More...

class	NCHelperGCRM
	Child helper class for GCRM grid. More...

class	NCHelperHOMME
	Child helper class for HOMME grid (CAM_SE) More...

class	NCHelperMPAS
	Child helper class for MPAS grid. More...

class	NCHelperScrip

class	NCWriteEuler

class	NCWriteFV

class	NCWriteGCRM

class	NCWriteHelper

class	ScdNCWriteHelper
	Child helper class for scd mesh, e.g. CAM_EL or CAM_FV. More...

class	UcdNCWriteHelper
	Child helper class for ucd mesh, e.g. CAM_SE (HOMME) or MPAS. More...

class	NCWriteHOMME

class	NCWriteMPAS

class	ReadABAQUS

class	ReadCCMIO

class	ReadCGM

class	ReadCGNS
	Export CGNS files. More...

class	ReadDamsel

class	ReadGmsh
	Gmsh (http://www.geuz.org/gmsh) file reader. More...

class	CheckOpenReadHDF5Handles

struct	SetContOffComp

class	ReadHDF5
	Read mesh from MOAB HDF5 (.h5m) file. More...

class	ReadHDF5Dataset
	Utility used for reading portions of an HDF5 dataset. More...

class	ReadHDF5VarLen
	Read variable-length data from 1-D array dataset. More...

class	ReadIDEAS

class	ReadMCNP5

class	ReadNASTRAN

class	ReadNC
	Output Exodus File for VERDE. More...

struct	ReadBlockData

struct	ReadFaceBlockData

class	ReadNCDF
	Output Exodus File for VERDE. More...

class	ReadOBJ

class	ReadRTT

class	ReadSmf
	Read SMF (Simple Model Format) files. More...

class	ReadSms

struct	BinaryHeader

struct	BinaryTri

class	ReadSTL
	ASCII and Binary Stereo Lithography File readers. More...

class	ReadTemplate
	Template for implementing new file readers in MOAB This class is a template for writing new file readers in MOAB. This shows how to efficiently create vertices and elements using the ReadUtilIface class, and to translate indices in connectivity lists into vertex handles created during the read. More...

class	ReadTetGen

class	ReadVtk

struct	SMF_ivars

class	SMF_State

class	Tqdcfr

class	WriteAns

class	WriteCCMIO

class	WriteCGNS
	Export CGNS files. More...

class	WriteDamsel

struct	ElemInfo

class	WriteGmsh
	Export Gmsh files. More...

class	WriteGMV
	Output Exodus File for VERDE. More...

class	CheckOpenWriteHDF5Handles

class	WriteHDF5
	Write mesh database to MOAB's native HDF5-based file format. More...

class	WriteNC
	Export NC files. More...

struct	MaterialSetData
	struct used to hold data for each block to be output in Exodus; used by initialize_exodus_file to initialize the file header for increased speed More...

struct	DirichletSetData
	struct used to hold data for each nodeset to be output in Exodus; used by initialize_exodus_file to initialize the file header for increased speed More...

struct	NeumannSetData
	struct used to hold data for each sideset to be output in Exodus; used by initialize_exodus_file to initialize the file header for increased speed More...

class	WriteNCDF
	Output Exodus File for VERDE. More...

class	WriteSLAC

class	WriteSmf

struct	BinTri

class	WriteSTL
	ASCII and Binary Stereo Lithography File writers. More...

class	WriteTemplate

class	WriteVtk

struct	handle_id

class	range_tool
	Methods to insert/remove range-based data from contents list. Templatized to operate on both Range and set-based MeshSets. More...

class	MeshSetRComp

class	MeshSet
	Class to implement entity set functionality. More...

class	MeshSetSequence

class	MeshTag
	Tag with only a global/mesh value. More...

class	AdaptiveKDTree
	Adaptive KD tree, for sorting and searching entities spatially. More...

class	AdaptiveKDTreeIter
	Iterate over leaves of an adaptive kD-tree. More...

class	BoundBox

class	BSPTree
	BSP tree, for sorting and searching entities spatially. More...

class	BSPTreeIter
	Iterate over leaves of a BSPTree. More...

class	BSPTreeBoxIter
	Iterate over leaves of a BSPTree. More...

class	BSPTreePoly
	Convex polyhedron. More...

class	BVHTree
	Bounding Volume Hierarchy (sorta like a tree), for sorting and searching entities spatially. More...

class	CartVect
	Cartesian Vector. More...

class	CN
	Canonical numbering data and functions This class represents canonical ordering of finite-element meshes. Elements in the finite element "zoo" are represented. Canonical numbering denotes the vertex, edge, and face numbers making up each kind of element, and the vertex numbers defining those entities. Functions for evaluating adjacencies and other things based on vertex numbering are also provided. By default, this class defines a zero-based numbering system. For a complete description of this class, see the document "MOAB Canonical Numbering Conventions", Timothy J. Tautges, Sandia National Laboratories Report #SAND2004-xxxx. More...

class	Core
	Implementation of MOAB Interface Implementation of the MOAB Interface class. You shouldn't call functions directly on an object of type Core (use Interface instead), unless you really have to access non-API functionality. More...

class	CpuTimer

class	DGMSolver

class	HiReconstruction

class	DualTool
	Tools for constructing and working with mesh duals (both tet- and hex-based, though some functions may not make sense for tet duals) More...

class	EvalSet

class	ElemEvaluator
	Class facilitating local discretization-related functionsThis class implements discretization-related functionality operating on data in MOAB. A member of this class caches certain data about the element it's currently operating on, but is not meant to be instantiated one-per-element, but rather one-per-search (or other operation on a collection of elements). More...

class	Error

class	FBEngine

class	FileOptions
	Parse options string passed to file IO routines. More...

class	GeomQueryTool
	Tool for querying different aspects of geometric topology sets in MOAB. More...

class	GeomTopoTool
	Tool for interpreting geometric topology sets in MOAB database Tool for interpreting geometric topology sets in MOAB database; see MOAB metadata_info document for information on how geometric topology sets are read and represented. More...

class	HalfFacetRep

class	HigherOrderFactory
	Functions for converting to/from higher-order elements. More...

class	HomCoord
	Homogeneous coordinate vector. More...

class	HomXform
	Homogeneous coordinate transformation matrix. More...

class	Interface
	Main interface class to MOAB. More...

class	type_equals
	predicate for STL algorithms. Returns true if the entity handle is of the specified type. For example, to remove all the tris out of a list of 2D entities retrieved using get_adjacencies you could do std::remove_if(list.begin(), list.end(), type_equals(gMB, MBTRI)); More...

class	type_not_equals
	predicate for STL algorithms. Returns true if the entity handle is not of the specified type. For example, to remove all but the tris out of a list of 2D entities retrieved using get_adjacencies you could do std::remove_if(list.begin(), list.end(), type_not_equals(gMB, MBTRI)); More...

class	Intx2Mesh

class	Intx2MeshInPlane

class	Intx2MeshOnSphere

class	IntxRllCssphere

class	IntxUtils

class	IntxAreaUtils

class	LloydSmoother

class	LinearHex

class	LinearQuad

class	LinearTet

class	LinearTri

class	QuadraticHex

class	SpectralHex

class	SpectralQuad

class	Matrix3

class	MergeMesh

class	MeshGeneration

class	MeshTopoUtil
	MeshTopoUtil contains general mesh utility functions. More...

class	NestedRefine

class	OrientedBox
	Oriented bounding box. More...

class	OrientedBoxTreeTool
	Class for constructing and querying Hierarchical Oriented Bounding Box trees. More...

class	Point_search

class	Bvh_tree

class	Element_tree

struct	range_iter_tag

struct	range_base_iter

class	Range
	the class Range More...

class	range_inserter
	Use as you would an STL back_inserter. More...

class	RangeMap
	Map ranges of values. More...

class	ReaderIface
	Interface for mesh reader implementations. More...

class	ReaderWriterSet
	Maintain list of readers and writers. More...

class	ReadUtilIface
	Interface implemented in MOAB which provides memory for mesh reading utilities. More...

class	Remapper

class	TempestOnlineMap
	An offline map between two Meshes. More...

class	TempestRemapper

class	ReorderTool

class	ScdParData
	struct for keeping parallel data in one place More...

class	ScdInterface
	A structured mesh interface for MOAB-based data. More...

class	ScdBox

class	SetIterator

class	RangeSetIterator

class	VectorSetIterator

class	Skinner
	Class for constructing and querying skin of a mesh Class for constructing and querying skin of a mesh, defined as the outside lower-dimensional boundary of a mesh or a given set of entities. This class provides options for finding the forward- and reverse-oriented members of the skin. Several methods are available for computing the skin, e.g. using geometric topology sets, vertex-entity adjacencies, or directly from (n-1)-dimensional entities. More...

class	SpatialLocator
	Tool to facilitate spatial location of a point in a mesh. More...

class	SpatialLocatorTimes
	Statistics for spatial location. More...

class	SpectralMeshTool
	Class with convenience functions for handling spectral mesh Class with convenience functions for handling spectral meshes. See description of spectral mesh handling in doc/metadata_info.doc and in the MOAB user's guide. More...

class	Tree
	Parent class of various tree types in MOAB. More...

class	TreeStats
	Traversal statistics accumulating and reporting. More...

class	TupleList

struct	MBuuid
	struct that handles universally unique id's for the Mesh Database More...

class	UnknownInterface
	base class for all interface classes More...

class	Util
	Utility functions for computational geometry and mathematical calculations. More...

class	VerdictWrapper

class	WriterIface
	Interface for mesh writer implementations. More...

class	WriteUtilIface
	Interface implemented in MOAB which provides memory for mesh reading utilities. More...

struct	Data

struct	OBBTreeSITFrame

class	RayIntersector

class	RayIntersectSets

struct	OBBTreeCPFrame

class	TreeLayoutPrinter

class	TreeNodePrinter

class	StatData

class	gs_data

class	ParallelComm
	Parallel communications in MOAB. More...

class	ParallelData
	Parallel data in MOAB. More...

class	ParallelMergeMesh

class	ParCommGraph

class	ProcConfig
	Multi-CPU information for parallel MOAB. More...

struct	set_tuple

struct	ProcList

class	ReadParallel

class	SharedSetData
	ParallelComm data about shared entity sets. More...

class	TagNameCompare

struct	serial_tag_data

struct	DatasetVals

struct	elemtype

class	WriteHDF5Parallel
	Write MOAB HDF5 file in parallel. More...

class	PolyElementSeq

class	RangeSeqIntersectIter
	Iterate over the blocks of EntityHandles in an Range that are in the same EntitySequence. More...

class	ReadUtil

struct	CompSortedVect

class	ScdElementData

class	ScdVertexData

class	SequenceData

class	SequenceManager

class	AdjSides

class	SmoothCurve

class	SmoothFace
	Implement CAMAL geometry callbacks using smooth iMesh. More...

class	SparseTagDataAllocator
	allocator for tag data More...

class	SparseTag
	Sparse tag data. More...

class	StructuredElementSeq

class	SweptElementData

class	SweptElementSeq

class	SweptVertexData

class	TagBytesEqual

class	TagBytesLess

class	TagVarBytesEqual

class	TagVarBytesLess

class	TagTypeEqual

class	TagTypeLess

class	TagOneTypeEqual

class	TagOneTypeLess

class	TagVarTypeEqual

class	TagVarTypeLess

class	ByteArrayIterator

class	InsertCount

class	TagInfo

struct	range_data

class	TypeSequenceManager
	Maintain data structures organizing EntitySequence instances. More...

class	UnstructuredElemSeq

class	VarLenDenseTag
	Dense storage of variable-length tag data. More...

class	VarLenSparseTag
	Sparse tag variable-length data. More...

class	VarLenTagData

class	VarLenTag
	Class for storing variable-length tag data. More...

class	VertexSequence

class	WriteUtil

class	Coupler
	This class couples data between meshes. More...

class	DataCoupler
	This class couples data between meshes. More...

Typedefs
typedef std::vector< EntityHandle >	AdjacencyVector

typedef herr_t(*	HDF5_Error_Func_Type) (void *)

typedef std::pair< EntityHandle, EntityHandle >	MeshSetRange

typedef std::pair< EntityType, EntityType >	DimensionPair

typedef ErrorCode(*	EvalFcn) (const double params, const double field, const int ndim, const int num_tuples, double work, double result)

typedef ErrorCode(*	JacobianFcn) (const double params, const double verts, const int nverts, const int ndim, double work, double result)

typedef ErrorCode(*	IntegrateFcn) (const double field, const double verts, const int nverts, const int ndim, const int num_tuples, double work, double result)

typedef ErrorCode(*	InitFcn) (const double verts, const int nverts, double &work)

typedef int(*	InsideFcn) (const double *verts, const int ndims, const double tol)

typedef ErrorCode(*	ReverseEvalFcn) (EvalFcn eval, JacobianFcn jacob, InsideFcn ins, const double posn, const double verts, const int nverts, const int ndim, const double iter_tol, const double inside_tol, double work, double params, int *is_inside)

typedef ErrorCode(*	NormalFcn) (const int ientDim, const int facet, const int nverts, const double *verts, double normal[3])

typedef unsigned long	EntityHandle

typedef long	EntityID

typedef std::vector< EntityHandle >	HandleVec

typedef EntityHandle	HFacet
	HalfFacetRep class implements the Array-Based Half-Facet(AHF) Mesh data structure on top of MOAB. \ It is based on a generalized notion of a half-facet derived from that a half-edge/half-face data structure for 2D/3D. \ The core construct of AHF are its two maps: sibling-half-facets(SIBHFS) and vertex-to-half-facet(V2HF) \ 1. SIBHFS: Maps every half-facet in the mesh to its sibling half-facets, \ 2. V2HF: Maps each vertex to an incident half-facet \ Using these two maps, a range of adjacency queries is performed. The maps are stored in dense tags over entities and vertices. \ \ Adjacency functions: \ 1. upward-incidence queries: vertex -> edge, edge -> faces, edge -> cells, face ->cells \ 2. neighborhood (same-dimensional) adjacency queries: edge -> edges, face -> faces, cell -> cells, etc. \ 3. downward adjacency queries: face -> edges, cell -> edges, etc. \ \ Mesh types supported: \ 1D(edges), 2D(triangles, quads), 3D(tet, pyramid, prism, hex), Mixed dimensional meshes \ \ CURRENTLY NOT SUPPORTED: \ 1. Meshes with mixed entity types of same dimension. Ex. a volume mesh with both tets and prisms. \ 2. create_if_missing = true \ 3. Modified meshes . More...

typedef RangeMap< EntityHandle, EntityHandle, 0 >	HandleMap

typedef TagBytesEqual	TagIntsEqual

typedef TagVarBytesEqual	TagVarIntsEqual

typedef TagTypeLess< int >	TagIntsLess

typedef TagVarTypeLess< int >	TagVarIntsLess

typedef TagOneTypeEqual< int >	TagOneIntEqual

typedef TagOneTypeLess< int >	TagOneIntLess

typedef TagBytesEqual	TagHandlesEqual

typedef TagVarBytesEqual	TagVarHandlesEqual

typedef TagTypeLess< EntityHandle >	TagHandlesLess

typedef TagVarTypeLess< EntityHandle >	TagVarHandlesLess

typedef TagOneTypeEqual< EntityHandle >	TagOneHandleEqual

typedef TagOneTypeLess< EntityHandle >	TagOneHandleLess

typedef TagTypeEqual< double >	TagDoublesEqual

typedef TagVarTypeEqual< double >	TagVarDoublesEqual

typedef TagTypeLess< double >	TagDoublesLess

typedef TagVarTypeLess< double >	TagVarDoublesLess

typedef TagOneTypeEqual< double >	TagOneDoubleEqual

typedef TagOneTypeLess< double >	TagOneDoubleLess

Enumerations
enum	ExoIIElementType { EXOII_SPHERE = 0 , EXOII_SPRING , EXOII_BAR , EXOII_BAR2 , EXOII_BAR3 , EXOII_BEAM , EXOII_BEAM2 , EXOII_BEAM3 , EXOII_TRUSS , EXOII_TRUSS2 , EXOII_TRUSS3 , EXOII_TRI , EXOII_TRI3 , EXO_SHELL3 , EXOII_TRI6 , EXOII_TRI7 , EXOII_QUAD , EXOII_QUAD4 , EXOII_QUAD5 , EXOII_QUAD8 , EXOII_QUAD9 , EXOII_SHELL , EXOII_SHELL4 , EXOII_SHELL5 , EXOII_SHELL8 , EXOII_SHELL9 , EXOII_TETRA , EXOII_TETRA4 , EXOII_TET4 , EXOII_TETRA8 , EXOII_TETRA10 , EXOII_TETRA14 , EXOII_PYRAMID , EXOII_PYRAMID5 , EXOII_PYRAMID10 , EXOII_PYRAMID13 , EXOII_PYRAMID18 , EXOII_WEDGE , EXOII_KNIFE , EXOII_HEX , EXOII_HEX8 , EXOII_HEX9 , EXOII_HEX20 , EXOII_HEX27 , EXOII_HEXSHELL , EXOII_POLYGON , EXOII_POLYHEDRON , EXOII_MAX_ELEM_TYPE }

enum	abaqus_line_types { abq_undefined_line = 0 , abq_blank_line , abq_comment_line , abq_keyword_line , abq_data_line , abq_eof }

enum	abaqus_keyword_type { abq_undefined = 0 , abq_unsupported , abq_ambiguous , abq_heading , abq_part , abq_end_part , abq_assembly , abq_end_assembly , abq_node , abq_element , abq_nset , abq_elset , abq_instance , abq_end_instance , abq_solid_section }

enum	abaqus_part_params { abq_part_undefined = 0 , abq_part_ambiguous , abq_part_name }

enum	abaqus_instance_params { abq_instance_undefined = 0 , abq_instance_ambiguous , abq_instance_name , abq_instance_part }

enum	abaqus_assembly_params { abq_assembly_undefined = 0 , abq_assembly_ambiguous , abq_assembly_name }

enum	abaqus_node_params { abq_node_undefined = 0 , abq_node_ambiguous , abq_node_nset , abq_node_system }

enum	abaqus_element_params { abq_element_undefined = 0 , abq_element_ambiguous , abq_element_elset , abq_element_type }

enum	abaqus_element_type { abq_eletype_unsupported = 0 , abq_eletype_dc3d8 , abq_eletype_c3d8r , abq_eletype_dcc3d8 , abq_eletype_c3d4 , abq_eletype_dc3d4 , abq_eletype_ds4 }

enum	abaqus_nset_params { abq_nset_undefined = 0 , abq_nset_ambiguous , abq_nset_nset , abq_nset_elset , abq_nset_generate , abq_nset_instance }

enum	abaqus_elset_params { abq_elset_undefined = 0 , abq_elset_ambiguous , abq_elset_elset , abq_elset_generate , abq_elset_instance }

enum	abaqus_solid_section_params { abq_solid_section_undefined = 0 , abq_solid_section_ambiguous , abq_solid_section_elset , abq_solid_section_matname }

enum	keyword_type { obj_undefined = 0 , object_start , group_start , face_start , vertex_start , valid_unsupported }

enum	{ MAX_SUB_ENTITIES = 12 , MAX_SUB_ENTITY_VERTICES = 9 }

enum	GEOMTYPE { HISURFACE , HI3DCURVE , HI2DCURVE }

enum	ErrorType { MB_ERROR_TYPE_NEW_GLOBAL = 0 , MB_ERROR_TYPE_NEW_LOCAL = 1 , MB_ERROR_TYPE_EXISTING = 2 }
	ErrorType - passed to the error handling routines indicating whether this is a new error (globally fatal or per-processor relevant) to be created, or an existing one to be handled. More...

enum	MESHTYPE { CURVE = 0 , SURFACE , SURFACE_MIXED , VOLUME , VOLUME_MIXED_1 , VOLUME_MIXED_2 , VOLUME_MIXED }
	ENUM for the type of input mesh. More...

enum	{ MAX_VERTICES = 8 , MAX_EDGES = 12 , MAX_FACES = 6 , MAX_VERTS_HF = 4 , MAX_INCIDENT_HF = 4 }

enum	QualityType { MB_UNDEFINED_QUALITY = -1 , MB_EDGE_RATIO = 0 , MB_MAX_EDGE_RATIO , MB_SKEW , MB_TAPER , MB_VOLUME , MB_STRETCH , MB_DIAGONAL , MB_DIMENSION , MB_ODDY , MB_MED_ASPECT_FROBENIUS , MB_MAX_ASPECT_FROBENIUS , MB_CONDITION , MB_JACOBIAN , MB_SCALED_JACOBIAN , MB_SHEAR , MB_SHAPE , MB_RELATIVE_SIZE_SQUARED , MB_SHAPE_AND_SIZE , MB_SHEAR_AND_SIZE , MB_DISTORTION , MB_LENGTH , MB_RADIUS_RATIO , MB_ASPECT_BETA , MB_ASPECT_RATIO , MB_ASPECT_GAMMA , MB_MINIMUM_ANGLE , MB_COLLAPSE_RATIO , MB_WARPAGE , MB_AREA , MB_MAXIMUM_ANGLE , MB_QUALITY_COUNT }

enum	MBMessageTag { MB_MESG_ANY = MPI_ANY_TAG , MB_MESG_ENTS_ACK , MB_MESG_ENTS_SIZE , MB_MESG_ENTS_LARGE , MB_MESG_REMOTEH_ACK , MB_MESG_REMOTEH_SIZE , MB_MESG_REMOTEH_LARGE , MB_MESG_TAGS_ACK , MB_MESG_TAGS_SIZE , MB_MESG_TAGS_LARGE }

Functions
static ErrorCode	closest_to_triangles (Interface *moab, const Range &tris, const CartVect &from, double &shortest_dist_sqr, CartVect &closest_pt, EntityHandle &closest_tri)

static ErrorCode	closest_to_triangles (Interface *moab, EntityHandle set_handle, const CartVect &from, double &shortest_dist_sqr, CartVect &closest_pt, EntityHandle &closest_tri)

static std::string	mem_to_string (unsigned long mem)

AffineXform	operator* (const AffineXform &A, const AffineXform &B)

AxisBox	operator& (const AxisBox &a, const AxisBox &b)

AxisBox	operator\| (const AxisBox &a, const AxisBox &b)

bool	operator\|\| (const AxisBox &a, const AxisBox &b)

static void	corners_from_box (const double box_min[3], const double box_max[3], double corners[8][3])

static bool	point_in_box (const double corners[8][3], const double point[3])

static void	copy_coords (const double src[3], double dest[3])

static void	plane_cut_edge (double old_coords_out[3], const double keep_end_coords[3], double cut_end_coords[3], const BSPTree::Plane &plane)
	Clip an edge using a plane. More...

static ErrorCode	plane_cut_box (double cut_face_out[4][3], double corners_inout[8][3], const BSPTree::Plane &plane)

static ErrorCode	plane_uncut_box (const double cut_face_in[4][3], double corners_inout[8][3], const BSPTree::Plane &plane)

static void	subtr (double result[3], const double a[3], const double b[3])

static void	sum (double result[3], const double a[3], const double b[3], const double c[3], const double d[3])

static void	cross (double result[3], const double a[3], const double b[3])

static double	dot (const double a[3], const double b[3])

template<typename PlaneIter >
static bool	ray_intersect_halfspaces (const CartVect &ray_pt, const CartVect &ray_dir, const PlaneIter &begin, const PlaneIter &end, double &t_enter, double &t_exit)

static BSPTreePoly::Edge *	split_edge (BSPTreePoly::Vertex &new_vtx, BSPTreePoly::Edge into_edge)

static BSPTreePoly::Face *	split_face (BSPTreePoly::EdgeUse start, BSPTreePoly::EdgeUse end)

std::ostream &	operator<< (std::ostream &s, const CartVect &v)

template<typename T >
static short int	side_number (const T parent_conn, const EntityType parent_type, const T child_conn, const int child_num_verts, const int child_dim, int &side_no, int &sense, int &offset)

template<typename T >
bool	connectivity_match (const T conn1_i, const T conn2_i, const int num_vertices, int &direct, int &offset)

template<typename T >
int	permute_this (EntityType t, const int dim, T *conn, const int indices_per_ent, const int num_entries)

template<typename T >
int	rev_permute_this (EntityType t, const int dim, T *conn, const int indices_per_ent, const int num_entries)

static const MeshSet *	get_mesh_set (const SequenceManager *sm, EntityHandle h)

static MeshSet *	get_mesh_set (SequenceManager *sm, EntityHandle h)

template<typename ITER >
static ErrorCode	get_adjacencies_union (Core *gMB, ITER begin, ITER end, int to_dimension, bool create_if_missing, Range &adj_entities)

template<typename ITER >
static ErrorCode	get_adjacencies_intersection (Core *mb, ITER begin, ITER end, const int to_dimension, const bool create_if_missing, std::vector< EntityHandle > &adj_entities)

template<typename ITER >
static ErrorCode	get_adjacencies_intersection (Core *mb, ITER begin, ITER end, const int to_dimension, const bool create_if_missing, Range &adj_entities)

static bool	is_zero_bytes (const void *mem, size_t size)

static void	print_range (char *buffer, unsigned long begin, unsigned long end)

static ErrorCode	not_found (const std::string &, EntityHandle)

static ErrorCode	ent_not_found (const std::string &, EntityHandle)

void	MBErrorHandler_Init ()
	Initialize MOAB error handler (e.g. create a utility object for printing error output) More...

void	MBErrorHandler_Finalize ()
	Finalize MOAB error handler (e.g. delete the utility object for printing error output) More...

bool	MBErrorHandler_Initialized ()
	Indicates whether MBErrorHandler_Init has been called. More...

void	MBErrorHandler_GetLastError (std::string &error)
	Get information about the last error. More...

void	MBTraceBackErrorHandler (int line, const char func, const char file, const char dir, const char err_msg, ErrorType err_type)

ErrorCode	MBError (int line, const char func, const char file, const char dir, ErrorCode err_code, const char err_msg, ErrorType err_type)
	Routine that is called to create a new error or handle an existing one. More...

MB_EXPORT const char *	MoabVersion ()

MB_EXPORT void	GetInterface (MBuuid &interface_requested, UnknownInterface **iface)

MB_EXPORT void	DeInitialize ()

MB_EXPORT void	ReleaseInterface (UnknownInterface *iface)

bool	intersect_segment_and_plane_slice (CartVect &from, CartVect &to, CartVect &p1, CartVect &p2, CartVect &, CartVect &normPlane, CartVect &intx_point, double &parPos)

ErrorCode	area_coordinates (Interface mbi, EntityHandle tri, CartVect &pnt, double area_coord, EntityHandle &boundary_handle)

static bool	strempty (const char *s)

EntityHandle	CREATE_HALFFACET (const unsigned lid, const EntityID id)

EntityID	FID_FROM_HALFFACET (HFacet handle)

int	LID_FROM_HALFFACET (HFacet handle)

EntityHandle	CREATE_HANDLE (const unsigned type, const EntityID id, int &err)
	Given a type and an id create a handle. More...

EntityHandle	CREATE_HANDLE (const unsigned type, const EntityID id)

EntityHandle	FIRST_HANDLE (unsigned type)

EntityHandle	LAST_HANDLE (unsigned type)

EntityID	ID_FROM_HANDLE (EntityHandle handle)
	Get the entity id out of the handle. More...

EntityType	TYPE_FROM_HANDLE (EntityHandle handle)
	Get the type out of the handle. Can do a simple shift because handles are unsigned (therefore shifting fills with zero's) More...

bool	angleCompare (angleAndIndex lhs, angleAndIndex rhs)

static bool	verify (CartVect a, CartVect b, CartVect c, CartVect d, double x, double y, double z)

static ErrorCode	error (ErrorCode rval)

ExoIIElementType	operator++ (ExoIIElementType &type, int)
	postfix increment operator for EntityType More...

ExoIIElementType &	operator++ (ExoIIElementType &type)
	prefix increment operator for EntityType More...

bool	HDF5_can_append_hyperslabs ()

const bool	operator== (const damsel_err_t &lhs, const damsel_err_t &rhs)

static herr_t	handle_hdf5_error (void *data)

static void	copy_sorted_file_ids (const EntityHandle *sorted_ids, long num_ids, Range &results)

static void	intersect (const mhdf_EntDesc &group, const Range &range, Range &result)

static bool	set_map_intersect (bool ranged, const long *contents, int content_len, const RangeMap< long, EntityHandle > &id_map)

static Range::iterator	copy_set_contents (Range::iterator hint, int ranged, EntityHandle *contents, long length, Range &results)

static std::pair< int, int >	allocate_mpe_state (const char , const char )

static void	INT_IO_ERROR (bool condition, unsigned line)

static void	swap8_voff (long *data)

static void	swap4_uint (unsigned int *data)

static hid_t	get_id_type ()

static ErrorCode	error (ErrorCode rval)

static herr_t	handle_hdf5_error (void *data)

template<class HandleRangeIter >
size_t	count_num_handles (HandleRangeIter iter, HandleRangeIter end)

template<class HandleRangeIter >
ErrorCode	range_to_id_list_templ (HandleRangeIter begin, HandleRangeIter end, const RangeMap< EntityHandle, WriteHDF5::wid_t > &idMap, WriteHDF5::wid_t *array)

template<class HandleRangeIter >
ErrorCode	range_to_blocked_list_templ (HandleRangeIter begin, HandleRangeIter end, const RangeMap< EntityHandle, WriteHDF5::wid_t > &idMap, std::vector< WriteHDF5::wid_t > &output_id_list, bool &ranged_list)

int	compare_handle_id (const void a, const void b)

static MeshSet::Count	insert_in_vector (const MeshSet::Count count, MeshSet::CompactList &list, const EntityHandle h, int &result)
	Insert into parent/child list. More...

static MeshSet::Count	remove_from_vector (const MeshSet::Count count, MeshSet::CompactList &list, const EntityHandle h, int &result)
	Remvoe from parent/child list. More...

static EntityHandle *	resize_compact_list (MeshSet::Count &count, MeshSet::CompactList &clist, size_t new_list_size)
	Resize MeshSet::CompactList. Returns pointer to storage. More...

static ErrorCode	vector_remove_range (MeshSet::Count &count, MeshSet::CompactList &clist, const Range &range, EntityHandle my_handle, AEntityFactory *adj)

static ErrorCode	vector_remove_ranges (MeshSet::Count &count, MeshSet::CompactList &clist, const EntityHandle pair_list, size_t num_pairs, EntityHandle my_handle, AEntityFactory adj)

static ErrorCode	vector_remove_vector (MeshSet::Count &count, MeshSet::CompactList &clist, const EntityHandle vect, size_t vect_size, EntityHandle my_handle, AEntityFactory adj)

static ErrorCode	vector_insert_vector (MeshSet::Count &count, MeshSet::CompactList &clist, const EntityHandle vect, size_t vect_size, EntityHandle my_handle, AEntityFactory adj)

static void	convert_to_ranges (const EntityHandle *vect_in, size_t vect_in_len, std::vector< EntityHandle > &vect_out)

MeshSet::hdl_iter::difference_type	operator- (const MeshSet::hdl_iter &a, const MeshSet::hdl_iter &b)

static ErrorCode	not_root_set (const std::string &, EntityHandle)

static bool	all_root_set (std::string name, const EntityHandle *array, size_t len)

static ErrorCode	not_found (const std::string &)

std::ostream &	operator<< (std::ostream &out, const BoundBox &box)

CartVect	operator+ (const CartVect &u, const CartVect &v)

CartVect	operator- (const CartVect &u, const CartVect &v)

CartVect	operator* (const CartVect &u, const CartVect &v)

double	operator% (const CartVect &u, const CartVect &v)
	Dot product. More...

double	angle (const CartVect &u, const CartVect &v)
	Interior angle between two vectors. More...

CartVect	operator- (const CartVect &v)

CartVect	operator+ (const CartVect &v, double s)

CartVect	operator- (const CartVect &v, double s)

CartVect	operator* (const CartVect &v, double s)

CartVect	operator/ (const CartVect &v, double s)

CartVect	operator+ (double s, const CartVect &v)

CartVect	operator- (double s, const CartVect &v)

CartVect	operator* (double s, const CartVect &v)

CartVect	unit (const CartVect &v)
	Get unit vector in same direction. More...

std::ostream &	operator<< (std::ostream &str, const HomCoord &hc)

template<typename Vector >
Matrix3	outer_product (const Vector &u, const Vector &v)

Matrix3	operator+ (const Matrix3 &a, const Matrix3 &b)

Matrix3	operator- (const Matrix3 &a, const Matrix3 &b)

Matrix3	operator* (const Matrix3 &a, const Matrix3 &b)

template<typename T >
std::vector< T >	operator* (const Matrix3 &m, const std::vector< T > &v)

template<typename T >
std::vector< T >	operator* (const std::vector< T > &v, const Matrix3 &m)

CartVect	operator* (const Matrix3 &m, const CartVect &v)

CartVect	operator* (const CartVect &v, const Matrix3 &m)

std::ostream &	operator<< (std::ostream &, const OrientedBox &)

Range	intersect (const Range &, const Range &)
	intersect two ranges, placing the results in the return range More...

Range	subtract (const Range &from, const Range &)
	subtract range2 from this, placing the results in the return range More...

Range	unite (const Range &r1, const Range &r2)
	unite two ranges, placing the results in the return range More...

Range::const_iterator	operator+ (const Range::const_iterator &it, EntityID step)

Range::const_iterator	operator+ (EntityID step, const Range::const_iterator &it)

Range::const_iterator	operator- (const Range::const_iterator &it, EntityID step)

Range::const_iterator	operator- (EntityID step, const Range::const_iterator &it)

EntityID	operator- (const Range::const_iterator &it1, const Range::const_iterator &it2)

std::ostream &	operator<< (std::ostream &s, const Range &r)

bool	operator== (const Range &r1, const Range &r2)

bool	operator!= (const Range &r1, const Range &r2)

std::ostream &	operator<< (std::ostream &str, const ScdParData &pd)

void	fail (const char *fmt,...)

std::string	QualityType_ToString (QualityType qtype)

static double	point_perp (const CartVect &p, const CartVect &b, const CartVect &m)
	Find closest point on line. More...

static ErrorCode	box_from_axes (OrientedBox &result, Interface *instance, const Range &points)
	Common code for box calculation. More...

bool	check_ray_limits (const double normal_par_pos, const double normal_par_dir, const double half_extent, const double nonneg_ray_len, const double neg_ray_len)

static ErrorCode	split_box (Interface *instance, const OrientedBox &box, int axis, const Range &entities, Range &left_list, Range &right_list)
	Split triangles by which side of a plane they are on. More...

static ErrorCode	split_sets (Interface *, const OrientedBox &box, int axis, const std::list< OrientedBoxTreeTool::SetData > &sets, std::list< OrientedBoxTreeTool::SetData > &left, std::list< OrientedBoxTreeTool::SetData > &right)

static int	measure (const CartVect &v, double &result)

static double	std_dev (double sqr, double sum, double count)

static void	local_condense (realType u, int op, const sint cm)

static void	local_uncondense (realType u, const sint cm)

static void	local_condense_vec (realType u, uint n, int op, const sint cm)

static void	local_uncondense_vec (realType u, uint n, const sint cm)

template<typename T >
static void	UNPACK (unsigned char &buff, T val, size_t count)

template<typename T >
static void	PACK (unsigned char &buff, const T val, size_t count)

static void	PACK_INTS (unsigned char &buff, const int int_val, size_t num)

static void	PACK_INT (unsigned char *&buff, int int_val)

static void	PACK_DBLS (unsigned char &buff, const double dbl_val, size_t num)

static void	PACK_EH (unsigned char &buff, const EntityHandle eh_val, size_t num)

static void	PACK_VOID (unsigned char &buff, const void val, size_t num)

static void	PACK_BYTES (unsigned char &buff, const void val, int num)

static void	PACK_RANGE (unsigned char *&buff, const Range &rng)

static void	UNPACK_INTS (unsigned char &buff, int int_val, size_t num)

static void	UNPACK_INT (unsigned char *&buff, int &int_val)

static void	UNPACK_DBLS (unsigned char &buff, double dbl_val, size_t num)

static void	UNPACK_DBL (unsigned char *&buff, double &dbl_val)

static void	UNPACK_EH (unsigned char &buff, EntityHandle eh_val, size_t num)

static void	UNPACK_VOID (unsigned char &buff, void val, size_t num)

static void	UNPACK_TYPE (unsigned char *&buff, EntityType &type)

static void	UNPACK_RANGE (unsigned char *&buff, Range &rng)

static size_t	RANGE_SIZE (const Range &rng)

void	print_buff (unsigned char *ch, int size)

template<class T >
T	LAND (const T &arg1, const T &arg2)

template<class T >
T	LOR (const T &arg1, const T &arg2)

template<class T >
T	LXOR (const T &arg1, const T &arg2)

template<class T >
T	MAX (const T &arg1, const T &arg2)

template<class T >
T	MIN (const T &arg1, const T &arg2)

template<class T >
T	ADD (const T &arg1, const T &arg2)

template<class T >
T	MULT (const T &arg1, const T &arg2)

static size_t	choose_owner_idx (const std::vector< unsigned > &proc_list)

bool	is_sorted_unique (std::vector< unsigned > &v)

static bool	operator< (const ProcList &a, const ProcList &b)

	STATIC_ASSERT (sizeof(unsigned long) >=sizeof(EntityHandle))

static ErrorCode	error (ErrorCode rval)

const char *	mpi_err_str (int errorcode)

template<typename T >
void	VALGRIND_MAKE_VEC_UNDEFINED (std::vector< T > &)

static int	my_Gatherv (void *sendbuf, int sendcount, MPI_Datatype sendtype, std::vector< unsigned char > &recvbuf, std::vector< int > &recvcounts, int root, MPI_Comm comm)

static void	print_type_sets (Interface iFace, DebugOutput str, Range &sets)

static void	set_bit (int position, unsigned char *bytes)

static bool	get_bit (int position, const unsigned char *bytes)

	STATIC_ASSERT ((sizeof(DatasetVals)==3 *sizeof(long)))

template<typename TYPE >
static void	convert_to_ranged_ids (const TYPE *buffer, size_t len, std::vector< WriteHDF5::wid_t > &result)

static void	merge_ranged_ids (const unsigned long *range_list, size_t len, std::vector< WriteHDF5::wid_t > &result)

static void	merge_vector_ids (const unsigned long *list, size_t len, std::vector< WriteHDF5::wid_t > &result)

static ErrorCode	check_int_tag (Interface *mb, Tag tag)

bool	IntPairComparator (const std::pair< int, int > &a, const std::pair< int, int > &b)

bool	operator< (Node const &lhs, Node const &rhs)

static ErrorCode	error (ErrorCode val)

static ErrorCode	check_tag_type (Interface *moab, Tag tag, DataType exp_type, int exp_size)

std::ostream &	operator<< (std::ostream &s, const TypeSequenceManager &seq_man)

std::ostream &	operator<< (std::ostream &s, const SequenceManager &seq_man)

void	print_sequences (const SequenceManager &seqman)

void	print_sequences (const TypeSequenceManager &seqman)

bool	within_tolerance (CartVect &p1, CartVect &p2, const double &tolerance)

int	numAdjTriInSet (Interface *mb, EntityHandle startEdge, EntityHandle set)

template<class Container >
static void	get_tagged (const SparseTag::MapType &mData, EntityType type, Container &output_range)

template<class Container >
static void	get_tagged (const SparseTag::MapType &mData, Range::const_iterator begin, Range::const_iterator end, Container &output_range)

template<class Container >
static void	get_tagged (const SparseTag::MapType &mData, Container &entities, EntityType type, const Range *intersect)

template<class Functor , class IteratorType >
static void	find_tag_values (Functor compare, IteratorType begin, IteratorType end, Range &results)

template<class Functor , class IteratorType >
static void	find_tag_values (Functor compare, IteratorType begin, IteratorType end, std::vector< EntityHandle > &results)

template<class Functor , class TagMap >
static void	find_map_values (Functor compare, Range::const_iterator lower, Range::const_iterator upper, const TagMap &tag_map, Range &results)

template<class IteratorType , class ContainerType >
static void	find_tag_values_equal (const TagInfo &tag_info, const void *value, int size, IteratorType begin, IteratorType end, ContainerType &results)

template<class IteratorType , class ContainerType >
static void	find_tag_varlen_values_equal (const TagInfo &tag_info, const void *value, int size, IteratorType begin, IteratorType end, ContainerType &results)

template<class TagMap >
static void	find_map_values_equal (const TagInfo &tag_info, const void *value, int size, Range::const_iterator begin, Range::const_iterator end, const TagMap &tag_map, Range &results)

template<class TagMap >
static void	find_map_varlen_values_equal (const TagInfo &tag_info, const void *value, int size, Range::const_iterator begin, Range::const_iterator end, const TagMap &tag_map, Range &results)

static std::pair< EntityType, EntityType >	type_range (EntityType type)

static bool	check_range (const range_data &d, bool prefer_end, EntityHandle &result)

static ErrorCode	not_found (std::string, EntityHandle)

template<class Container >
static ErrorCode	get_tagged (const SequenceManager *seqman, int mySequenceArray, EntityType type, Container &entities)

template<class Container >
static ErrorCode	get_tagged (const SequenceManager *seqman, int mySequenceArray, Range::const_iterator begin, Range::const_iterator end, Container &entities)

template<class Container >
static ErrorCode	get_tagged (const SequenceManager seqman, int mySequenceArray, Container &entities, EntityType type, const Range intersect)

template<class Container >
static void	get_tagged (const VarLenSparseTag::MapType &mData, EntityType type, Container &output_range)

template<class Container >
static void	get_tagged (const VarLenSparseTag::MapType &mData, Range::const_iterator begin, Range::const_iterator end, Container &output_range)

template<class Container >
static void	get_tagged (const VarLenSparseTag::MapType &mData, Container &entities, EntityType type, const Range *intersect)

double	physField (double x, double y, double z, double factor)

void	putElementField (Interface mbi, const char tagname, double factor)

void	putSpectralElementField (Interface mbi, int dim, int np, const char tagname, double factor)

void	putVertexField (Interface mbi, const char tagname, double factor)

int	pack_tuples (TupleList tl, void *ptr)

void	unpack_tuples (void ptr, TupleList *tlp)

Variables
const char *const	AFFINE_XFORM_TAG_NAME = "AFFINE_TRANSFORM"

const char *const	AXIS_BOX_TAG_NAME = "AXIS_BOX"

static const int	box_face_corners [6][4]

bool	debug = false

bool	debug_ap = false

static ErrorOutput *	errorOutput = NULL

static std::string	lastError = "No error"

double	tolerance = 0.01

double	tolerance_segment = 0.01

const bool	Debug_surf_eval = false

bool	debug_splits = false

const char	DEFAULT_SEPARATOR = ';'

const char	GEOM_SENSE_2_TAG_NAME [] = "GEOM_SENSE_2"

const char	GEOM_SENSE_N_ENTS_TAG_NAME [] = "GEOM_SENSE_N_ENTS"

const char	GEOM_SENSE_N_SENSES_TAG_NAME [] = "GEOM_SENSE_N_SENSES"

const char	OBB_ROOT_TAG_NAME [] = "OBB_ROOT"

const char	OBB_GSET_TAG_NAME [] = "OBB_GSET"

const char	IMPLICIT_COMPLEMENT_NAME [] = "impl_complement"

int	dum [] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 }

const int	hex_27_node_order []

const int	tet_10_node_order [] = { 0, 1, 2, 3, 4, 5, 6, 7, 9, 8 }

const int	pri_15_node_order []

const int	pyr_13_node_order []

const int	MAX_NODES = 28

const int	mb_to_gmsh_type [][MAX_NODES]

const int	DEFAULT_MAX_EDGES_PER_CELL = 10

const double	pideg = acos( -1.0 ) / 180.0

const int	EDGES_PER_CELL = 6

static int const	kNValues = 10

static char const	kDefaultState [] = "default"

static char const	kUnitsName [] = "Units"

static int const	kVertOffset = 2

static int const	kCellInc = 4

const bool	DEFAULT_BLOCKED_COORDINATE_IO = false

const bool	DEFAULT_BCAST_SUMMARY = true

const bool	DEFAULT_BCAST_DUPLICATE_READS = true

const size_t	DEFAULT_HYPERSLAB_SELECTION_LIMIT = 200

const char *	object_start_token = "o"

const char *	group_start_token = "g"

const char *	vertex_start_token = "v"

const char *	face_start_token = "f"

const char *const	geom_name [] = { "Vertex\0", "Curve\0", "Surface\0", "Volume\0" }

const char	geom_category [][CATEGORY_TAG_SIZE] = { "Vertex\0", "Curve\0", "Surface\0", "Volume\0", "Group\0" }

const char *const	vtk_type_names []

static int	major = -1

static int	minor = -1

const int const const *const	cub_elem_order_map = exodus_elem_order_map

const char *const	BLOCK_NODESET_OFFSET_TAG_NAME = "BLOCK_NODESET_OFFSET"

const char *const	BLOCK_SIDESET_OFFSET_TAG_NAME = "BLOCK_SIDESET_OFFSET"

const unsigned	pixel [] = { 0, 1, 3, 2 }

const unsigned	voxel [] = { 0, 1, 3, 2, 4, 5, 7, 6 }

const unsigned	wedge []

const unsigned	qhex []

const int	mb_to_vtk_type [][3]

static char const	kStateName [] = "default"

const int	DEFAULT_PRECISION = 10

const int	TIME_STR_LEN = 11

const bool	DEFAULT_STRICT = true

const unsigned char	E = CN::MID_EDGE_BIT

const unsigned char	F = CN::MID_FACE_BIT

const unsigned char	R = CN::MID_REGION_BIT

const int	MAXSIZE = 200

static const MBuuid	IDD_MBCore = MBuuid( 0x8956e0a, 0xc300, 0x4005, 0xbd, 0xf6, 0xc3, 0x4e, 0xf7, 0x1f, 0x5a, 0x52 )

static const MBuuid	IDD_MBUnknown
	uuid for an unknown interface this can be used to either return a default interface or a NULL interface More...

const char	DEFAULT_TAG_NAME [] = "OBB"

const int	MAX_BCAST_SIZE = ( 1 << 28 )

std::vector< ParallelComm::Buffer * >	msgs

unsigned int	__PACK_num = 0

unsigned int	__UNPACK_num = 0

unsigned int	__PACK_count = 0

unsigned int	__UNPACK_count = 0

std::string	__PACK_string

std::string	__UNPACK_string

const char *	PARTITIONING_PCOMM_TAG_NAME = "__PRTN_PCOMM"

const unsigned	SSVB = 3

const int	UNUSED_SIZE = 0

bool	debug_surf_eval1 = false

static int	possibleQuality [MBMAXTYPE][MB_QUALITY_COUNT]

static int	numQualities [MBMAXTYPE]

static char const *	nameQuality [MB_QUALITY_COUNT]

static const char *	nameType [MBMAXTYPE]

Detailed Description

Class representing axis-aligned bounding box.

Stores contiguous or partially contiguous values in an optimized fashion. Partially contiguous accessing patterns is also optimized.

Shape function space for spectral hexahedron.

Shape function space for trilinear tetrahedron, obtained by a pushforward of the canonical linear (affine) functions.

Shape function space for trilinear quadahedron, obtained by a pushforward of the canonical linear (affine) functions.

Shape function space for trilinear hexahedron, obtained by a pushforward of the canonical linear (affine) functions.

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

Author: Jason Kraftcheck (kraft.nosp@m.che@.nosp@m.cae.w.nosp@m.isc..nosp@m.edu)

Date: August, 2006

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. Implementation of ABAQUS mesh hierarchy and meta-data on MOAB

This reader processes data written by the ABAQUS computer-aided engineering front-end. While that tool writes binary files in its own proprietary format, it also writes an ASCII input file that is the fundamental input to the ABAQUS solver itself. A published syntax for this format is available from Simulia.

This reader only supports a subset of the mesh syntax necessary to support a basic thermal analysis of solid systems.

An ABAQUS mesh makes use of the common paradigms of building a geometry as an "assembly" of "instances" of "parts".

A "part" is defined as a set of "nodes" and "elements" connecting those nodes. The nodes and elements can be arranged in "node sets" and "element sets" and specific "materials" can be assigned to "element sets" other features of parts are not currently used by applications and are not implemented.

Overview of supported structure

File: Heading Part Nodes Elements Node Sets Element Sets Solid Sections Assembly Instance Nodes Elements Node Sets Element Sets Solid Sections Node Sets

An "instance" is a full copy of a "part" with a linear geometric transformation. To create a full copy: • a duplicate set of nodes is created by copying the coordinates of the part nodes and applying a linear geometric transformation - the new coords are used to define the new nodes • a new node set is created for each node set in the part and the set of nodes among the duplicates are assigned to the new node set • a duplicate set of elements is defined by creating a new element with a connectivity made up of the duplicate nodes that correspond to the appropriate original element • a new element set is created for each element set in the part and the set of elements among the duplicates are assigned to the new element set; the corresponding material is also assigned go the new element sets

It is also possible for an "instance" to contain the complete definition of the mesh, copying nothing from the "part" (the "part" may have no mesh defined). It is unclear whether an "instance" can combine mesh from the "part" definition with mesh contained only in the "instance" definition. (Not appropriately documented in ABAUQUS Reference Manual.)

In order to provide convenient access to the data and mesh structures the following data model is used:

• EntitySet file_set • tags • NONE • members • all nodes of all parts and all instances • all elements of all parts and all instances • all assembly_sets • all part_sets • EntitySet part_set • tags • mSetNameTag (opaque=char*) name of entity set • members • part nodes • part elements • part node sets • part element sets • EntitySet assembly_set • tags • mSetNameTag (opaque=char*) name of entity set • members • instance_sets • instance element_sets • instance node_sets • instance nodes • instance elements • EntitySet instance_set • tags • mSetNameTag (opaque=char*) name of entity set • mPartHandleTag (handle) pointer to part from which this instance was generated • mAssemblyHandleTag (handle) pointer to assembly in which this instance exists • mInstancePIDTag (int) ordinal number indicating which instance of this part • mInstanceGIDTag (int) ordinal number indicating which instance in this assembly • members • instance nodes • instance elements • instance node_sets • instance element_sets • EntitySet node_set • tags • mSetNameTag (opaque=char*) name of entity set • mPartHandleTag (handle) pointer to part in which this node set exists (only defined for node sets that are in an instance and derive from a part) • mInstanceHandleTag (handle) pointer back to instance set in which this node set exists (NULL if this node_set is not in an instance) • mAssemblyHandleTag (handle) pointer to assembly in which this node set exists (NULL if this node_set is not in an assembly) • members • nodes • EntitySet element_set • tags • mSetNameTag (opaque=char*) name of entity set • mPartHandleTag (handle) pointer to part in which this element set exists (only defined for node sets that are in an instance and derive from a part) • mInstanceHandleTag (handle) pointer back to instance set in which this element set exists (NULL if this node_set is not in an instance) • mAssemblyHandleTag (handle) pointer to assembly in which this element set exists (NULL if this node_set is not in an assembly) • mMatNameTag (opaque=char*) name of material in these elements • mMaterialSetTag (integer) material id in these elements • members • elements • Entity node • tags • mLocalIDTag (int) numerical ID of node in local scope (part, instance) • mInstanceHandleTag (handle) pointer back to instance set in which this node exists (NULL if this node is not in an instance) • Entity element • tags • mLocalIDTag (int) numerical ID of element in local scope (part, instance) • mInstanceHandleTag (handle) pointer back to instance set in which this element exists (NULL if this element is not in an instance)

MOAB Damsel file reader For description of the Damsel-MOAB data model mapping, see WriteDamsel.cpp.

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. Data structure of MCNP5 data created by this reader:

each file_meshset contains DATA_AND_TIME_TAG TITLE_TAG NPS_TAG each tally_meshset contains TALLY_NUMBER_TAG TALLY_COMMENT_TAG TALLY_PARTICLE_TAG TALLY_COORD_SYS_TAG each mesh element contains TALLY_TAG ERROR_TAG

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. The RTT file format is used by the Attila deterministic radiation transport code. The specific mesh format can be found in Chapter 9 of the Attila manual. The format is defined by xml like, block/end block type syntax. The implementation at the time of writing supports a subset of the whole format, and even Attila does not support the entireity of its own mesh format.

The mesh contains several features, that as a whole allow the conversion from the RTT format, to a DAGMC geometry and a Tet Mesh for tallying.

Sides - Defines the 6 boundary condtions for top, bottom, front, back

left and right, as well as internal and external.

Faces - Logically equivalent to surfaces in DAGMC, containers for triangles, includes the definition of the sense of the faces with respect to the Cells (volumes) which bound it.

The face syntax looks like

1 (+)Pyrex@14

This means Face (surface) 1 is used to define the insde of the Pyrex cell only

75 (+)Pyrex/(-)Fuel30@25

This means Face (surface) 75 is used by both Cell Pyrex and Cell Fuel 30, the + and - signs refer to the sense, i.e. the inside sense defines the Pyrex and

the outside sense defines the Fuel.

Cells - Entityset like coillections of tetrahedra which define contiguous material properties

   cell_flags
     1 REGIONS
       1 Pyrex
   end_cell_flags

Defines that there is 1 region called Pyrex

Nodes - Defines the vertices for facets and tets, the syntax of which is shown below

100 1.8900000000E+03 0.0000000000E+00 5.0000000000E+03 100

Defines that this is node 100, and has the coordinates 1890.0, 0.0 5000.0 cm

Side (element) - Triangles

1 3 874 132 154 3 6365

Defines that this is side element 1, it has 3 nodes, 874, 132 and 154,

side ID 3 and surface number 6365

Cells (element) - Tetrahedra

691 4 599 556 1218 1216 2

Defines that this is tet 691, it has 4 connections to nodes 599, 556, 1218, 1216 and belongs to cell number 2.

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

Author: Clinton Stimpson

Date

15 April 2002

          Range FAQ and tips ********************

The purpose of this FAQ is to familiarize a user with the appropriate use of the Range template.

      A few points about Range: *******

Range is not the be all of generic containers.
Range has its strengths and weaknesses as any other STL container has.
Strengths: a. For contiguous values, storage is extremely minimal. b. Searching through contiguous values, at best, is a constant time operation. b. Fairly compatible with most STL algorithms. c. Insertions of data from high value to low value is a linear operation (constant for each insertion). d. Removal of a value using an iterator is constant time.
Weaknesses: a. For non-contiguous values, storage is not minimal and is on the order of 4x the storage space as using a vector. b. Searching through non-contiguous values is linear time operation. c. Insertions of random data is VERY slow.

Given the above characteristics of Ranges, you can now decide between Range and another STL container for your particular needs.

       Tips *******

Be aware of what iterators are available. Currently, there are three. Range<T>::iterator, Range<T>::const_iterator, and Range<T>::RangeListIterator. iterator is derived from const_iterator. const_iterator is derived from RangeListIterator. RangeListIterator is a std::list<std::pair<T,T> >::const_iterator. If a particular algorithm could be more efficient by using RangeListIterator, do so.

ie.

Range<char> range1; ... put some stuff in range1 Range<char> range2;

the SLOW way. std::copy(range1.begin(), range1.end(), range_inserter<...>(range2));

the FAST way. for(Range<char>::RangeListIterator iter = range1.begin(), iter != range1.end(); ++iter) { range2.insert(iter->first, iter->second); }

Prefer insert(val1, val2) over insert(val) where possible.
insert(val) and insert(val1, val2) have to perform searching to find out where to insert an item. Searches are started from the beginning of the values. Inserting larger values before smaller values will increase efficiency.

ie. std::set<int> my_set; Range<int> my_range; .. perform some operations which set does efficiently.

now copy the results from the set into the range. copy from the end of the set to the beginning of the set std::copy(my_set.rbegin(), my_set.rend(), range_inserter< Range<int> > ( my_range );

Use empty() instead of size() if you only need to find out if there is anything in the list.
Know what swap() does. Sometimes it is useful. It'll replace the contents of one list with another.

void compute_and_get_some_set( Range<char> range1, Range<char> range2, Range<char>& results ); { Range<char> tmp_results; .. perform some computation on range1 and range2 and put results in tmp_results; .. filter tmp_results out for some special type. .. etc.... return results results.swap(tmp_results); }

       FAQ *******

1. Why won't this code compile?

class SomeClass { public: Range<int> range; }; .... void some_function( const SomeClass& some_class ) { Range<int>::iterator = some_class.range.begin();

}

Solution: you need to use Range<int>::const_iterator instead.

Why doesn't this work right when I try to change the contents of an Range?

make a range that has the letters A,B,C in it. Range<char> my_chars('A', 'C'); make an iterator that points to 'A'. Range<char>::iterator iter = my_chars.begin(); change A to D iter = 'D'; print contents of my_chars to stdout std::copy(my_chars.begin(), my_chars.end(), std::ostream_iterator(std::cout, " "));

result is A B C instead of B C D

When one calls *iter, which returns 'A', the actual storage of the value 'A' which is returned is in the iterator and not in the Range. This allows for multiple iterators on a single Range and the Range does not have to keep track of which iterator is referencing which value.

MOAB, a Mesh-Oriented datABase, is a software component for creating, storing and accessing finite element mesh data.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

Typedef Documentation

◆ AdjacencyVector

typedef std::vector< EntityHandle > moab::AdjacencyVector

Definition at line 29 of file AEntityFactory.hpp.

◆ DimensionPair

typedef std::pair< EntityType, EntityType > moab::DimensionPair

Definition at line 54 of file CN.hpp.

◆ EntityHandle

typedef unsigned long moab::EntityHandle

Examples: DeformMeshRemap.cpp, DirectAccessNoHoles.cpp, DirectAccessWithHoles.cpp, ExtractLand.cpp, ExtrudePoly.cpp, GenLargeMesh.cpp, GetEntities.cpp, LaplacianSmoother.cpp, LloydRelaxation.cpp, QuadTriConv.cpp, ReadPartFile.cpp, ReadWriteTest.cpp, ReduceExchangeTags.cpp, StructuredMeshSimple.cpp, TestExodusII.cpp, addPCdata.cpp, and copyPartition.cpp.

Definition at line 43 of file EntityHandle.hpp.

◆ EntityID

typedef long moab::EntityID

Definition at line 48 of file EntityHandle.hpp.

◆ EvalFcn

typedef ErrorCode( * moab::EvalFcn) (const double *params, const double *field, const int ndim, const int num_tuples, double *work, double *result)

Definition at line 14 of file ElemEvaluator.hpp.

◆ HandleMap

typedef RangeMap< EntityHandle, EntityHandle, 0 > moab::HandleMap

Definition at line 40 of file ParallelComm.hpp.

◆ HandleVec

typedef std::vector< EntityHandle > moab::HandleVec

Definition at line 30 of file Forward.hpp.

◆ HDF5_Error_Func_Type

typedef herr_t( * moab::HDF5_Error_Func_Type) (void *)

Definition at line 14 of file HDF5Common.hpp.

◆ HFacet

typedef EntityHandle moab::HFacet

HalfFacetRep class implements the Array-Based Half-Facet(AHF) Mesh data structure on top of MOAB. \ It is based on a generalized notion of a half-facet derived from that a half-edge/half-face data structure for 2D/3D. \ The core construct of AHF are its two maps: sibling-half-facets(SIBHFS) and vertex-to-half-facet(V2HF) \ 1. SIBHFS: Maps every half-facet in the mesh to its sibling half-facets, \ 2. V2HF: Maps each vertex to an incident half-facet \ Using these two maps, a range of adjacency queries is performed. The maps are stored in dense tags over entities and vertices. \ \ Adjacency functions: \ 1. upward-incidence queries: vertex -> edge, edge -> faces, edge -> cells, face ->cells \ 2. neighborhood (same-dimensional) adjacency queries: edge -> edges, face -> faces, cell -> cells, etc. \ 3. downward adjacency queries: face -> edges, cell -> edges, etc. \ \ Mesh types supported: \ 1D(edges), 2D(triangles, quads), 3D(tet, pyramid, prism, hex), Mixed dimensional meshes \ \ CURRENTLY NOT SUPPORTED: \ 1. Meshes with mixed entity types of same dimension. Ex. a volume mesh with both tets and prisms. \ 2. create_if_missing = true \ 3. Modified meshes .

Definition at line 49 of file HalfFacetRep.hpp.

◆ InitFcn

typedef ErrorCode( * moab::InitFcn) (const double *verts, const int nverts, double *&work)

Definition at line 36 of file ElemEvaluator.hpp.

◆ InsideFcn

typedef int( * moab::InsideFcn) (const double *verts, const int ndims, const double tol)

Definition at line 38 of file ElemEvaluator.hpp.

◆ IntegrateFcn

typedef ErrorCode( * moab::IntegrateFcn) (const double *field, const double *verts, const int nverts, const int ndim, const int num_tuples, double *work, double *result)

Definition at line 28 of file ElemEvaluator.hpp.

◆ JacobianFcn

typedef ErrorCode( * moab::JacobianFcn) (const double *params, const double *verts, const int nverts, const int ndim, double *work, double *result)

Definition at line 21 of file ElemEvaluator.hpp.

◆ MeshSetRange

typedef std::pair< EntityHandle, EntityHandle > moab::MeshSetRange

Definition at line 429 of file MeshSet.cpp.

◆ NormalFcn

typedef ErrorCode( * moab::NormalFcn) (const int ientDim, const int facet, const int nverts, const double *verts, double normal[3])

Definition at line 53 of file ElemEvaluator.hpp.

◆ ReverseEvalFcn

typedef ErrorCode( * moab::ReverseEvalFcn) (EvalFcn eval, JacobianFcn jacob, InsideFcn ins, const double *posn, const double *verts, const int nverts, const int ndim, const double iter_tol, const double inside_tol, double *work, double *params, int *is_inside)

Definition at line 40 of file ElemEvaluator.hpp.

◆ TagDoublesEqual

typedef TagTypeEqual< double > moab::TagDoublesEqual

Definition at line 258 of file TagCompare.hpp.

◆ TagDoublesLess

typedef TagTypeLess< double > moab::TagDoublesLess

Definition at line 260 of file TagCompare.hpp.

◆ TagHandlesEqual

typedef TagBytesEqual moab::TagHandlesEqual

Definition at line 251 of file TagCompare.hpp.

◆ TagHandlesLess

typedef TagTypeLess< EntityHandle > moab::TagHandlesLess

Definition at line 253 of file TagCompare.hpp.

◆ TagIntsEqual

typedef TagBytesEqual moab::TagIntsEqual

Definition at line 244 of file TagCompare.hpp.

◆ TagIntsLess

typedef TagTypeLess< int > moab::TagIntsLess

Definition at line 246 of file TagCompare.hpp.

◆ TagOneDoubleEqual

typedef TagOneTypeEqual< double > moab::TagOneDoubleEqual

Definition at line 262 of file TagCompare.hpp.

◆ TagOneDoubleLess

typedef TagOneTypeLess< double > moab::TagOneDoubleLess

Definition at line 263 of file TagCompare.hpp.

◆ TagOneHandleEqual

typedef TagOneTypeEqual< EntityHandle > moab::TagOneHandleEqual

Definition at line 255 of file TagCompare.hpp.

◆ TagOneHandleLess

typedef TagOneTypeLess< EntityHandle > moab::TagOneHandleLess

Definition at line 256 of file TagCompare.hpp.

◆ TagOneIntEqual

typedef TagOneTypeEqual< int > moab::TagOneIntEqual

Definition at line 248 of file TagCompare.hpp.

◆ TagOneIntLess

typedef TagOneTypeLess< int > moab::TagOneIntLess

Definition at line 249 of file TagCompare.hpp.

◆ TagVarDoublesEqual

typedef TagVarTypeEqual< double > moab::TagVarDoublesEqual

Definition at line 259 of file TagCompare.hpp.

◆ TagVarDoublesLess

typedef TagVarTypeLess< double > moab::TagVarDoublesLess

Definition at line 261 of file TagCompare.hpp.

◆ TagVarHandlesEqual

typedef TagVarBytesEqual moab::TagVarHandlesEqual

Definition at line 252 of file TagCompare.hpp.

◆ TagVarHandlesLess

typedef TagVarTypeLess< EntityHandle > moab::TagVarHandlesLess

Definition at line 254 of file TagCompare.hpp.

◆ TagVarIntsEqual

typedef TagVarBytesEqual moab::TagVarIntsEqual

Definition at line 245 of file TagCompare.hpp.

◆ TagVarIntsLess

typedef TagVarTypeLess< int > moab::TagVarIntsLess

Definition at line 247 of file TagCompare.hpp.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
MAX_VERTICES
MAX_EDGES
MAX_FACES
MAX_VERTS_HF
MAX_INCIDENT_HF

Definition at line 65 of file HalfFacetRep.hpp.

 {
  MAX_VERTICES = 8,
  MAX_EDGES = 12,
  MAX_FACES = 6,
  MAX_VERTS_HF = 4,
  MAX_INCIDENT_HF = 4
 };

◆ anonymous enum

anonymous enum

Enumerator
MAX_SUB_ENTITIES	the maximum number n-1 dimension adjacencies a element may have
MAX_SUB_ENTITY_VERTICES	the maximum number of nodes an n-1 dimensional element may have

Definition at line 46 of file CN.hpp.

 {
  //! the maximum number n-1 dimension adjacencies a element may have
  MAX_SUB_ENTITIES = 12,
  //! the maximum number of nodes an n-1 dimensional element may have
  MAX_SUB_ENTITY_VERTICES = 9
 };

◆ abaqus_assembly_params

enum moab::abaqus_assembly_params

Enumerator
abq_assembly_undefined
abq_assembly_ambiguous
abq_assembly_name

Definition at line 286 of file ReadABAQUS.hpp.

 {
  abq_assembly_undefined = 0,
  abq_assembly_ambiguous,
  abq_assembly_name
 };

◆ abaqus_element_params

enum moab::abaqus_element_params

Enumerator
abq_element_undefined
abq_element_ambiguous
abq_element_elset
abq_element_type

Definition at line 301 of file ReadABAQUS.hpp.

 {
  abq_element_undefined = 0,
  abq_element_ambiguous,
  abq_element_elset,
  abq_element_type
 };

◆ abaqus_element_type

enum moab::abaqus_element_type

Enumerator
abq_eletype_unsupported
abq_eletype_dc3d8
abq_eletype_c3d8r
abq_eletype_dcc3d8
abq_eletype_c3d4
abq_eletype_dc3d4
abq_eletype_ds4

Definition at line 309 of file ReadABAQUS.hpp.

 {
  abq_eletype_unsupported = 0,
  abq_eletype_dc3d8,
  abq_eletype_c3d8r,
  abq_eletype_dcc3d8,
  abq_eletype_c3d4,
  abq_eletype_dc3d4,
  abq_eletype_ds4
 };

◆ abaqus_elset_params

enum moab::abaqus_elset_params

Enumerator
abq_elset_undefined
abq_elset_ambiguous
abq_elset_elset
abq_elset_generate
abq_elset_instance

Definition at line 330 of file ReadABAQUS.hpp.

 {
  abq_elset_undefined = 0,
  abq_elset_ambiguous,
  abq_elset_elset,
  abq_elset_generate,
  abq_elset_instance
 };

◆ abaqus_instance_params

enum moab::abaqus_instance_params

Enumerator
abq_instance_undefined
abq_instance_ambiguous
abq_instance_name
abq_instance_part

Definition at line 278 of file ReadABAQUS.hpp.

 {
  abq_instance_undefined = 0,
  abq_instance_ambiguous,
  abq_instance_name,
  abq_instance_part
 };

◆ abaqus_keyword_type

enum moab::abaqus_keyword_type

Enumerator
abq_undefined
abq_unsupported
abq_ambiguous
abq_heading
abq_part
abq_end_part
abq_assembly
abq_end_assembly
abq_node
abq_element
abq_nset
abq_elset
abq_instance
abq_end_instance
abq_solid_section

Definition at line 252 of file ReadABAQUS.hpp.

 {
  abq_undefined = 0,
  abq_unsupported,
  abq_ambiguous,
  abq_heading,
  abq_part,
  abq_end_part,
  abq_assembly,
  abq_end_assembly,
  abq_node,
  abq_element,
  abq_nset,
  abq_elset,
  abq_instance,
  abq_end_instance,
  abq_solid_section
 };

◆ abaqus_line_types

enum moab::abaqus_line_types

Enumerator
abq_undefined_line
abq_blank_line
abq_comment_line
abq_keyword_line
abq_data_line
abq_eof

Definition at line 242 of file ReadABAQUS.hpp.

 {
  abq_undefined_line = 0,
  abq_blank_line,
  abq_comment_line,
  abq_keyword_line,
  abq_data_line,
  abq_eof
 };

◆ abaqus_node_params

enum moab::abaqus_node_params

Enumerator
abq_node_undefined
abq_node_ambiguous
abq_node_nset
abq_node_system

Definition at line 293 of file ReadABAQUS.hpp.

 {
  abq_node_undefined = 0,
  abq_node_ambiguous,
  abq_node_nset,
  abq_node_system
 };

◆ abaqus_nset_params

enum moab::abaqus_nset_params

Enumerator
abq_nset_undefined
abq_nset_ambiguous
abq_nset_nset
abq_nset_elset
abq_nset_generate
abq_nset_instance

Definition at line 320 of file ReadABAQUS.hpp.

 {
  abq_nset_undefined = 0,
  abq_nset_ambiguous,
  abq_nset_nset,
  abq_nset_elset,
  abq_nset_generate,
  abq_nset_instance
 };

◆ abaqus_part_params

enum moab::abaqus_part_params

Enumerator
abq_part_undefined
abq_part_ambiguous
abq_part_name

Definition at line 271 of file ReadABAQUS.hpp.

 {
  abq_part_undefined = 0,
  abq_part_ambiguous,
  abq_part_name
 };

◆ abaqus_solid_section_params

enum moab::abaqus_solid_section_params

Enumerator
abq_solid_section_undefined
abq_solid_section_ambiguous
abq_solid_section_elset
abq_solid_section_matname

Definition at line 339 of file ReadABAQUS.hpp.

 {
  abq_solid_section_undefined = 0,
  abq_solid_section_ambiguous,
  abq_solid_section_elset,
  abq_solid_section_matname
 };

◆ ErrorType

enum moab::ErrorType

ErrorType - passed to the error handling routines indicating whether this is a new error (globally fatal or per-processor relevant) to be created, or an existing one to be handled.

Enumerator
MB_ERROR_TYPE_NEW_GLOBAL
MB_ERROR_TYPE_NEW_LOCAL
MB_ERROR_TYPE_EXISTING

Definition at line 18 of file ErrorHandler.hpp.

 {
  MB_ERROR_TYPE_NEW_GLOBAL = 0,
  MB_ERROR_TYPE_NEW_LOCAL = 1,
  MB_ERROR_TYPE_EXISTING = 2
 };

◆ ExoIIElementType

enum moab::ExoIIElementType

Enumerator
EXOII_SPHERE
EXOII_SPRING
EXOII_BAR
EXOII_BAR2
EXOII_BAR3
EXOII_BEAM
EXOII_BEAM2
EXOII_BEAM3
EXOII_TRUSS
EXOII_TRUSS2
EXOII_TRUSS3
EXOII_TRI
EXOII_TRI3
EXO_SHELL3
EXOII_TRI6
EXOII_TRI7
EXOII_QUAD
EXOII_QUAD4
EXOII_QUAD5
EXOII_QUAD8
EXOII_QUAD9
EXOII_SHELL
EXOII_SHELL4
EXOII_SHELL5
EXOII_SHELL8
EXOII_SHELL9
EXOII_TETRA
EXOII_TETRA4
EXOII_TET4
EXOII_TETRA8
EXOII_TETRA10
EXOII_TETRA14
EXOII_PYRAMID
EXOII_PYRAMID5
EXOII_PYRAMID10
EXOII_PYRAMID13
EXOII_PYRAMID18
EXOII_WEDGE
EXOII_KNIFE
EXOII_HEX
EXOII_HEX8
EXOII_HEX9
EXOII_HEX20
EXOII_HEX27
EXOII_HEXSHELL
EXOII_POLYGON
EXOII_POLYHEDRON
EXOII_MAX_ELEM_TYPE

Definition at line 25 of file ExoIIInterface.hpp.

 {
  EXOII_SPHERE = 0,
  EXOII_SPRING,
  EXOII_BAR,
  EXOII_BAR2,
  EXOII_BAR3,
  EXOII_BEAM,
  EXOII_BEAM2,
  EXOII_BEAM3,
  EXOII_TRUSS,
  EXOII_TRUSS2,
  EXOII_TRUSS3,
  EXOII_TRI,
  EXOII_TRI3,
  EXO_SHELL3,
  EXOII_TRI6,
  EXOII_TRI7,
  EXOII_QUAD,
  EXOII_QUAD4,
  EXOII_QUAD5,
  EXOII_QUAD8,
  EXOII_QUAD9,
  EXOII_SHELL,
  EXOII_SHELL4,
  EXOII_SHELL5,
  EXOII_SHELL8,
  EXOII_SHELL9,
  EXOII_TETRA,
  EXOII_TETRA4,
  EXOII_TET4,
  EXOII_TETRA8,
  EXOII_TETRA10,
  EXOII_TETRA14,
  EXOII_PYRAMID,
  EXOII_PYRAMID5,
  EXOII_PYRAMID10,
  EXOII_PYRAMID13,
  EXOII_PYRAMID18,
  EXOII_WEDGE,
  EXOII_KNIFE,
  EXOII_HEX,
  EXOII_HEX8,
  EXOII_HEX9,
  EXOII_HEX20,
  EXOII_HEX27,
  EXOII_HEXSHELL,
  EXOII_POLYGON,
  EXOII_POLYHEDRON,
  EXOII_MAX_ELEM_TYPE
 };

◆ GEOMTYPE

enum moab::GEOMTYPE

Enumerator
HISURFACE
HI3DCURVE
HI2DCURVE

Definition at line 28 of file HiReconstruction.hpp.

 {
  HISURFACE,
  HI3DCURVE,
  HI2DCURVE
 };

◆ keyword_type

enum moab::keyword_type

Enumerator
obj_undefined
object_start
group_start
face_start
vertex_start
valid_unsupported

Definition at line 106 of file ReadOBJ.hpp.

 {
  obj_undefined = 0,
  object_start,
  group_start,
  face_start,
  vertex_start,
  valid_unsupported
 };

◆ MBMessageTag

enum moab::MBMessageTag

Enumerator
MB_MESG_ANY
MB_MESG_ENTS_ACK
MB_MESG_ENTS_SIZE
MB_MESG_ENTS_LARGE
MB_MESG_REMOTEH_ACK
MB_MESG_REMOTEH_SIZE
MB_MESG_REMOTEH_LARGE
MB_MESG_TAGS_ACK
MB_MESG_TAGS_SIZE
MB_MESG_TAGS_LARGE

Definition at line 226 of file ParallelComm.cpp.

 {
  MB_MESG_ANY = MPI_ANY_TAG,
  MB_MESG_ENTS_ACK,
  MB_MESG_ENTS_SIZE,
  MB_MESG_ENTS_LARGE,
  MB_MESG_REMOTEH_ACK,
  MB_MESG_REMOTEH_SIZE,
  MB_MESG_REMOTEH_LARGE,
  MB_MESG_TAGS_ACK,
  MB_MESG_TAGS_SIZE,
  MB_MESG_TAGS_LARGE
 };

◆ MESHTYPE

enum moab::MESHTYPE

ENUM for the type of input mesh.

Enumerator
CURVE
SURFACE
SURFACE_MIXED
VOLUME
VOLUME_MIXED_1
VOLUME_MIXED_2
VOLUME_MIXED

Definition at line 54 of file HalfFacetRep.hpp.

 {
  CURVE = 0, // Homogeneous curve mesh
  SURFACE, // Homogeneous surface mesh
  SURFACE_MIXED, // Mixed surface with embedded curves
  VOLUME, // Homogeneous volume mesh
  VOLUME_MIXED_1, // Volume mesh with embedded curves
  VOLUME_MIXED_2, // Volume mesh with embedded surface
  VOLUME_MIXED // Volume mesh with embedded curves and surfaces
 };

◆ QualityType

enum moab::QualityType

Enumerator
MB_UNDEFINED_QUALITY
MB_EDGE_RATIO
MB_MAX_EDGE_RATIO
MB_SKEW
MB_TAPER
MB_VOLUME
MB_STRETCH
MB_DIAGONAL
MB_DIMENSION
MB_ODDY
MB_MED_ASPECT_FROBENIUS
MB_MAX_ASPECT_FROBENIUS
MB_CONDITION
MB_JACOBIAN
MB_SCALED_JACOBIAN
MB_SHEAR
MB_SHAPE
MB_RELATIVE_SIZE_SQUARED
MB_SHAPE_AND_SIZE
MB_SHEAR_AND_SIZE
MB_DISTORTION
MB_LENGTH
MB_RADIUS_RATIO
MB_ASPECT_BETA
MB_ASPECT_RATIO
MB_ASPECT_GAMMA
MB_MINIMUM_ANGLE
MB_COLLAPSE_RATIO
MB_WARPAGE
MB_AREA
MB_MAXIMUM_ANGLE
MB_QUALITY_COUNT

Definition at line 18 of file VerdictWrapper.hpp.

 {
  // order exactly from HexMetricVals
  MB_UNDEFINED_QUALITY = -1,
  MB_EDGE_RATIO = 0, // 0 MBHEX, MBTET, MBQUAD, MBTRI
  MB_MAX_EDGE_RATIO, // 1 MBHEX, MBQUAD
  MB_SKEW, // 2 MBHEX, MBQUAD
  MB_TAPER, // 3 MBHEX, MBQUAD
  MB_VOLUME, // 4 MBHEX, MBTET, MBPRISM, MBKNIFE
  MB_STRETCH, // 5 MBHEX, MBQUAD
  MB_DIAGONAL, // 6 MBHEX,
  MB_DIMENSION, // 7 MBHEX,
  MB_ODDY, // 8 MBHEX, MBQUAD
  MB_MED_ASPECT_FROBENIUS, // 9 MBHEX, MBQUAD
  MB_MAX_ASPECT_FROBENIUS, // 10 MBHEX, MBTET (aspect_frobenius) MBQUAD, MBTRI
  // (aspect_frobenius)
  MB_CONDITION, // 11 MBHEX, MBTET, MBQUAD, MBTRI
  MB_JACOBIAN, // 12 MBHEX, MBTET, MBQUAD
  MB_SCALED_JACOBIAN, // 13 MBHEX, MBTET, MBQUAD, MBTRI
  MB_SHEAR, // 14 MBHEX, MBQUAD, MBTRI
  MB_SHAPE, // 15 MBHEX, MBTET, MBQUAD, MBTRI
  MB_RELATIVE_SIZE_SQUARED, // 16 MBHEX, MBTET, MBQUAD, MBTRI
  MB_SHAPE_AND_SIZE, // 17 MBHEX, MBTET, MBQUAD
  MB_SHEAR_AND_SIZE, // 18 MBHEX, MBQUAD
  MB_DISTORTION, // 19 MBHEX, MBTET, MBQUAD
  // length for edge:
  MB_LENGTH, // 20 only for MBEDGE
  // specific to tets
  MB_RADIUS_RATIO, // 21 MBTET, MBQUAD, MBTRI
  MB_ASPECT_BETA, // 22 MBTET
  MB_ASPECT_RATIO, // 23 MBTET, MBQUAD, MBTRI
  MB_ASPECT_GAMMA, // 24 MBTET
  MB_MINIMUM_ANGLE, // 25 MBTET, MBQUAD, MBTRI
  MB_COLLAPSE_RATIO, // 26 MBTET
  // specific to quads
  MB_WARPAGE, // 27 MBQUAD
  MB_AREA, // 28 MBQUAD, MBTRI
  MB_MAXIMUM_ANGLE, // 29 MBQUAD, MBTRI
  MB_QUALITY_COUNT // used to size the arrays
  
 };

Function Documentation

◆ ADD()

template<class T >

T moab::ADD	(	const T &	arg1,
		const T &	arg2
	)

Definition at line 3832 of file ParallelComm.cpp.

 {
  return arg1 + arg2;
 }

◆ all_root_set()

static bool moab::all_root_set	(	std::string	name,
		const EntityHandle *	array,
		size_t	len
	)

inlinestatic

Definition at line 27 of file MeshTag.cpp.

 {
  for( size_t i = 0; i < len; ++i )
  {
  if( array[i] )
  {
  not_root_set( name, array[i] );
  return false;
  }
  }
  
  return true;
 }

References not_root_set().

Referenced by moab::MeshTag::clear_data(), moab::MeshTag::get_data(), moab::MeshTag::remove_data(), and moab::MeshTag::set_data().

◆ allocate_mpe_state()

static std::pair< int, int > moab::allocate_mpe_state	(	const char *	,
		const char *
	)

static

Definition at line 50 of file ReadHDF5Dataset.cpp.

 {
  return std::pair< int, int >();
 }

Referenced by moab::ReadHDF5Dataset::ReadHDF5Dataset().

◆ angle()

double moab::angle	(	const CartVect &	u,
		const CartVect &	v
	)

inline

Interior angle between two vectors.

Definition at line 207 of file CartVect.hpp.

 {
  double tmp = ( u % v ) / std::sqrt( ( u % u ) * ( v % v ) );
  if( tmp > 1. ) tmp = 1.;
  if( tmp < -1. ) tmp = -1.;
  return std::acos( tmp );
 }

Referenced by moab::IntxAreaUtils::area_spherical_triangle_lHuiller(), moab::IntxUtils::enforce_convexity(), moab::GeomQueryTool::get_normal(), moab::SmoothFace::init_gradient(), interior_point(), moab::IntxUtils::oriented_spherical_angle(), moab::ReadSmf::rot(), VerdictVector::rotate(), moab::AffineXform::rotation(), moab::IntxAreaUtils::spherical_angle(), v_quad_maximum_angle(), v_quad_minimum_angle(), VerdictVector::vector_angle(), VerdictVector::vector_angle_quick(), and vectorRotate().

◆ angleCompare()

bool moab::angleCompare	(	angleAndIndex	lhs,
		angleAndIndex	rhs
	)

Definition at line 92 of file IntxUtils.cpp.

 {
  return lhs.angle < rhs.angle;
 }

References moab::angleAndIndex::angle.

Referenced by moab::IntxUtils::SortAndRemoveDoubles2().

◆ area_coordinates()

ErrorCode moab::area_coordinates	(	Interface *	mbi,
		EntityHandle	tri,
		CartVect &	pnt,
		double *	area_coord,
		EntityHandle &	boundary_handle
	)

Definition at line 98 of file FBEngine.cpp.

 {
  
  int nnodes;
  const EntityHandle* conn3;
  ErrorCode rval = mbi->get_connectivity( tri, conn3, nnodes );
  MBERRORR( rval, "Failed to get connectivity" );
  assert( 3 == nnodes );
  CartVect P[3];
  rval = mbi->get_coords( conn3, nnodes, (double*)&P[0] );
  MBERRORR( rval, "Failed to get coordinates" );
  
  CartVect r0( P[0] - pnt );
  CartVect r1( P[1] - pnt );
  CartVect r2( P[2] - pnt );
  if( debug_splits )
  {
  std::cout << " nodes:" << conn3[0] << " " << conn3[1] << " " << conn3[2] << "\n";
  std::cout << " distances: " << r0.length() << " " << r1.length() << " " << r2.length() << "\n";
  }
  if( r0.length() < tolerance_segment )
  {
  area_coord[0] = 1.;
  area_coord[1] = 0.;
  area_coord[2] = 0.;
  boundary_handle = conn3[0];
  return MB_SUCCESS;
  }
  if( r1.length() < tolerance_segment )
  {
  area_coord[0] = 0.;
  area_coord[1] = 1.;
  area_coord[2] = 0.;
  boundary_handle = conn3[1];
  return MB_SUCCESS;
  }
  if( r2.length() < tolerance_segment )
  {
  area_coord[0] = 0.;
  area_coord[1] = 0.;
  area_coord[2] = 1.;
  boundary_handle = conn3[2];
  return MB_SUCCESS;
  }
  
  CartVect v1( P[1] - P[0] );
  CartVect v2( P[2] - P[0] );
  
  double areaDouble = ( v1 * v2 ).length(); // the same for CartVect
  if( areaDouble < tolerance_segment * tolerance_segment )
  {
  MBERRORR( MB_FAILURE, "area of triangle too small" );
  }
  area_coord[0] = ( r1 * r2 ).length() / areaDouble;
  area_coord[1] = ( r2 * r0 ).length() / areaDouble;
  area_coord[2] = ( r0 * r1 ).length() / areaDouble;
  
  if( fabs( area_coord[0] + area_coord[1] + area_coord[2] - 1 ) > tolerance_segment )
  {
  MBERRORR( MB_FAILURE, "point outside triangle" );
  }
  // the tolerance is used here for area coordinates (0 to 1), and in other
  // parts it is used as an absolute distance; pretty inconsistent.
  bool side0 = ( area_coord[0] < tolerance_segment );
  bool side1 = ( area_coord[1] < tolerance_segment );
  bool side2 = ( area_coord[2] < tolerance_segment );
  if( !side0 && !side1 && !side2 ) return MB_SUCCESS; // interior point
  // now, find out what boundary is in question
  // first, get all edges, in order
  std::vector< EntityHandle > edges;
  EntityHandle nn2[2];
  for( int i = 0; i < 3; i++ )
  {
  nn2[0] = conn3[( i + 1 ) % 3];
  nn2[1] = conn3[( i + 2 ) % 3];
  std::vector< EntityHandle > adjacent;
  rval = mbi->get_adjacencies( nn2, 2, 1, false, adjacent, Interface::INTERSECT );
  MBERRORR( rval, "Failed to get edges" );
  if( adjacent.size() != 1 ) MBERRORR( MB_FAILURE, "Failed to get adjacent edges" );
  // should be only one edge here
  edges.push_back( adjacent[0] );
  }
  
  if( side0 ) boundary_handle = edges[0];
  if( side1 ) boundary_handle = edges[1];
  if( side2 ) boundary_handle = edges[2];
  
  return MB_SUCCESS;
 }

References debug_splits, ErrorCode, moab::Interface::get_adjacencies(), moab::Interface::get_connectivity(), moab::Interface::get_coords(), moab::Interface::INTERSECT, moab::CartVect::length(), length(), MB_SUCCESS, MBERRORR, and tolerance_segment.

Referenced by moab::FBEngine::split_surface_with_direction().

◆ box_from_axes()

static ErrorCode moab::box_from_axes	(	OrientedBox &	result,
		Interface *	instance,
		const Range &	points
	)

static

Common code for box calculation.

Given the orientation of the box and an approximate center, calculate the exact center and extents of the box.

Parameters

result.center	As input, the approximate center of the box. As output, the exact center of the box.
result.axes	As input, directions of principal axes corresponding to the orientation of the box. Axes are assumed to be unit-length on input. Output will include extents of box.
points	The set of points the box should contain.

Definition at line 166 of file OrientedBox.cpp.

 {
  ErrorCode rval;
  
  // project points onto axes to get box extents
  CartVect min( std::numeric_limits< double >::max() ), max( -std::numeric_limits< double >::max() );
  for( Range::iterator i = points.begin(); i != points.end(); ++i )
  {
  CartVect coords;
  rval = instance->get_coords( &*i, 1, coords.array() );MB_CHK_ERR( rval );
  
  for( int d = 0; d < 3; ++d )
  {
  const double t = point_perp( coords, result.center, result.axes.col( d ) );
  if( t < min[d] ) min[d] = t;
  if( t > max[d] ) max[d] = t;
  }
  }
  
  // We now have a box defined by three orthogonal line segments
  // that intersect at the center of the box. Each line segment
  // is defined as result.center + t * result.axes[i], where the
  // range of t is [min[i], max[i]].
  
  // Calculate new center
  const CartVect mid = 0.5 * ( min + max );
  result.center += mid[0] * result.axes.col( 0 ) + mid[1] * result.axes.col( 1 ) + mid[2] * result.axes.col( 2 );
  
  // reorder axes by length
  CartVect range = 0.5 * ( max - min );
  if( range[2] < range[1] )
  {
  if( range[2] < range[0] )
  {
  std::swap( range[0], range[2] );
  result.axes.swapcol( 0, 2 );
  }
  }
  else if( range[1] < range[0] )
  {
  std::swap( range[0], range[1] );
  result.axes.swapcol( 0, 1 );
  }
  if( range[1] > range[2] )
  {
  std::swap( range[1], range[2] );
  result.axes.swapcol( 1, 2 );
  }
  
  // scale axis to encompass all points, divide in half
 #if MB_ORIENTED_BOX_UNIT_VECTORS
  result.length = range;
 #else
  result.axes.colscale( 0, range[0] );
  result.axes.colscale( 1, range[1] );
  result.axes.colscale( 2, range[2] );
 #endif
  
 #if MB_ORIENTED_BOX_OUTER_RADIUS
  result.radius = range.length();
 #endif
  
  return MB_SUCCESS;
 }

References moab::CartVect::array(), moab::OrientedBox::axes, moab::Range::begin(), moab::OrientedBox::center, moab::Matrix3::col(), moab::Matrix3::colscale(), moab::Range::end(), ErrorCode, moab::Interface::get_coords(), moab::CartVect::length(), moab::OrientedBox::length, MB_CHK_ERR, MB_SUCCESS, point_perp(), moab::OrientedBox::radius, moab::Matrix3::swapcol(), and t.

Referenced by moab::OrientedBox::compute_from_covariance_data(), and moab::OrientedBox::compute_from_vertices().

◆ check_int_tag()

static ErrorCode moab::check_int_tag	(	Interface *	mb,
		Tag	tag
	)

static

Definition at line 301 of file ReadUtil.cpp.

 {
  int size;
  DataType type;
  ErrorCode rval = mb->tag_get_bytes( tag, size );
  if( MB_SUCCESS != rval ) return rval;
  if( size != sizeof( int ) ) return MB_TYPE_OUT_OF_RANGE;
  rval = mb->tag_get_data_type( tag, type );
  if( type != MB_TYPE_OPAQUE && type != MB_TYPE_INTEGER ) return MB_TYPE_OUT_OF_RANGE;
  
  return MB_SUCCESS;
 }

References ErrorCode, mb, MB_SUCCESS, MB_TYPE_INTEGER, MB_TYPE_OPAQUE, MB_TYPE_OUT_OF_RANGE, size, moab::Core::tag_get_bytes(), and moab::Core::tag_get_data_type().

Referenced by moab::ReadUtil::assign_ids().

◆ check_range()

static bool moab::check_range	(	const range_data &	d,
		bool	prefer_end,
		EntityHandle &	result
	)

static

Definition at line 453 of file TypeSequenceManager.cpp.

 {
  EntityHandle first = std::max( d.min_start_handle, d.first );
  EntityHandle last = std::min( d.max_end_handle, d.last );
  if( last < first + d.num_entities - 1 )
  {
  result = 0;
  return false;
  }
  
  result = prefer_end ? last + 1 - d.num_entities : first;
  return true;
 }

References moab::GeomUtil::first(), moab::range_data::first, moab::range_data::last, moab::range_data::max_end_handle, moab::range_data::min_start_handle, and moab::range_data::num_entities.

Referenced by moab::TypeSequenceManager::find_free_sequence().

◆ check_ray_limits()

bool moab::check_ray_limits	(	const double	normal_par_pos,
		const double	normal_par_dir,
		const double	half_extent,
		const double *	nonneg_ray_len,
		const double *	neg_ray_len
	)

inline

Definition at line 444 of file OrientedBox.cpp.

 {
  
  const double extent_pos_diff = half_extent - normal_par_pos;
  
  // limit in positive direction
  if( nonneg_ray_len )
  { // should be 0 <= t <= nonneg_ray_len
  assert( 0 <= *nonneg_ray_len );
  if( normal_par_dir > 0 )
  { // if/else if needed for pos/neg divisor
  if( *nonneg_ray_len * normal_par_dir >= extent_pos_diff && extent_pos_diff >= 0 ) return true;
  }
  else if( normal_par_dir < 0 )
  {
  if( *nonneg_ray_len * normal_par_dir <= extent_pos_diff && extent_pos_diff <= 0 ) return true;
  }
  }
  else
  { // should be 0 <= t
  if( normal_par_dir > 0 )
  { // if/else if needed for pos/neg divisor
  if( extent_pos_diff >= 0 ) return true;
  }
  else if( normal_par_dir < 0 )
  {
  if( extent_pos_diff <= 0 ) return true;
  }
  }
  
  // limit in negative direction
  if( neg_ray_len )
  { // should be neg_ray_len <= t < 0
  assert( 0 >= *neg_ray_len );
  if( normal_par_dir > 0 )
  { // if/else if needed for pos/neg divisor
  if( *neg_ray_len * normal_par_dir <= extent_pos_diff && extent_pos_diff < 0 ) return true;
  }
  else if( normal_par_dir < 0 )
  {
  if( *neg_ray_len * normal_par_dir >= extent_pos_diff && extent_pos_diff > 0 ) return true;
  }
  }
  
  return false;
 }

Referenced by moab::OrientedBox::intersect_ray().

◆ check_tag_type()

static ErrorCode moab::check_tag_type	(	Interface *	moab,
		Tag	tag,
		DataType	exp_type,
		int	exp_size
	)

static

Definition at line 44 of file ReorderTool.cpp.

 {
  ErrorCode rval;
  DataType act_type;
  int act_size;
  
  rval = moab->tag_get_data_type( tag, act_type );CHKERR;
  
  rval = moab->tag_get_bytes( tag, act_size );CHKERR;
  
  if( act_type != exp_type || act_size != exp_size ) return MB_TYPE_OUT_OF_RANGE;
  
  return MB_SUCCESS;
 }

References CHKERR, ErrorCode, MB_SUCCESS, and MB_TYPE_OUT_OF_RANGE.

Referenced by moab::ReorderTool::handle_order_from_int_tag(), moab::ReorderTool::int_order_from_sets_and_adj(), and moab::ReorderTool::reorder_entities().

◆ choose_owner_idx()

static size_t moab::choose_owner_idx ( const std::vector< unsigned > & proc_list )

static

Definition at line 4478 of file ParallelComm.cpp.

 {
  // Try to assign owners randomly so we get a good distribution,
  // (note: specifying the same seed on all procs is essential)
  unsigned val = 0;
  for( size_t i = 0; i < proc_list.size(); i++ )
  val ^= proc_list[i];
  srand( (int)( val ) );
  return rand() % proc_list.size();
 }

Referenced by moab::ParallelComm::resolve_shared_sets().

◆ closest_to_triangles() [1/2]

static ErrorCode moab::closest_to_triangles	(	Interface *	moab,
		const Range &	tris,
		const CartVect &	from,
		double &	shortest_dist_sqr,
		CartVect &	closest_pt,
		EntityHandle &	closest_tri
	)

static

Definition at line 1542 of file AdaptiveKDTree.cpp.

 {
  ErrorCode rval;
  CartVect pos, diff, verts[3];
  const EntityHandle* conn = NULL;
  int len = 0;
  
  for( Range::iterator i = tris.begin(); i != tris.end(); ++i )
  {
  rval = moab->get_connectivity( *i, conn, len );
  if( MB_SUCCESS != rval ) return rval;
  
  rval = moab->get_coords( conn, 3, verts[0].array() );
  if( MB_SUCCESS != rval ) return rval;
  
  GeomUtil::closest_location_on_tri( from, verts, pos );
  diff = pos - from;
  double dist_sqr = diff % diff;
  if( dist_sqr < shortest_dist_sqr )
  {
  // new closest location
  shortest_dist_sqr = dist_sqr;
  closest_pt = pos;
  closest_tri = *i;
  }
  }
  
  return MB_SUCCESS;
 }

References moab::Range::begin(), moab::GeomUtil::closest_location_on_tri(), moab::Range::end(), ErrorCode, and MB_SUCCESS.

Referenced by closest_to_triangles(), moab::AdaptiveKDTree::closest_triangle(), and moab::AdaptiveKDTree::find_close_triangle().

◆ closest_to_triangles() [2/2]

static ErrorCode moab::closest_to_triangles	(	Interface *	moab,
		EntityHandle	set_handle,
		const CartVect &	from,
		double &	shortest_dist_sqr,
		CartVect &	closest_pt,
		EntityHandle &	closest_tri
	)

static

Definition at line 1577 of file AdaptiveKDTree.cpp.

 {
  ErrorCode rval;
  Range tris;
  
  rval = moab->get_entities_by_type( set_handle, MBTRI, tris );
  if( MB_SUCCESS != rval ) return rval;
  
  return closest_to_triangles( moab, tris, from, shortest_dist_sqr, closest_pt, closest_tri );
 }

References closest_to_triangles(), ErrorCode, MB_SUCCESS, and MBTRI.

◆ compare_handle_id()

int moab::compare_handle_id	(	const void *	a,
		const void *	b
	)

Definition at line 200 of file MergeMesh.cpp.

 {
  
  handle_id* ia = (handle_id*)a;
  handle_id* ib = (handle_id*)b;
  if( ia->val == ib->val )
  {
  return ( ia->eh < ib->eh ) ? -1 : 1;
  }
  else
  {
  return ( ia->val - ib->val );
  }
 }

References moab::handle_id::eh, and moab::handle_id::val.

Referenced by moab::MergeMesh::merge_using_integer_tag().

◆ connectivity_match()

template<typename T >

bool moab::connectivity_match	(	const T *	conn1_i,
		const T *	conn2_i,
		const int	num_vertices,
		int &	direct,
		int &	offset
	)

inline

Definition at line 469 of file CN.cpp.

 {
  
  bool they_match;
  
  // special test for 2 handles, since we don't want to wrap the list in this
  // case
  if( num_vertices == 2 )
  {
  they_match = false;
  if( conn1_i[0] == conn2_i[0] && conn1_i[1] == conn2_i[1] )
  {
  direct = 1;
  they_match = true;
  offset = 0;
  }
  else if( conn1_i[0] == conn2_i[1] && conn1_i[1] == conn2_i[0] )
  {
  they_match = true;
  direct = -1;
  offset = 1;
  }
  }
  
  else
  {
  const T* iter;
  iter = std::find( &conn2_i[0], &conn2_i[num_vertices], conn1_i[0] );
  if( iter == &conn2_i[num_vertices] ) return false;
  
  they_match = true;
  
  offset = iter - conn2_i;
  int i;
  
  // first compare forward
  for( i = 1; i < num_vertices; ++i )
  {
  if( conn1_i[i] != conn2_i[( offset + i ) % num_vertices] )
  {
  they_match = false;
  break;
  }
  }
  
  if( they_match == true )
  {
  direct = 1;
  return they_match;
  }
  
  they_match = true;
  
  // then compare reverse
  for( i = 1; i < num_vertices; i++ )
  {
  if( conn1_i[i] != conn2_i[( offset + num_vertices - i ) % num_vertices] )
  {
  they_match = false;
  break;
  }
  }
  if( they_match )
  {
  direct = -1;
  }
  }
  
  return they_match;
 }

References T.

◆ convert_to_ranged_ids()

template<typename TYPE >

static void moab::convert_to_ranged_ids	(	const TYPE *	buffer,
		size_t	len,
		std::vector< WriteHDF5::wid_t > &	result
	)

static

Definition at line 1740 of file WriteHDF5Parallel.cpp.

 {
  if( !len )
  {
  result.clear();
  return;
  }
  
  result.resize( len * 2 );
  Range tmp;
  for( size_t i = 0; i < len; i++ )
  tmp.insert( (EntityHandle)buffer[i] );
  result.resize( tmp.psize() * 2 );
  int j = 0;
  for( Range::const_pair_iterator pit = tmp.const_pair_begin(); pit != tmp.const_pair_end(); ++pit, j++ )
  {
  result[2 * j] = pit->first;
  result[2 * j + 1] = pit->second - pit->first + 1;
  }
 }

References buffer, moab::Range::const_pair_begin(), moab::Range::const_pair_end(), moab::Range::insert(), and moab::Range::psize().

Referenced by moab::WriteHDF5Parallel::unpack_set().

◆ convert_to_ranges()

static void moab::convert_to_ranges	(	const EntityHandle *	vect_in,
		size_t	vect_in_len,
		std::vector< EntityHandle > &	vect_out
	)

static

Convert unsorted array of handles into array of ranged [begin,end] pairs

Definition at line 1160 of file MeshSet.cpp.

 {
  vect_out.reserve( 2 * vect_in_len );
  vect_out.resize( vect_in_len );
  std::copy( vect_in, vect_in + vect_in_len, vect_out.begin() );
  std::sort( vect_out.begin(), vect_out.end() );
  vect_out.erase( std::unique( vect_out.begin(), vect_out.end() ), vect_out.end() );
  
  // duplicate all entries
  vect_out.resize( vect_out.size() * 2 );
  for( long i = vect_out.size() - 1; i >= 0; --i )
  vect_out[i] = vect_out[i / 2];
  
  // compact adjacent ranges
  std::vector< EntityHandle >::iterator r = vect_out.begin(), w = vect_out.begin();
  while( r != vect_out.end() )
  {
  *w = *r;
  ++w;
  ++r;
  *w = *r;
  ++r;
  
  while( r != vect_out.end() && *w + 1 == *r )
  {
  ++r;
  *w = *r;
  ++r;
  }
  ++w;
  }
  
  // remove extra space
  vect_out.erase( w, vect_out.end() );
 }

Referenced by moab::MeshSet::convert(), moab::MeshSet::insert_entity_vector(), and moab::MeshSet::remove_entity_vector().

◆ copy_coords()

static void moab::copy_coords	(	const double	src[3],
		double	dest[3]
	)

inlinestatic

Definition at line 580 of file BSPTree.cpp.

 {
  dest[0] = src[0];
  dest[1] = src[1];
  dest[2] = src[2];
 }

Referenced by moab::BSPTreeBoxIter::face_corners(), and plane_uncut_box().

◆ copy_set_contents()

static Range::iterator moab::copy_set_contents	(	Range::iterator	hint,
		int	ranged,
		EntityHandle *	contents,
		long	length,
		Range &	results
	)

static

Definition at line 2390 of file ReadHDF5.cpp.

 {
  if( ranged )
  {
  assert( length % 2 == 0 );
  for( long i = 0; i < length; i += 2 )
  hint = results.insert( hint, contents[i], contents[i] + contents[i + 1] - 1 );
  }
  else
  {
  std::sort( contents, contents + length );
  for( long i = 0; i < length; ++i )
  hint = results.insert( hint, contents[i] );
  }
  return hint;
 }

References moab::Range::insert(), and length().

Referenced by moab::ReadHDF5::read_set_data().

◆ copy_sorted_file_ids()

static void moab::copy_sorted_file_ids	(	const EntityHandle *	sorted_ids,
		long	num_ids,
		Range &	results
	)

static

Definition at line 112 of file ReadHDF5.cpp.

 {
  Range::iterator hint = results.begin();
  long i = 0;
  while( i < num_ids )
  {
  EntityHandle start = sorted_ids[i];
  for( ++i; i < num_ids && sorted_ids[i] == 1 + sorted_ids[i - 1]; ++i )
  ;
  hint = results.insert( hint, start, sorted_ids[i - 1] );
  }
 }

References moab::Range::begin(), and moab::Range::insert().

Referenced by moab::ReadHDF5::read_elems(), and moab::ReadHDF5::search_tag_values().

◆ corners_from_box()

static void moab::corners_from_box	(	const double	box_min[3],
		const double	box_max[3],
		double	corners[8][3]
	)

static

Definition at line 42 of file BSPTree.cpp.

 {
  const double* ranges[] = { box_min, box_max };
  for( int z = 0; z < 2; ++z )
  {
  corners[4 * z][0] = box_min[0];
  corners[4 * z][1] = box_min[1];
  corners[4 * z][2] = ranges[z][2];
  
  corners[4 * z + 1][0] = box_max[0];
  corners[4 * z + 1][1] = box_min[1];
  corners[4 * z + 1][2] = ranges[z][2];
  
  corners[4 * z + 2][0] = box_max[0];
  corners[4 * z + 2][1] = box_max[1];
  corners[4 * z + 2][2] = ranges[z][2];
  
  corners[4 * z + 3][0] = box_min[0];
  corners[4 * z + 3][1] = box_max[1];
  corners[4 * z + 3][2] = ranges[z][2];
  }
 }

References box_max(), and box_min().

Referenced by moab::BSPTree::create_tree(), and moab::BSPTree::set_tree_box().

◆ count_num_handles()

template<class HandleRangeIter >

size_t moab::count_num_handles	(	HandleRangeIter	iter,
		HandleRangeIter	end
	)

inline

Definition at line 1579 of file WriteHDF5.cpp.

 {
  size_t result = 0;
  for( ; iter != end; ++iter )
  result += iter->second - iter->first + 1;
  
  return result;
 }

Referenced by range_to_blocked_list_templ(), and range_to_id_list_templ().

◆ CREATE_HALFFACET()

EntityHandle moab::CREATE_HALFFACET	(	const unsigned	lid,
		const EntityID	id
	)

inline

Definition at line 31 of file HalfFacetRep.cpp.

 {
  assert( id <= MB_END_ID && lid < 6 );
  return ( ( (HFacet)lid ) << MB_ID_WIDTH ) | id;
 }

References MB_END_ID, and MB_ID_WIDTH.

Referenced by moab::HalfFacetRep::create_halffacet().

◆ CREATE_HANDLE() [1/2]

EntityHandle moab::CREATE_HANDLE	(	const unsigned	type,
		const EntityID	id
	)

inline

Definition at line 68 of file Internals.hpp.

 {
  assert( id <= MB_END_ID && type <= MBMAXTYPE );
  return ( ( (EntityHandle)type ) << MB_ID_WIDTH ) | id;
 }

References MB_END_ID, MB_ID_WIDTH, and MBMAXTYPE.

◆ CREATE_HANDLE() [2/2]

EntityHandle moab::CREATE_HANDLE	(	const unsigned	type,
		const EntityID	id,
		int &	err
	)

inline

Given a type and an id create a handle.

Definition at line 55 of file Internals.hpp.

 {
  err = 0; //< Assume that there is a real error value defined somewhere
  
  if( id > MB_END_ID || type > MBMAXTYPE )
  {
  err = 1; //< Assume that there is a real error value defined somewhere
  return 1; //<You've got to return something. What do you return?
  }
  
  return ( ( (EntityHandle)type ) << MB_ID_WIDTH ) | id;
 }

References MB_END_ID, MB_ID_WIDTH, and MBMAXTYPE.

Referenced by moab::SequenceManager::check_valid_entities(), moab::WriteHDF5Parallel::communicate_shared_set_data(), moab::SequenceManager::create_element(), moab::SequenceManager::create_mesh_set(), moab::SequenceManager::create_vertex(), moab::SequenceManager::delete_entities(), moab::Range::equal_range(), moab::SparseTag::find_entities_with_value(), moab::VarLenSparseTag::find_entities_with_value(), moab::RangeSeqIntersectIter::find_invalid_range(), moab::WriteVtk::gather_mesh(), moab::AEntityFactory::get_associated_meshsets(), moab::AEntityFactory::get_element(), moab::BitTag::get_entities_with_bits(), moab::SequenceManager::get_memory_use(), moab::TypeSequenceManager::get_memory_use(), moab::RangeSetIterator::get_next_by_dimension(), moab::RangeSetIterator::get_next_by_type(), moab::ParallelComm::get_remote_handles(), moab::BitTag::get_tagged(), moab::AEntityFactory::get_up_adjacency_elements(), moab::Core::handle_from_id(), moab::TypeSequenceManager::is_free_handle(), moab::TypeSequenceManager::last_free_handle(), moab::WriteGMV::local_write_mesh(), moab::Range::lower_bound(), main(), moab::Range::num_of_dimension(), moab::ReadNCDF::read_nodesets(), moab::WriteHDF5Parallel::remove_remote_entities(), moab::SequenceManager::sequence_start_handle(), moab::Range::subset_by_dimension(), moab::HigherOrderFactory::tag_for_deletion(), and moab::Range::upper_bound().

◆ cross()

static void moab::cross	(	double	result[3],
		const double	a[3],
		const double	b[3]
	)

static

Definition at line 930 of file BSPTree.cpp.

 {
  result[0] = a[1] * b[2] - a[2] * b[1];
  result[1] = a[2] * b[0] - a[0] * b[2];
  result[2] = a[0] * b[1] - a[1] * b[0];
 }

Referenced by moab::GeomUtil::box_hex_overlap(), moab::GeomUtil::box_linear_elem_overlap(), form_Q(), interior_point(), v_tri_scaled_jacobian(), and moab::BSPTreeBoxIter::volume().

◆ DeInitialize()

MB_EXPORT void moab::DeInitialize ( )

Definition at line 127 of file Factory.cpp.

 {
  // delete all instances of objects
  while( ComponentFactory::objects_in_use.size() )
  {
  UnknownInterface* iface = ComponentFactory::objects_in_use.front();
  ComponentFactory::objects_in_use.pop_front();
  if( iface ) delete iface;
  }
 }

References iface, moab::ComponentFactory::objects_in_use, and size.

◆ dot()

static double moab::dot	(	const double	a[3],
		const double	b[3]
	)

static

Definition at line 937 of file BSPTree.cpp.

 {
  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
 }

Referenced by moab::GeomUtil::box_hex_overlap(), moab::GeomUtil::box_linear_elem_overlap(), moab::GeomUtil::box_tet_overlap(), moab::GeomUtil::box_tet_overlap_edge(), moab::SmoothFace::ray_intersection_correct(), moab::BSPTree::Plane::set(), VerdictVector::vector_angle(), and moab::BSPTreeBoxIter::volume().

◆ ent_not_found()

static ErrorCode moab::ent_not_found	(	const std::string &	,
		EntityHandle
	)

inlinestatic

Definition at line 36 of file DenseTag.cpp.

 {
  // MB_ENTITY_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
 #if 0
  fprintf(
  stderr,
  "[Warning]: Invalid entity handle setting tag %s: %s %ld\n",
  name.c_str(),
  CN::EntityTypeName(TYPE_FROM_HANDLE(h)),
  (unsigned long)ID_FROM_HANDLE(h)
  );
 #endif
  
  return MB_ENTITY_NOT_FOUND;
 }

References moab::CN::EntityTypeName(), ID_FROM_HANDLE(), MB_ENTITY_NOT_FOUND, and TYPE_FROM_HANDLE().

Referenced by moab::DenseTag::get_array_private().

◆ error() [1/4]

static ErrorCode moab::error ( ErrorCode rval )

inlinestatic

Definition at line 127 of file DamselUtil.hpp.

 {
  return rval;
 }

◆ error() [2/4]

static ErrorCode moab::error ( ErrorCode rval )

inlinestatic

Definition at line 123 of file WriteHDF5.cpp.

 {
  return rval;
 }

◆ error() [3/4]

static ErrorCode moab::error ( ErrorCode rval )

inlinestatic

Definition at line 75 of file WriteHDF5Parallel.cpp.

 {
  return rval;
 }

◆ error() [4/4]

static ErrorCode moab::error ( ErrorCode val )

inlinestatic

Definition at line 23 of file ReorderTool.cpp.

 {
  return val;
 }

◆ fail()

void moab::fail	(	const char *	fmt,
			...
	)

Definition at line 14 of file TupleList.cpp.

 {
  va_list ap;
  va_start( ap, fmt );
  vfprintf( stderr, fmt, ap );
  va_end( ap );
  exit( 1 );
 }

Referenced by moab::TupleList::buffer::buffer_init_(), moab::TupleList::buffer::buffer_reserve_(), moab::gs_data::gs_data_op_many(), moab::gs_data::gs_data_op_vec(), moab::TupleList::initialize(), moab::ReadNCDF::load_file(), main(), moab::WriteNCDF::open_file(), moab::WriteSLAC::open_file(), moab::ReadNCDF::read_elements(), moab::ReadNCDF::read_exodus_header(), moab::ReadNCDF::read_nodes(), moab::ReadNCDF::read_polyhedra_faces(), moab::ReadNCDF::read_qa_string(), moab::ReadNCDF::read_tag_values(), moab::TupleList::resize(), moab::ReadNCDF::update(), moab::WriteNCDF::write_BCs(), moab::WriteNCDF::write_elementblocks(), moab::WriteNCDF::write_exodus_integer_variable(), moab::WriteNCDF::write_file(), moab::WriteSLAC::write_file(), moab::WriteSLAC::write_matsets(), moab::WriteSLAC::write_nodes(), moab::WriteNCDF::write_nodes(), moab::WriteNCDF::write_poly_faces(), and moab::WriteNCDF::write_qa_string().

◆ FID_FROM_HALFFACET()

EntityID moab::FID_FROM_HALFFACET ( HFacet handle )

inline

Definition at line 36 of file HalfFacetRep.cpp.

 {
  return ( handle & MB_ID_MASK );
 }

References MB_ID_MASK.

Referenced by moab::HalfFacetRep::fid_from_halfacet().

◆ find_map_values()

template<class Functor , class TagMap >

static void moab::find_map_values	(	Functor	compare,
		Range::const_iterator	lower,
		Range::const_iterator	upper,
		const TagMap &	tag_map,
		Range &	results
	)

inlinestatic

Definition at line 286 of file TagCompare.hpp.

 {
  Range::iterator insert = results.begin();
  for( ; lower != upper; ++lower )
  {
  typename TagMap::const_iterator i = tag_map.find( *lower );
  if( i != tag_map.end() && compare( i->second ) ) insert = results.insert( insert, *lower );
  }
 }

References moab::Range::begin(), and moab::Range::insert().

◆ find_map_values_equal()

template<class TagMap >

static void moab::find_map_values_equal	(	const TagInfo &	tag_info,
		const void *	value,
		int	size,
		Range::const_iterator	begin,
		Range::const_iterator	end,
		const TagMap &	tag_map,
		Range &	results
	)

inlinestatic

Find all entities for which a tag has a specific value

Parameters

IteratorType	: an iterator that has map behavior: the value of 'first' is the entity handle. the value of 'second' is a pointer to the tag data.
ContainerType	: std::vector<EntityHandle> or Range

Definition at line 376 of file TagCompare.hpp.

 {
  switch( tag_info.get_data_type() )
  {
  case MB_TYPE_INTEGER:
  if( size == sizeof( int ) )
  find_map_values< TagOneIntEqual, TagMap >( TagOneIntEqual( value ), begin, end, tag_map, results );
  else
  find_map_values< TagIntsEqual, TagMap >( TagIntsEqual( value, size ), begin, end, tag_map, results );
  break;
  
  case MB_TYPE_DOUBLE:
  if( size == sizeof( double ) )
  find_map_values< TagOneDoubleEqual, TagMap >( TagOneDoubleEqual( value ), begin, end, tag_map,
  results );
  else
  find_map_values< TagDoublesEqual, TagMap >( TagDoublesEqual( value, size ), begin, end, tag_map,
  results );
  break;
  
  case MB_TYPE_HANDLE:
  if( size == sizeof( EntityHandle ) )
  find_map_values< TagOneHandleEqual, TagMap >( TagOneHandleEqual( value ), begin, end, tag_map,
  results );
  else
  find_map_values< TagHandlesEqual, TagMap >( TagHandlesEqual( value, size ), begin, end, tag_map,
  results );
  break;
  
  default:
  find_map_values< TagBytesEqual, TagMap >( TagBytesEqual( value, size ), begin, end, tag_map, results );
  break;
  }
 }

References moab::TagInfo::get_data_type(), MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, and size.

Referenced by moab::SparseTag::find_entities_with_value().

◆ find_map_varlen_values_equal()

template<class TagMap >

static void moab::find_map_varlen_values_equal	(	const TagInfo &	tag_info,
		const void *	value,
		int	size,
		Range::const_iterator	begin,
		Range::const_iterator	end,
		const TagMap &	tag_map,
		Range &	results
	)

inlinestatic

Definition at line 417 of file TagCompare.hpp.

 {
  switch( tag_info.get_data_type() )
  {
  case MB_TYPE_INTEGER:
  find_map_values< TagVarIntsEqual, TagMap >( TagVarIntsEqual( value, size ), begin, end, tag_map, results );
  break;
  case MB_TYPE_DOUBLE:
  find_map_values< TagVarDoublesEqual, TagMap >( TagVarDoublesEqual( value, size ), begin, end, tag_map,
  results );
  break;
  case MB_TYPE_HANDLE:
  find_map_values< TagVarHandlesEqual, TagMap >( TagVarHandlesEqual( value, size ), begin, end, tag_map,
  results );
  break;
  default:
  find_map_values< TagVarBytesEqual, TagMap >( TagVarBytesEqual( value, size ), begin, end, tag_map,
  results );
  break;
  }
 }

References moab::TagInfo::get_data_type(), MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, and size.

Referenced by moab::VarLenSparseTag::find_entities_with_value().

◆ find_tag_values() [1/2]

template<class Functor , class IteratorType >

static void moab::find_tag_values	(	Functor	compare,
		IteratorType	begin,
		IteratorType	end,
		Range &	results
	)

inlinestatic

Definition at line 268 of file TagCompare.hpp.

 {
  Range::iterator insert = results.begin();
  for( IteratorType i = begin; i != end; ++i )
  if( compare( i->second ) ) insert = results.insert( insert, i->first );
 }

References moab::Range::begin(), and moab::Range::insert().

◆ find_tag_values() [2/2]

template<class Functor , class IteratorType >

static void moab::find_tag_values	(	Functor	compare,
		IteratorType	begin,
		IteratorType	end,
		std::vector< EntityHandle > &	results
	)

inlinestatic

Definition at line 276 of file TagCompare.hpp.

 {
  for( IteratorType i = begin; i != end; ++i )
  if( compare( i->second ) ) results.push_back( i->first );
 }

◆ find_tag_values_equal()

template<class IteratorType , class ContainerType >

static void moab::find_tag_values_equal	(	const TagInfo &	tag_info,
		const void *	value,
		int	size,
		IteratorType	begin,
		IteratorType	end,
		ContainerType &	results
	)

inlinestatic

Find all entities for which a tag has a specific value

Parameters

IteratorType	: an iterator that has map behavior: the value of 'first' is the entity handle. the value of 'second' is a pointer to the tag data.
ContainerType	: std::vector<EntityHandle> or Range

Definition at line 307 of file TagCompare.hpp.

 {
  switch( tag_info.get_data_type() )
  {
  case MB_TYPE_INTEGER:
  if( size == sizeof( int ) )
  find_tag_values< TagOneIntEqual, IteratorType >( TagOneIntEqual( value ), begin, end, results );
  else
  find_tag_values< TagIntsEqual, IteratorType >( TagIntsEqual( value, size ), begin, end, results );
  break;
  
  case MB_TYPE_DOUBLE:
  if( size == sizeof( double ) )
  find_tag_values< TagOneDoubleEqual, IteratorType >( TagOneDoubleEqual( value ), begin, end, results );
  else
  find_tag_values< TagDoublesEqual, IteratorType >( TagDoublesEqual( value, size ), begin, end, results );
  break;
  
  case MB_TYPE_HANDLE:
  if( size == sizeof( EntityHandle ) )
  find_tag_values< TagOneHandleEqual, IteratorType >( TagOneHandleEqual( value ), begin, end, results );
  else
  find_tag_values< TagHandlesEqual, IteratorType >( TagHandlesEqual( value, size ), begin, end, results );
  break;
  
  default:
  find_tag_values< TagBytesEqual, IteratorType >( TagBytesEqual( value, size ), begin, end, results );
  break;
  }
 }

References moab::TagInfo::get_data_type(), MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, and size.

Referenced by moab::DenseTag::find_entities_with_value(), and moab::SparseTag::find_entities_with_value().

◆ find_tag_varlen_values_equal()

template<class IteratorType , class ContainerType >

static void moab::find_tag_varlen_values_equal	(	const TagInfo &	tag_info,
		const void *	value,
		int	size,
		IteratorType	begin,
		IteratorType	end,
		ContainerType &	results
	)

inlinestatic

Definition at line 343 of file TagCompare.hpp.

 {
  switch( tag_info.get_data_type() )
  {
  case MB_TYPE_INTEGER:
  find_tag_values< TagVarIntsEqual, IteratorType >( TagVarIntsEqual( value, size ), begin, end, results );
  break;
  case MB_TYPE_DOUBLE:
  find_tag_values< TagVarDoublesEqual, IteratorType >( TagVarDoublesEqual( value, size ), begin, end,
  results );
  break;
  case MB_TYPE_HANDLE:
  find_tag_values< TagVarHandlesEqual, IteratorType >( TagVarHandlesEqual( value, size ), begin, end,
  results );
  break;
  default:
  find_tag_values< TagVarBytesEqual, IteratorType >( TagVarBytesEqual( value, size ), begin, end, results );
  break;
  }
 }

References moab::TagInfo::get_data_type(), MB_TYPE_DOUBLE, MB_TYPE_HANDLE, MB_TYPE_INTEGER, and size.

Referenced by moab::VarLenDenseTag::find_entities_with_value(), and moab::VarLenSparseTag::find_entities_with_value().

◆ FIRST_HANDLE()

EntityHandle moab::FIRST_HANDLE ( unsigned type )

inline

Definition at line 74 of file Internals.hpp.

 {
  return ( ( (EntityHandle)type ) << MB_ID_WIDTH ) | MB_START_ID;
 }

References MB_ID_WIDTH, and MB_START_ID.

Referenced by moab::MeshSet::FIRST_OF_DIM(), moab::MeshSet::get_entities_by_type(), moab::MeshSetSequence::get_parent_child_meshsets(), get_tagged(), moab::AEntityFactory::get_zero_to_n_elements(), and moab::MeshSet::num_entities_by_type().

◆ get_adjacencies_intersection() [1/2]

template<typename ITER >

static ErrorCode moab::get_adjacencies_intersection	(	Core *	mb,
		ITER	begin,
		ITER	end,
		const int	to_dimension,
		const bool	create_if_missing,
		Range &	adj_entities
	)

inlinestatic

Definition at line 1403 of file Core.cpp.

 {
  std::vector< EntityHandle > results;
  ErrorCode rval = moab::get_adjacencies_intersection( mb, begin, end, to_dimension, create_if_missing, results );MB_CHK_ERR( rval );
  
  if( adj_entities.empty() )
  {
  std::copy( results.begin(), results.end(), range_inserter( adj_entities ) );
  return MB_SUCCESS;
  }
  
  Range::iterator it = adj_entities.begin();
  while( it != adj_entities.end() )
  {
  if( std::find( results.begin(), results.end(), *it ) == results.end() )
  it = adj_entities.erase( it );
  else
  ++it;
  }
  return MB_SUCCESS;
 }

References moab::Range::begin(), moab::Range::empty(), moab::Range::end(), moab::Range::erase(), ErrorCode, get_adjacencies_intersection(), mb, MB_CHK_ERR, and MB_SUCCESS.

◆ get_adjacencies_intersection() [2/2]

template<typename ITER >

static ErrorCode moab::get_adjacencies_intersection	(	Core *	mb,
		ITER	begin,
		ITER	end,
		const int	to_dimension,
		const bool	create_if_missing,
		std::vector< EntityHandle > &	adj_entities
	)

inlinestatic

Definition at line 1317 of file Core.cpp.

 {
  const size_t SORT_THRESHOLD = 200;
  std::vector< EntityHandle > temp_vec;
  std::vector< EntityHandle >::iterator adj_it, w_it;
  ErrorCode result = MB_SUCCESS;
  
  if( begin == end )
  {
  adj_entities.clear(); // intersection
  return MB_SUCCESS;
  }
  
  // First iteration is a special case if input list is empty.
  // Rather than returning nothing (intersecting with empty
  // input list), we begin with the adjacencies for the first entity.
  if( adj_entities.empty() )
  {
  EntityType entity_type = TYPE_FROM_HANDLE( *begin );
  if( to_dimension == CN::Dimension( entity_type ) )
  adj_entities.push_back( *begin );
  else if( to_dimension == 0 && entity_type != MBPOLYHEDRON )
  {
  result = mb->get_connectivity( &( *begin ), 1, adj_entities );MB_CHK_ERR( result );
  }
  else
  {
  result = mb->a_entity_factory()->get_adjacencies( *begin, to_dimension, create_if_missing, adj_entities );MB_CHK_ERR( result );
  }
  ++begin;
  }
  
  for( ITER from_it = begin; from_it != end; ++from_it )
  {
  // running results kept in adj_entities; clear temp_vec, which is working space
  temp_vec.clear();
  
  // get the next set of adjacencies
  EntityType entity_type = TYPE_FROM_HANDLE( *from_it );
  if( to_dimension == CN::Dimension( entity_type ) )
  temp_vec.push_back( *from_it );
  else if( to_dimension == 0 && entity_type != MBPOLYHEDRON )
  {
  result = mb->get_connectivity( &( *from_it ), 1, temp_vec );MB_CHK_ERR( result );
  }
  else
  {
  result = mb->a_entity_factory()->get_adjacencies( *from_it, to_dimension, create_if_missing, temp_vec );MB_CHK_ERR( result );
  }
  
  // otherwise intersect with the current set of results
  w_it = adj_it = adj_entities.begin();
  if( temp_vec.size() * adj_entities.size() < SORT_THRESHOLD )
  {
  for( ; adj_it != adj_entities.end(); ++adj_it )
  if( std::find( temp_vec.begin(), temp_vec.end(), *adj_it ) != temp_vec.end() )
  {
  *w_it = *adj_it;
  ++w_it;
  }
  }
  else
  {
  std::sort( temp_vec.begin(), temp_vec.end() );
  for( ; adj_it != adj_entities.end(); ++adj_it )
  if( std::binary_search( temp_vec.begin(), temp_vec.end(), *adj_it ) )
  {
  *w_it = *adj_it;
  ++w_it;
  }
  }
  adj_entities.erase( w_it, adj_entities.end() );
  
  // we're intersecting, so if there are no more results, we're done
  if( adj_entities.empty() ) break;
  }
  
  return MB_SUCCESS;
 }

References moab::CN::Dimension(), ErrorCode, mb, MB_CHK_ERR, MB_SUCCESS, MBPOLYHEDRON, and TYPE_FROM_HANDLE().

Referenced by moab::Core::get_adjacencies(), and get_adjacencies_intersection().

◆ get_adjacencies_union()

template<typename ITER >

static ErrorCode moab::get_adjacencies_union	(	Core *	gMB,
		ITER	begin,
		ITER	end,
		int	to_dimension,
		bool	create_if_missing,
		Range &	adj_entities
	)

inlinestatic

Definition at line 1243 of file Core.cpp.

 {
  const size_t DEFAULT_MAX_BLOCKS_SIZE = 4000;
  const size_t MAX_OUTER_ITERATIONS = 100;
  
  std::vector< EntityHandle > temp_vec, storage;
  std::vector< EntityHandle >::const_iterator ti;
  ErrorCode result = MB_SUCCESS, tmp_result;
  ITER i = begin;
  Range::iterator ins;
  const EntityHandle* conn;
  int conn_len;
  
  // Just copy any vertices from the input range into the output
  size_t remaining = end - begin;
  assert( begin + remaining == end );
  
  // How many entities to work with at once? 2000 or so shouldn't require
  // too much memory, but don't iterate in outer loop more than a
  // 1000 times (make it bigger if many input entiites.)
  const size_t block_size = std::max( DEFAULT_MAX_BLOCKS_SIZE, remaining / MAX_OUTER_ITERATIONS );
  while( remaining > 0 )
  {
  const size_t count = remaining > block_size ? block_size : remaining;
  remaining -= count;
  temp_vec.clear();
  for( size_t j = 0; j < count; ++i, ++j )
  {
  if( CN::Dimension( TYPE_FROM_HANDLE( *i ) ) == to_dimension )
  {
  temp_vec.push_back( *i );
  }
  else if( to_dimension == 0 && TYPE_FROM_HANDLE( *i ) != MBPOLYHEDRON )
  {
  tmp_result = gMB->get_connectivity( *i, conn, conn_len, false, &storage );
  if( MB_SUCCESS != tmp_result )
  {
  result = tmp_result;
  continue;
  }
  temp_vec.insert( temp_vec.end(), conn, conn + conn_len );
  }
  else
  {
  tmp_result = gMB->a_entity_factory()->get_adjacencies( *i, to_dimension, create_if_missing, temp_vec );
  if( MB_SUCCESS != tmp_result )
  {
  result = tmp_result;
  continue;
  }
  }
  }
  
  std::sort( temp_vec.begin(), temp_vec.end() );
  ins = adj_entities.begin();
  ti = temp_vec.begin();
  while( ti != temp_vec.end() )
  {
  EntityHandle first = *ti;
  EntityHandle second = *ti;
  for( ++ti; ti != temp_vec.end() && ( *ti - second <= 1 ); ++ti )
  second = *ti;
  ins = adj_entities.insert( ins, first, second );
  }
  }
  return result;
 }

References moab::Range::begin(), moab::CN::Dimension(), ErrorCode, moab::GeomUtil::first(), gMB, moab::Range::insert(), MB_SUCCESS, MBPOLYHEDRON, and TYPE_FROM_HANDLE().

Referenced by moab::Core::get_adjacencies().

◆ get_bit()

static bool moab::get_bit	(	int	position,
		const unsigned char *	bytes
	)

static

Definition at line 746 of file WriteHDF5Parallel.cpp.

 {
  int byte = position / 8;
  int bit = position % 8;
  return 0 != ( bytes[byte] & ( ( (unsigned char)1 ) << bit ) );
 }

Referenced by moab::WriteHDF5Parallel::create_tag_tables().

◆ get_id_type()

static hid_t moab::get_id_type ( )

static

Definition at line 95 of file WriteHDF5.cpp.

 {
  if( 8 == sizeof( WriteHDF5::wid_t ) )
  {
  if( 8 == sizeof( long ) )
  return H5T_NATIVE_ULONG;
  else
  return H5T_NATIVE_UINT64;
  }
  else if( 4 == sizeof( WriteHDF5::wid_t ) )
  {
  if( 4 == sizeof( int ) )
  return H5T_NATIVE_UINT;
  else
  return H5T_NATIVE_UINT32;
  }
  else
  {
  assert( 0 );
  return (hid_t)-1;
  }
 }

◆ get_mesh_set() [1/2]

static const MeshSet* moab::get_mesh_set	(	const SequenceManager *	sm,
		EntityHandle	h
	)

inlinestatic

Definition at line 155 of file Core.cpp.

 {
  const EntitySequence* seq;
  if( MBENTITYSET != TYPE_FROM_HANDLE( h ) || MB_SUCCESS != sm->find( h, seq ) ) return 0;
  return reinterpret_cast< const MeshSetSequence* >( seq )->get_set( h );
 }

References moab::SequenceManager::find(), MB_SUCCESS, MBENTITYSET, and TYPE_FROM_HANDLE().

Referenced by moab::Core::add_child_meshset(), moab::Core::add_child_meshsets(), moab::Core::add_entities(), moab::Core::add_parent_child(), moab::Core::add_parent_meshset(), moab::Core::add_parent_meshsets(), moab::Core::clear_meshset(), moab::Core::contains_entities(), moab::Core::delete_entities(), moab::Core::get_meshset_options(), moab::Core::intersect_meshset(), moab::Core::remove_child_meshset(), moab::Core::remove_entities(), moab::Core::remove_parent_child(), moab::Core::remove_parent_meshset(), moab::Core::replace_entities(), moab::Core::set_meshset_options(), moab::Core::subtract_meshset(), and moab::Core::unite_meshset().

◆ get_mesh_set() [2/2]

static MeshSet* moab::get_mesh_set	(	SequenceManager *	sm,
		EntityHandle	h
	)

inlinestatic

Definition at line 162 of file Core.cpp.

 {
  EntitySequence* seq;
  if( MBENTITYSET != TYPE_FROM_HANDLE( h ) || MB_SUCCESS != sm->find( h, seq ) ) return 0;
  return reinterpret_cast< MeshSetSequence* >( seq )->get_set( h );
 }

References moab::SequenceManager::find(), MB_SUCCESS, MBENTITYSET, and TYPE_FROM_HANDLE().

◆ get_tagged() [1/9]

template<class Container >

static ErrorCode moab::get_tagged	(	const SequenceManager *	seqman,
		int	mySequenceArray,
		Container &	entities,
		EntityType	type,
		const Range *	intersect
	)

inlinestatic

Definition at line 518 of file VarLenDenseTag.cpp.

 {
  if( !intersect )
  return get_tagged< Container >( seqman, mySequenceArray, type, entities );
  else if( MBMAXTYPE == type )
  return get_tagged< Container >( seqman, mySequenceArray, intersect->begin(), intersect->end(), entities );
  else
  {
  std::pair< Range::iterator, Range::iterator > r = intersect->equal_range( type );
  return get_tagged< Container >( seqman, mySequenceArray, r.first, r.second, entities );
  }
 }

References entities, intersect(), and MBMAXTYPE.

◆ get_tagged() [2/9]

template<class Container >

static ErrorCode moab::get_tagged	(	const SequenceManager *	seqman,
		int	mySequenceArray,
		EntityType	type,
		Container &	entities
	)

inlinestatic

Definition at line 461 of file VarLenDenseTag.cpp.

 {
  typename Container::iterator hint = entities.begin();
  std::pair< EntityType, EntityType > range = type_range( type );
  TypeSequenceManager::const_iterator i;
  const VarLenTag *data, *iter, *end;
  for( EntityType t = range.first; t != range.second; ++t )
  {
  const TypeSequenceManager& map = seqman->entity_map( t );
  for( i = map.begin(); i != map.end(); ++i )
  {
  data = reinterpret_cast< const VarLenTag* >( ( *i )->data()->get_tag_data( mySequenceArray ) );
  if( !data ) continue;
  end = data + ( *i )->end_handle() - ( *i )->data()->start_handle() + 1;
  iter = data + ( *i )->start_handle() - ( *i )->data()->start_handle();
  EntityHandle handle = ( *i )->start_handle();
  for( ; iter != end; ++iter, ++handle )
  if( iter->size() ) hint = entities.insert( hint, handle );
  }
  }
  
  return MB_SUCCESS;
 }

References moab::TypeSequenceManager::begin(), moab::VarLenTag::data(), moab::TypeSequenceManager::end(), entities, moab::SequenceManager::entity_map(), MB_SUCCESS, moab::VarLenTag::size(), t, and type_range().

◆ get_tagged() [3/9]

template<class Container >

static ErrorCode moab::get_tagged	(	const SequenceManager *	seqman,
		int	mySequenceArray,
		Range::const_iterator	begin,
		Range::const_iterator	end,
		Container &	entities
	)

inlinestatic

Definition at line 489 of file VarLenDenseTag.cpp.

 {
  typename Container::iterator hint = entities.begin();
  RangeSeqIntersectIter iter( const_cast< SequenceManager* >( seqman ) );
  ErrorCode rval = iter.init( begin, end );
  const VarLenTag* data;
  for( ; MB_SUCCESS == rval; rval = iter.step() )
  {
  data = reinterpret_cast< const VarLenTag* >( iter.get_sequence()->data()->get_tag_data( mySequenceArray ) );
  if( !data ) continue;
  
  data += iter.get_start_handle() - iter.get_sequence()->data()->start_handle();
  size_t count = iter.get_end_handle() - iter.get_start_handle() + 1;
  for( size_t i = 0; i < count; ++i )
  if( data[i].size() ) hint = entities.insert( hint, iter.get_start_handle() + i );
  rval = iter.step();
  }
  
  if( MB_FAILURE != rval ) // We get MB_FAILURE at iterator end
  return rval;
  
  return MB_SUCCESS;
 }

References moab::EntitySequence::data(), entities, ErrorCode, moab::RangeSeqIntersectIter::get_end_handle(), moab::RangeSeqIntersectIter::get_sequence(), moab::RangeSeqIntersectIter::get_start_handle(), moab::SequenceData::get_tag_data(), moab::RangeSeqIntersectIter::init(), MB_SUCCESS, size, moab::SequenceData::start_handle(), and moab::RangeSeqIntersectIter::step().

◆ get_tagged() [4/9]

template<class Container >

static void moab::get_tagged	(	const SparseTag::MapType &	mData,
		Container &	entities,
		EntityType	type,
		const Range *	intersect
	)

inlinestatic

Definition at line 424 of file SparseTag.cpp.

 {
  if( !intersect )
  get_tagged< Container >( mData, type, entities );
  else if( MBMAXTYPE == type )
  get_tagged< Container >( mData, intersect->begin(), intersect->end(), entities );
  else
  {
  std::pair< Range::iterator, Range::iterator > r = intersect->equal_range( type );
  get_tagged< Container >( mData, r.first, r.second, entities );
  }
 }

References entities, intersect(), and MBMAXTYPE.

◆ get_tagged() [5/9]

template<class Container >

static void moab::get_tagged	(	const SparseTag::MapType &	mData,
		EntityType	type,
		Container &	output_range
	)

inlinestatic

Definition at line 389 of file SparseTag.cpp.

 {
  SparseTag::MapType::const_iterator iter;
  typename Container::iterator hint = output_range.begin();
  if( MBMAXTYPE == type )
  {
  for( iter = mData.begin(); iter != mData.end(); ++iter )
  hint = output_range.insert( hint, iter->first );
  }
  else
  {
 #ifdef MOAB_HAVE_UNORDERED_MAP
  for( iter = mData.begin(); iter != mData.end(); ++iter )
  if( TYPE_FROM_HANDLE( iter->first ) == type ) hint = output_range.insert( hint, iter->first );
 #else
  iter = mData.lower_bound( FIRST_HANDLE( type ) );
  SparseTag::MapType::const_iterator end = mData.lower_bound( LAST_HANDLE( type ) + 1 );
  for( ; iter != end; ++iter )
  hint = output_range.insert( hint, iter->first );
 #endif
  }
 }

References FIRST_HANDLE(), LAST_HANDLE(), MBMAXTYPE, and TYPE_FROM_HANDLE().

Referenced by moab::SparseTag::get_tagged_entities(), moab::VarLenDenseTag::get_tagged_entities(), moab::VarLenSparseTag::get_tagged_entities(), moab::SparseTag::num_tagged_entities(), moab::VarLenDenseTag::num_tagged_entities(), and moab::VarLenSparseTag::num_tagged_entities().

◆ get_tagged() [6/9]

template<class Container >

static void moab::get_tagged	(	const SparseTag::MapType &	mData,
		Range::const_iterator	begin,
		Range::const_iterator	end,
		Container &	output_range
	)

inlinestatic

Definition at line 413 of file SparseTag.cpp.

 {
  typename Container::iterator hint = output_range.begin();
  for( Range::const_iterator i = begin; i != end; ++i )
  if( mData.find( *i ) != mData.end() ) hint = output_range.insert( hint, *i );
 }

◆ get_tagged() [7/9]

template<class Container >

static void moab::get_tagged	(	const VarLenSparseTag::MapType &	mData,
		Container &	entities,
		EntityType	type,
		const Range *	intersect
	)

inlinestatic

Definition at line 341 of file VarLenSparseTag.cpp.

 {
  if( !intersect )
  get_tagged< Container >( mData, type, entities );
  else if( MBMAXTYPE == type )
  get_tagged< Container >( mData, intersect->begin(), intersect->end(), entities );
  else
  {
  std::pair< Range::iterator, Range::iterator > r = intersect->equal_range( type );
  get_tagged< Container >( mData, r.first, r.second, entities );
  }
 }

References entities, intersect(), and MBMAXTYPE.

◆ get_tagged() [8/9]

template<class Container >

static void moab::get_tagged	(	const VarLenSparseTag::MapType &	mData,
		EntityType	type,
		Container &	output_range
	)

inlinestatic

Definition at line 306 of file VarLenSparseTag.cpp.

 {
  VarLenSparseTag::MapType::const_iterator iter;
  typename Container::iterator hint = output_range.begin();
  if( MBMAXTYPE == type )
  {
  for( iter = mData.begin(); iter != mData.end(); ++iter )
  hint = output_range.insert( hint, iter->first );
  }
  else
  {
 #ifdef MOAB_HAVE_UNORDERED_MAP
  for( iter = mData.begin(); iter != mData.end(); ++iter )
  if( TYPE_FROM_HANDLE( iter->first ) == type ) hint = output_range.insert( hint, iter->first );
 #else
  iter = mData.lower_bound( FIRST_HANDLE( type ) );
  VarLenSparseTag::MapType::const_iterator end = mData.lower_bound( LAST_HANDLE( type ) + 1 );
  for( ; iter != end; ++iter )
  hint = output_range.insert( hint, iter->first );
 #endif
  }
 }

References FIRST_HANDLE(), LAST_HANDLE(), MBMAXTYPE, and TYPE_FROM_HANDLE().

◆ get_tagged() [9/9]

template<class Container >

static void moab::get_tagged	(	const VarLenSparseTag::MapType &	mData,
		Range::const_iterator	begin,
		Range::const_iterator	end,
		Container &	output_range
	)

inlinestatic

Definition at line 330 of file VarLenSparseTag.cpp.

 {
  typename Container::iterator hint = output_range.begin();
  for( Range::const_iterator i = begin; i != end; ++i )
  if( mData.find( *i ) != mData.end() ) hint = output_range.insert( hint, *i );
 }

◆ GetInterface()

MB_EXPORT void moab::GetInterface	(	MBuuid &	interface_requested,
		UnknownInterface **	iface
	)

Definition at line 114 of file Factory.cpp.

 {
  // create an instance of our component factory
  ComponentFactory server;
  // ask the component factory to give us the interface we want
  server.QueryInterface( interface_requested, iface );
  // if the interface existed, put it on our list
  if( iface && *iface ) ComponentFactory::objects_in_use.push_front( *iface );
 }

References iface, moab::ComponentFactory::objects_in_use, and moab::ComponentFactory::QueryInterface().

◆ handle_hdf5_error() [1/2]

static herr_t moab::handle_hdf5_error ( void * data )

static

Definition at line 103 of file ReadHDF5.cpp.

 {
  ReadHDF5::HDF5ErrorHandler* h = reinterpret_cast< ReadHDF5::HDF5ErrorHandler* >( data );
  herr_t result = 0;
  if( h->func ) result = ( *h->func )( h->data );MB_CHK_ERR_CONT( MB_FAILURE );
  return result;
 }

References moab::ReadHDF5::HDF5ErrorHandler::data, moab::ReadHDF5::HDF5ErrorHandler::func, and MB_CHK_ERR_CONT.

Referenced by moab::ReadHDF5::clean_up_read(), moab::WriteHDF5::init(), moab::ReadHDF5::set_up_read(), and moab::WriteHDF5::write_finished().

◆ handle_hdf5_error() [2/2]

static herr_t moab::handle_hdf5_error ( void * data )

static

Definition at line 143 of file WriteHDF5.cpp.

 {
  WriteHDF5::HDF5ErrorHandler* h = reinterpret_cast< WriteHDF5::HDF5ErrorHandler* >( data );
  herr_t result = 0;
  if( h->func ) result = ( *h->func )( h->data );
  error( MB_FAILURE );
  return result;
 }

References moab::WriteHDF5::HDF5ErrorHandler::data, error(), and moab::WriteHDF5::HDF5ErrorHandler::func.

◆ HDF5_can_append_hyperslabs()

bool moab::HDF5_can_append_hyperslabs ( )

Definition at line 8 of file HDF5Common.cpp.

 {
  hsize_t dim = 100;
  hid_t space = H5Screate_simple( 1, &dim, NULL );
  bool result = false;
  
  HDF5_Error_Func_Type fptr = 0;
  void* fdata = 0;
 #if defined( H5Eget_auto_vers ) && H5Eget_auto_vers > 1
  if( 0 <= H5Eget_auto( H5E_DEFAULT, &fptr, &fdata ) ) H5Eset_auto( H5E_DEFAULT, 0, 0 );
 #else
  if( 0 <= H5Eget_auto( &fptr, &fdata ) ) H5Eset_auto( 0, 0 );
 #endif
  
  hsize_t start = 1, count = 5;
  H5Sselect_hyperslab( space, H5S_SELECT_SET, &start, 0, &count, 0 );
  start = 20;
  if( 0 <= H5Sselect_hyperslab( space, H5S_SELECT_APPEND, &start, 0, &count, 0 ) ) result = true;
  
  if( fptr )
  {
 #if defined( H5Eset_auto_vers ) && H5Eset_auto_vers > 1
  H5Eset_auto( H5E_DEFAULT, fptr, fdata );
 #else
  H5Eset_auto( fptr, fdata );
 #endif
  }
  H5Sclose( space );
  
  return result;
 }

References dim.

Referenced by moab::WriteHDF5Parallel::parallel_create_file(), and moab::ReadHDF5::set_up_read().

◆ ID_FROM_HANDLE()

EntityID moab::ID_FROM_HANDLE ( EntityHandle handle )

inline

Get the entity id out of the handle.

Definition at line 85 of file Internals.hpp.

 {
  return ( handle & MB_ID_MASK );
 }

References MB_ID_MASK.

◆ insert_in_vector()

static MeshSet::Count moab::insert_in_vector	(	const MeshSet::Count	count,
		MeshSet::CompactList &	list,
		const EntityHandle	h,
		int &	result
	)

inlinestatic

Insert into parent/child list.

Definition at line 103 of file MeshSet.cpp.

 {
  switch( count )
  {
  case MeshSet::ZERO:
  list.hnd[0] = h;
  result = true;
  return MeshSet::ONE;
  case MeshSet::ONE:
  if( list.hnd[0] == h )
  {
  result = false;
  return MeshSet::ONE;
  }
  else
  {
  result = true;
  list.hnd[1] = h;
  return MeshSet::TWO;
  }
  case MeshSet::TWO:
  if( list.hnd[0] == h || list.hnd[1] == h )
  {
  result = false;
  return MeshSet::TWO;
  }
  else
  {
  EntityHandle* ptr = (EntityHandle*)malloc( 3 * sizeof( EntityHandle ) );
  ptr[0] = list.hnd[0];
  ptr[1] = list.hnd[1];
  ptr[2] = h;
  list.ptr[0] = ptr;
  list.ptr[1] = ptr + 3;
  result = true;
  return MeshSet::MANY;
  }
  case MeshSet::MANY:
  if( std::find( list.ptr[0], list.ptr[1], h ) != list.ptr[1] )
  {
  result = false;
  }
  else
  {
  int size = list.ptr[1] - list.ptr[0];
  list.ptr[0] = (EntityHandle*)realloc( list.ptr[0], ( size + 1 ) * sizeof( EntityHandle ) );
  list.ptr[0][size] = h;
  list.ptr[1] = list.ptr[0] + size + 1;
  result = true;
  }
  return MeshSet::MANY;
  }
  
  return MeshSet::ZERO;
 }

References moab::MeshSet::CompactList::hnd, moab::MeshSet::MANY, moab::MeshSet::ONE, moab::MeshSet::CompactList::ptr, size, moab::MeshSet::TWO, and moab::MeshSet::ZERO.

Referenced by moab::MeshSet::add_child(), and moab::MeshSet::add_parent().

◆ INT_IO_ERROR()

static void moab::INT_IO_ERROR	(	bool	condition,
		unsigned	line
	)

inlinestatic

Definition at line 114 of file Tqdcfr.cpp.

 {
  if( !condition )
  {
  char buffer[] = __FILE__ " ";
  sprintf( buffer, "%s:%u", __FILE__, line );
  fflush( stderr );
  perror( buffer );
  abort();
  }
 }

References buffer.

◆ intersect() [1/2]

static void moab::intersect	(	const mhdf_EntDesc &	group,
		const Range &	range,
		Range &	result
	)

static

Definition at line 125 of file ReadHDF5.cpp.

 {
  Range::const_iterator s, e;
  s = Range::lower_bound( range.begin(), range.end(), group.start_id );
  e = Range::lower_bound( s, range.end(), group.start_id + group.count );
  result.merge( s, e );
 }

References moab::Range::begin(), mhdf_EntDesc::count, moab::Range::end(), moab::Range::lower_bound(), moab::Range::merge(), and mhdf_EntDesc::start_id.

◆ intersect() [2/2]

Range moab::intersect	(	const Range &	range1,
		const Range &	range2
	)

intersect two ranges, placing the results in the return range

Definition at line 626 of file Range.cpp.

 {
  Range::const_pair_iterator r_it[2] = { range1.const_pair_begin(), range2.const_pair_begin() };
  EntityHandle low_it, high_it;
  
  Range lhs;
  Range::iterator hint = lhs.begin();
  
  // terminate the while loop when at least one "start" iterator is at the
  // end of the list
  while( r_it[0] != range1.end() && r_it[1] != range2.end() )
  {
  
  if( r_it[0]->second < r_it[1]->first )
  // 1st subrange completely below 2nd subrange
  ++r_it[0];
  else if( r_it[1]->second < r_it[0]->first )
  // 2nd subrange completely below 1st subrange
  ++r_it[1];
  
  else
  {
  // else ranges overlap; first find greater start and lesser end
  low_it = MAX( r_it[0]->first, r_it[1]->first );
  high_it = MIN( r_it[0]->second, r_it[1]->second );
  
  // insert into result
  hint = lhs.insert( hint, low_it, high_it );
  
  // now find bounds of this insertion and increment corresponding iterator
  if( high_it == r_it[0]->second ) ++r_it[0];
  if( high_it == r_it[1]->second ) ++r_it[1];
  }
  }
  
  return lhs;
 }

◆ intersect_segment_and_plane_slice()

bool moab::intersect_segment_and_plane_slice	(	CartVect &	from,
		CartVect &	to,
		CartVect &	p1,
		CartVect &	p2,
		CartVect &	,
		CartVect &	normPlane,
		CartVect &	intx_point,
		double &	parPos
	)

Definition at line 50 of file FBEngine.cpp.

 {
  //
  // plane eq is normPlane % r + d = 0, or normPlane % r - normPlane%p1 = 0
  double dd = -normPlane % p1;
  double valFrom = normPlane % from + dd;
  double valTo = normPlane % to + dd;
  
  if( fabs( valFrom ) < tolerance_segment )
  {
  intx_point = from;
  parPos = 0.;
  double proj1 = ( intx_point - p1 ) % ( p2 - p1 );
  double proj2 = ( intx_point - p2 ) % ( p1 - p2 );
  if( proj1 <= -tolerance_segment || proj2 <= -tolerance_segment ) return false;
  if( debug_splits ) std::cout << "intx : " << intx_point << "\n";
  return true;
  }
  if( fabs( valTo ) < tolerance_segment )
  {
  intx_point = to;
  parPos = 1;
  double proj1 = ( intx_point - p1 ) % ( p2 - p1 );
  double proj2 = ( intx_point - p2 ) % ( p1 - p2 );
  if( proj1 <= -tolerance_segment || proj2 <= -tolerance_segment ) return false;
  if( debug_splits ) std::cout << "intx : " << intx_point << "\n";
  return true;
  }
  if( valFrom * valTo > 0 ) return false; // no intersection, although it could be very close
  // else, it could intersect the plane; check for the slice too.
  parPos = valFrom / ( valFrom - valTo ); // this is 0 for valFrom 0, 1 for valTo 0
  intx_point = from + ( to - from ) * parPos;
  // now check if the intx_point is indeed between p1 and p2 in the slice.
  double proj1 = ( intx_point - p1 ) % ( p2 - p1 );
  double proj2 = ( intx_point - p2 ) % ( p1 - p2 );
  if( proj1 <= -tolerance_segment || proj2 <= -tolerance_segment ) return false;
  
  if( debug_splits ) std::cout << "intx : " << intx_point << "\n";
  return true;
 }

References debug_splits, and tolerance_segment.

Referenced by moab::FBEngine::compute_intersection_points(), and moab::FBEngine::split_surface_with_direction().

◆ IntPairComparator()

bool moab::IntPairComparator	(	const std::pair< int, int > &	a,
		const std::pair< int, int > &	b
	)

Definition at line 689 of file TempestRemapper.cpp.

 {
  if( a.first == b.first )
  return a.second < b.second;
  else
  return a.first < b.first;
 }

Referenced by moab::TempestRemapper::convert_overlap_mesh_sorted_by_source().

◆ is_sorted_unique()

bool moab::is_sorted_unique ( std::vector< unsigned > & v )

Definition at line 4613 of file ParallelComm.cpp.

 {
  for( size_t i = 1; i < v.size(); i++ )
  if( v[i - 1] >= v[i] ) return false;
  return true;
 }

Referenced by moab::ParallelComm::resolve_shared_sets().

◆ is_zero_bytes()

static bool moab::is_zero_bytes	(	const void *	mem,
		size_t	size
	)

static

Definition at line 2266 of file Core.cpp.

 {
  const char* iter = reinterpret_cast< const char* >( mem );
  const char* const end = iter + size;
  for( ; iter != end; ++iter )
  if( *iter ) return false;
  return true;
 }

References size.

Referenced by moab::Core::tag_get_handle().

◆ LAND()

template<class T >

T moab::LAND	(	const T &	arg1,
		const T &	arg2
	)

Definition at line 3807 of file ParallelComm.cpp.

 {
  return arg1 && arg2;
 }

◆ LAST_HANDLE()

EntityHandle moab::LAST_HANDLE ( unsigned type )

inline

Definition at line 79 of file Internals.hpp.

 {
  return ( (EntityHandle)( type + 1 ) << MB_ID_WIDTH ) - 1;
 }

References MB_ID_WIDTH.

Referenced by moab::MeshSet::get_entities_by_type(), moab::RangeSetIterator::get_next_by_dimension(), moab::RangeSetIterator::get_next_by_type(), moab::MeshSet::get_non_set_entities(), get_tagged(), moab::AEntityFactory::get_zero_to_n_elements(), moab::MeshSet::LAST_OF_DIM(), and moab::MeshSet::num_entities_by_type().

◆ LID_FROM_HALFFACET()

int moab::LID_FROM_HALFFACET ( HFacet handle )

inline

Definition at line 40 of file HalfFacetRep.cpp.

 {
  return static_cast< int >( handle >> MB_ID_WIDTH );
 }

References MB_ID_WIDTH.

Referenced by moab::HalfFacetRep::lid_from_halffacet().

◆ local_condense()

static void moab::local_condense	(	realType *	u,
		int	op,
		const sint *	cm
	)

static

Definition at line 128 of file gs.cpp.

 {
  switch( op )
  {
  case GS_OP_ADD:
  LOOP( DO_ADD );
  break;
  case GS_OP_MUL:
  LOOP( DO_MUL );
  break;
  case GS_OP_MIN:
  LOOP( DO_MIN );
  break;
  case GS_OP_MAX:
  LOOP( DO_MAX );
  break;
  case GS_OP_BPR:
  LOOP( DO_BPR );
  break;
  }
 }

References DO_ADD, DO_BPR, DO_MAX, DO_MIN, DO_MUL, GS_OP_ADD, GS_OP_BPR, GS_OP_MAX, GS_OP_MIN, GS_OP_MUL, and LOOP.

Referenced by moab::gs_data::gs_data_op(), and moab::gs_data::gs_data_op_many().

◆ local_condense_vec()

static void moab::local_condense_vec	(	realType *	u,
		uint	n,
		int	op,
		const sint *	cm
	)

static

Definition at line 177 of file gs.cpp.

 {
  switch( op )
  {
  case GS_OP_ADD:
  LOOP( DO_ADD );
  break;
  case GS_OP_MUL:
  LOOP( DO_MUL );
  break;
  case GS_OP_MIN:
  LOOP( DO_MIN );
  break;
  case GS_OP_MAX:
  LOOP( DO_MAX );
  break;
  case GS_OP_BPR:
  LOOP( DO_BPR );
  break;
  }
 }

References DO_ADD, DO_BPR, DO_MAX, DO_MIN, DO_MUL, GS_OP_ADD, GS_OP_BPR, GS_OP_MAX, GS_OP_MIN, GS_OP_MUL, and LOOP.

Referenced by moab::gs_data::gs_data_op_vec().

◆ local_uncondense()

static void moab::local_uncondense	(	realType *	u,
		const sint *	cm
	)

static

Definition at line 150 of file gs.cpp.

 {
  LOOP( DO_SET );
 }

References DO_SET, and LOOP.

Referenced by moab::gs_data::gs_data_op(), and moab::gs_data::gs_data_op_many().

◆ local_uncondense_vec()

static void moab::local_uncondense_vec	(	realType *	u,
		uint	n,
		const sint *	cm
	)

static

Definition at line 199 of file gs.cpp.

 {
  LOOP( DO_SET );
 }

References DO_SET, and LOOP.

Referenced by moab::gs_data::gs_data_op_vec().

◆ LOR()

template<class T >

T moab::LOR	(	const T &	arg1,
		const T &	arg2
	)

Definition at line 3812 of file ParallelComm.cpp.

 {
  return arg1 || arg2;
 }

◆ LXOR()

template<class T >

T moab::LXOR	(	const T &	arg1,
		const T &	arg2
	)

Definition at line 3817 of file ParallelComm.cpp.

 {
  return ( ( arg1 && !arg2 ) || ( !arg1 && arg2 ) );
 }

◆ MAX()

template<class T >

T moab::MAX	(	const T &	arg1,
		const T &	arg2
	)

Definition at line 3822 of file ParallelComm.cpp.

 {
  return ( arg1 > arg2 ? arg1 : arg2 );
 }

Referenced by moab::Tqdcfr::check_contiguous(), and moab::Tqdcfr::read_nodes().

◆ MBError()

ErrorCode moab::MBError	(	int	line,
		const char *	func,
		const char *	file,
		const char *	dir,
		ErrorCode	err_code,
		const char *	err_msg,
		ErrorType	err_type
	)

Routine that is called to create a new error or handle an existing one.

Definition at line 96 of file ErrorHandler.cpp.

 {
  // When this routine is called to handle an existing error (instead of creating a new one),
  // we need to check if the returned non-success result from a function might be a non-error
  // condition. If no last error message was ever set, just return the given error code.
  if( MB_ERROR_TYPE_EXISTING == err_type && "No error" == lastError ) return err_code;
  
  MBTraceBackErrorHandler( line, func, file, dir, err_msg, err_type );
  
 #ifdef MOAB_HAVE_MPI
  // If this is called from the main() routine we call MPI_Abort() to allow
  // the parallel program to be properly shutdown
  if( strncmp( func, "main", 4 ) == 0 ) MPI_Abort( MPI_COMM_WORLD, err_code );
 #endif
  
  return err_code;
 }

References lastError, MB_ERROR_TYPE_EXISTING, and MBTraceBackErrorHandler().

◆ MBErrorHandler_Finalize()

void moab::MBErrorHandler_Finalize ( )

Finalize MOAB error handler (e.g. delete the utility object for printing error output)

Examples: CrystalRouterExample.cpp, ErrorHandlingSimulation.cpp, TestErrorHandling.cpp, and TestErrorHandlingPar.cpp.

Definition at line 40 of file ErrorHandler.cpp.

 {
  if( NULL != errorOutput )
  {
  delete errorOutput;
  errorOutput = NULL;
  }
 }

References errorOutput.

Referenced by moab::Core::deinitialize(), and main().

◆ MBErrorHandler_GetLastError()

void moab::MBErrorHandler_GetLastError ( std::string & error )

Get information about the last error.

Definition at line 54 of file ErrorHandler.cpp.

 {
  error = lastError;
 }

References error(), and lastError.

Referenced by moab::Core::get_last_error().

◆ MBErrorHandler_Init()

void moab::MBErrorHandler_Init ( )

Initialize MOAB error handler (e.g. create a utility object for printing error output)

Examples: CrystalRouterExample.cpp, ErrorHandlingSimulation.cpp, TestErrorHandling.cpp, and TestErrorHandlingPar.cpp.

Definition at line 30 of file ErrorHandler.cpp.

 {
  if( NULL == errorOutput )
  {
  errorOutput = new( std::nothrow ) ErrorOutput( stderr );
  assert( NULL != errorOutput );
  errorOutput->use_world_rank();
  }
 }

References errorOutput, and moab::ErrorOutput::use_world_rank().

Referenced by moab::Core::initialize(), and main().

◆ MBErrorHandler_Initialized()

bool moab::MBErrorHandler_Initialized ( )

Indicates whether MBErrorHandler_Init has been called.

Definition at line 49 of file ErrorHandler.cpp.

 {
  return ( NULL != errorOutput );
 }

References errorOutput.

Referenced by moab::Core::initialize().

◆ MBTraceBackErrorHandler()

void moab::MBTraceBackErrorHandler	(	int	line,
		const char *	func,
		const char *	file,
		const char *	dir,
		const char *	err_msg,
		ErrorType	err_type
	)

Definition at line 59 of file ErrorHandler.cpp.

 {
  if( NULL == errorOutput ) return;
  
  // For a globally fatal error, get world rank of current processor, so that it is only printed
  // from processor 0 For a per-processor relevant error, set rank of current processor to 0, so
  // that it is always printed
  int rank = 0;
  if( MB_ERROR_TYPE_NEW_GLOBAL == err_type && errorOutput->have_rank() ) rank = errorOutput->get_rank();
  
  if( 0 == rank )
  {
  // Print the error message for a new error
  if( MB_ERROR_TYPE_EXISTING != err_type && NULL != err_msg )
  {
  errorOutput->print( "--------------------- Error Message ------------------------------------\n" );
  errorOutput->printf( "%s!\n", err_msg );
  lastError = err_msg;
  }
  
  // Print a line of stack trace for a new error, or an existing one
  errorOutput->printf( "%s() line %d in %s%s\n", func, line, dir, file );
  }
  else
  {
  // Do not print the error message or stack trace, since processor 0 will print them
  // Sleep 10 seconds before aborting so it will not accidently kill process 0
  sleep( 10 );
  abort();
  }
 }

References errorOutput, moab::ErrorOutput::get_rank(), moab::ErrorOutput::have_rank(), lastError, MB_ERROR_TYPE_EXISTING, MB_ERROR_TYPE_NEW_GLOBAL, moab::ErrorOutput::print(), and moab::ErrorOutput::printf().

Referenced by MBError().

◆ measure()

static int moab::measure	(	const CartVect &	v,
		double &	result
	)

static

Definition at line 1799 of file OrientedBoxTreeTool.cpp.

 {
  const double tol = 1e-6;
  int dims = 0;
  result = 1;
  for( int i = 0; i < 3; ++i )
  if( v[i] > tol )
  {
  ++dims;
  result *= v[i];
  }
  return dims;
 }

Referenced by gather_set_stats(), main(), and moab::OrientedBoxTreeTool::recursive_stats().

◆ mem_to_string()

static std::string moab::mem_to_string ( unsigned long mem )

static

Definition at line 2069 of file AdaptiveKDTree.cpp.

 {
  char unit[3] = "B";
  if( mem > 9 * 1024 )
  {
  mem = ( mem + 512 ) / 1024;
  strcpy( unit, "kB" );
  }
  if( mem > 9 * 1024 )
  {
  mem = ( mem + 512 ) / 1024;
  strcpy( unit, "MB" );
  }
  if( mem > 9 * 1024 )
  {
  mem = ( mem + 512 ) / 1024;
  strcpy( unit, "GB" );
  }
  char buffer[256];
  sprintf( buffer, "%lu %s", mem, unit );
  return buffer;
 }

References buffer, and unit().

Referenced by moab::AdaptiveKDTree::print().

◆ merge_ranged_ids()

static void moab::merge_ranged_ids	(	const unsigned long *	range_list,
		size_t	len,
		std::vector< WriteHDF5::wid_t > &	result
	)

static

Definition at line 1761 of file WriteHDF5Parallel.cpp.

 {
  typedef WriteHDF5::wid_t wid_t;
  assert( 0 == len % 2 );
  assert( 0 == result.size() % 2 );
  STATIC_ASSERT( sizeof( std::pair< wid_t, wid_t > ) == 2 * sizeof( wid_t ) );
  
  result.insert( result.end(), range_list, range_list + len );
  size_t plen = result.size() / 2;
  Range tmp;
  for( size_t i = 0; i < plen; i++ )
  {
  EntityHandle starth = (EntityHandle)result[2 * i];
  EntityHandle endh = (EntityHandle)result[2 * i] + (wid_t)result[2 * i + 1] - 1; // id + count - 1
  tmp.insert( starth, endh );
  }
  // Now convert back to std::vector<WriteHDF5::wid_t>, compressed range format
  result.resize( tmp.psize() * 2 );
  int j = 0;
  for( Range::const_pair_iterator pit = tmp.const_pair_begin(); pit != tmp.const_pair_end(); ++pit, j++ )
  {
  result[2 * j] = pit->first;
  result[2 * j + 1] = pit->second - pit->first + 1;
  }
 }

References moab::Range::const_pair_begin(), moab::Range::const_pair_end(), moab::Range::insert(), moab::Range::psize(), and STATIC_ASSERT().

Referenced by moab::WriteHDF5Parallel::unpack_set().

◆ merge_vector_ids()

static void moab::merge_vector_ids	(	const unsigned long *	list,
		size_t	len,
		std::vector< WriteHDF5::wid_t > &	result
	)

static

Definition at line 1787 of file WriteHDF5Parallel.cpp.

 {
  result.insert( result.end(), list, list + len );
 }

Referenced by moab::WriteHDF5Parallel::unpack_set().

◆ MIN()

template<class T >

T moab::MIN	(	const T &	arg1,
		const T &	arg2
	)

Definition at line 3827 of file ParallelComm.cpp.

 {
  return ( arg1 < arg2 ? arg1 : arg2 );
 }

Referenced by moab::Tqdcfr::check_contiguous().

◆ MoabVersion()

MB_EXPORT const char* moab::MoabVersion ( )

Definition at line 108 of file Factory.cpp.

 {
  return MB_INTERFACE_VERSION;
 }

References MB_INTERFACE_VERSION.

◆ mpi_err_str()

const char* moab::mpi_err_str ( int errorcode )

Definition at line 80 of file WriteHDF5Parallel.cpp.

 {
  static char buffer[2048];
  int len = sizeof( buffer );
  MPI_Error_string( errorcode, buffer, &len );
  buffer[std::min( (size_t)len, sizeof( buffer ) - 1 )] = '\0';
  return buffer;
 }

References buffer.

◆ MULT()

template<class T >

T moab::MULT	(	const T &	arg1,
		const T &	arg2
	)

Definition at line 3837 of file ParallelComm.cpp.

 {
  return arg1 * arg2;
 }

◆ my_Gatherv()

static int moab::my_Gatherv	(	void *	sendbuf,
		int	sendcount,
		MPI_Datatype	sendtype,
		std::vector< unsigned char > &	recvbuf,
		std::vector< int > &	recvcounts,
		int	root,
		MPI_Comm	comm
	)

static

Definition at line 184 of file WriteHDF5Parallel.cpp.

 {
  int nproc, rank, bytes, err;
  MPI_Comm_size( comm, &nproc );
  MPI_Comm_rank( comm, &rank );
  MPI_Type_size( sendtype, &bytes );
  
  recvcounts.resize( rank == root ? nproc : 0 );
  err = MPI_Gather( &sendcount, 1, MPI_INT, &recvcounts[0], 1, MPI_INT, root, comm );
  if( MPI_SUCCESS != err ) return err;
  
  std::vector< int > disp( recvcounts.size() );
  if( root == rank )
  {
  disp[0] = 0;
  for( int i = 1; i < nproc; ++i )
  disp[i] = disp[i - 1] + recvcounts[i - 1];
  recvbuf.resize( bytes * ( disp.back() + recvcounts.back() ) );
  }
  
  return MPI_Gatherv( sendbuf, sendcount, sendtype, &recvbuf[0], &recvcounts[0], &disp[0], sendtype, root, comm );
 }

Referenced by moab::WriteHDF5Parallel::create_tag_tables().

◆ not_found() [1/3]

static ErrorCode moab::not_found ( const std::string & )

inlinestatic

Definition at line 41 of file MeshTag.cpp.

 {
  // MB_TAG_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
 #if 0
  fprintf(stderr, "[Warning]: No mesh tag %s value for global/mesh tag\n", name.c_str());
 #endif
  
  return MB_TAG_NOT_FOUND;
 }

References MB_TAG_NOT_FOUND.

◆ not_found() [2/3]

static ErrorCode moab::not_found	(	const std::string &	,
		EntityHandle
	)

inlinestatic

Definition at line 20 of file DenseTag.cpp.

 {
  // MB_TAG_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
 #if 0
  if (h)
  fprintf(stderr, "[Warning]: No dense tag %s value for %s %ld\n",
  name.c_str(),
  CN::EntityTypeName(TYPE_FROM_HANDLE(h)),
  (unsigned long)ID_FROM_HANDLE(h));
  else
  fprintf(stderr, "[Warning]: No dense tag %s value for root set\n", name.c_str());
 #endif
  
  return MB_TAG_NOT_FOUND;
 }

References moab::CN::EntityTypeName(), ID_FROM_HANDLE(), MB_TAG_NOT_FOUND, and TYPE_FROM_HANDLE().

Referenced by moab::VarLenDenseTag::get_array(), moab::VarLenDenseTag::get_data(), moab::DenseTag::get_data(), and moab::MeshTag::get_data().

◆ not_found() [3/3]

static ErrorCode moab::not_found	(	std::string	,
		EntityHandle
	)

inlinestatic

Definition at line 21 of file VarLenDenseTag.cpp.

 {
 #if 0
  // MB_TAG_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
  // Print warning messages for debugging only
  if (h)
  fprintf(stderr, "[Warning]: No variable-length dense tag %s value for %s %lu\n",
  name.c_str(),
  CN::EntityTypeName(TYPE_FROM_HANDLE(h)),
  (unsigned long)ID_FROM_HANDLE(h));
  else
  fprintf(stderr, "[Warning]: No variable-length dense tag %s value for root set\n", name.c_str());
 #endif
  
  return MB_TAG_NOT_FOUND;
 }

References moab::CN::EntityTypeName(), ID_FROM_HANDLE(), MB_TAG_NOT_FOUND, and TYPE_FROM_HANDLE().

◆ not_root_set()

static ErrorCode moab::not_root_set	(	const std::string &	,
		EntityHandle
	)

inlinestatic

Definition at line 16 of file MeshTag.cpp.

 {
  // MB_TAG_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
  // Print warning messages for debugging only
 #if 0
  MB_SET_ERR(MB_VARIABLE_DATA_LENGTH, "Cannot get/set mesh/global tag " << name << " on non-root-set " << CN::EntityTypeName(TYPE_FROM_HANDLE(h)) << " " << (unsigned long)ID_FROM_HANDLE(h));
 #endif
  
  return MB_TAG_NOT_FOUND;
 }

References moab::CN::EntityTypeName(), ID_FROM_HANDLE(), MB_SET_ERR, MB_TAG_NOT_FOUND, MB_VARIABLE_DATA_LENGTH, and TYPE_FROM_HANDLE().

Referenced by all_root_set(), moab::MeshTag::clear_data(), moab::MeshTag::get_data(), moab::MeshTag::remove_data(), moab::MeshTag::set_data(), and moab::MeshTag::tag_iterate().

◆ numAdjTriInSet()

int moab::numAdjTriInSet	(	Interface *	mb,
		EntityHandle	startEdge,
		EntityHandle	set
	)

Definition at line 25 of file SmoothFace.cpp.

 {
  std::vector< EntityHandle > adjTri;
  mb->get_adjacencies( &startEdge, 1, 2, false, adjTri, Interface::UNION );
  // count how many are in the set
  int nbInSet = 0;
  for( size_t i = 0; i < adjTri.size(); i++ )
  {
  EntityHandle tri = adjTri[i];
  if( mb->contains_entities( set, &tri, 1 ) ) nbInSet++;
  }
  return nbInSet;
 }

References moab::Core::contains_entities(), moab::Core::get_adjacencies(), mb, and moab::Interface::UNION.

◆ operator!=()

bool moab::operator!=	(	const Range &	r1,
		const Range &	r2
	)

inline

Definition at line 924 of file Range.hpp.

 {
  return !( r1 == r2 );
 }

◆ operator%()

double moab::operator%	(	const CartVect &	u,
		const CartVect &	v
	)

inline

Dot product.

Definition at line 170 of file CartVect.hpp.

 {
  return u[0] * v[0] + u[1] * v[1] + u[2] * v[2];
 }

◆ operator&()

AxisBox moab::operator&	(	const AxisBox &	a,
		const AxisBox &	b
	)

inline

intersect

Definition at line 116 of file AxisBox.hpp.

 {
  return AxisBox( a ) &= b;
 }

◆ operator*() [1/9]

AffineXform moab::operator*	(	const AffineXform &	A,
		const AffineXform &	B
	)

inline

create a new transform equivalent to transform A followed by transform B

Definition at line 119 of file AffineXform.hpp.

 {
  AffineXform result( A );
  result.accumulate( B );
  return result;
 }

References moab::AffineXform::accumulate().

◆ operator*() [2/9]

CartVect moab::operator*	(	const CartVect &	u,
		const CartVect &	v
	)

inline

cross product

Definition at line 164 of file CartVect.hpp.

 {
  return CartVect( u[1] * v[2] - u[2] * v[1], u[2] * v[0] - u[0] * v[2], u[0] * v[1] - u[1] * v[0] );
 }

◆ operator*() [3/9]

CartVect moab::operator*	(	const CartVect &	v,
		const Matrix3 &	m
	)

inline

Definition at line 1077 of file Matrix3.hpp.

 {
  return moab::Matrix::vector_matrix( v, m );
 }

References moab::Matrix::vector_matrix().

◆ operator*() [4/9]

CartVect moab::operator*	(	const CartVect &	v,
		double	s
	)

inline

Definition at line 227 of file CartVect.hpp.

 {
  return CartVect( v[0] * s, v[1] * s, v[2] * s );
 }

◆ operator*() [5/9]

Matrix3 moab::operator*	(	const Matrix3 &	a,
		const Matrix3 &	b
	)

inline

Definition at line 1051 of file Matrix3.hpp.

 {
 #ifndef MOAB_HAVE_LAPACK
  return Matrix3( a._mat * b._mat );
 #else
  return Matrix::mmult3( a, b );
 #endif
 }

◆ operator*() [6/9]

CartVect moab::operator*	(	const Matrix3 &	m,
		const CartVect &	v
	)

inline

Definition at line 1072 of file Matrix3.hpp.

 {
  return moab::Matrix::matrix_vector( m, v );
 }

References moab::Matrix::matrix_vector().

◆ operator*() [7/9]

template<typename T >

std::vector< T > moab::operator*	(	const Matrix3 &	m,
		const std::vector< T > &	v
	)

inline

Definition at line 1061 of file Matrix3.hpp.

 {
  return moab::Matrix::matrix_vector( m, v );
 }

References moab::Matrix::matrix_vector().

◆ operator*() [8/9]

template<typename T >

std::vector< T > moab::operator*	(	const std::vector< T > &	v,
		const Matrix3 &	m
	)

inline

Definition at line 1067 of file Matrix3.hpp.

 {
  return moab::Matrix::vector_matrix( v, m );
 }

References moab::Matrix::vector_matrix().

◆ operator*() [9/9]

CartVect moab::operator*	(	double	s,
		const CartVect &	v
	)

inline

Definition at line 243 of file CartVect.hpp.

 {
  return CartVect( v[0] * s, v[1] * s, v[2] * s );
 }

◆ operator+() [1/6]

CartVect moab::operator+	(	const CartVect &	u,
		const CartVect &	v
	)

inline

Definition at line 153 of file CartVect.hpp.

 {
  return CartVect( u[0] + v[0], u[1] + v[1], u[2] + v[2] );
 }

◆ operator+() [2/6]

CartVect moab::operator+	(	const CartVect &	v,
		double	s
	)

inline

Definition at line 219 of file CartVect.hpp.

 {
  return CartVect( v[0] + s, v[1] + s, v[2] + s );
 }

◆ operator+() [3/6]

Matrix3 moab::operator+	(	const Matrix3 &	a,
		const Matrix3 &	b
	)

inline

Definition at line 1027 of file Matrix3.hpp.

 {
 #ifndef MOAB_HAVE_LAPACK
  return Matrix3( a._mat + b._mat );
 #else
  Matrix3 s( a );
  for( int i = 0; i < Matrix3::size; ++i )
  s( i ) += b._mat[i];
  return s;
 #endif
 }

◆ operator+() [4/6]

Range::const_iterator moab::operator+	(	const Range::const_iterator &	it,
		EntityID	step
	)

inline

Definition at line 780 of file Range.hpp.

 {
  Range::const_iterator tmp( it );
  return tmp += step;
 }

◆ operator+() [5/6]

CartVect moab::operator+	(	double	s,
		const CartVect &	v
	)

inline

Definition at line 235 of file CartVect.hpp.

 {
  return CartVect( v[0] + s, v[1] + s, v[2] + s );
 }

◆ operator+() [6/6]

Range::const_iterator moab::operator+	(	EntityID	step,
		const Range::const_iterator &	it
	)

inline

Definition at line 786 of file Range.hpp.

 {
  Range::const_iterator tmp( it );
  return tmp += step;
 }

◆ operator++() [1/2]

ExoIIElementType& moab::operator++ ( ExoIIElementType & type )

inline

prefix increment operator for EntityType

Definition at line 127 of file ExoIIUtil.hpp.

 {
  return (ExoIIElementType&)( ++( (int&)type ) );
 }

◆ operator++() [2/2]

ExoIIElementType moab::operator++	(	ExoIIElementType &	type,
		int
	)

inline

postfix increment operator for EntityType

Definition at line 121 of file ExoIIUtil.hpp.

 {
  return (ExoIIElementType)( ( (int&)type )++ );
 }

Referenced by moab::Range::pair_iterator::operator++(), moab::Range::const_iterator::operator++(), and moab::Range::const_pair_iterator::operator++().

◆ operator-() [1/9]

CartVect moab::operator-	(	const CartVect &	u,
		const CartVect &	v
	)

inline

Definition at line 158 of file CartVect.hpp.

 {
  return CartVect( u[0] - v[0], u[1] - v[1], u[2] - v[2] );
 }

◆ operator-() [2/9]

CartVect moab::operator- ( const CartVect & v )

inline

Definition at line 215 of file CartVect.hpp.

 {
  return CartVect( -v[0], -v[1], -v[2] );
 }

◆ operator-() [3/9]

CartVect moab::operator-	(	const CartVect &	v,
		double	s
	)

inline

Definition at line 223 of file CartVect.hpp.

 {
  return CartVect( v[0] - s, v[1] - s, v[2] - s );
 }

◆ operator-() [4/9]

Matrix3 moab::operator-	(	const Matrix3 &	a,
		const Matrix3 &	b
	)

inline

Definition at line 1039 of file Matrix3.hpp.

 {
 #ifndef MOAB_HAVE_LAPACK
  return Matrix3( a._mat - b._mat );
 #else
  Matrix3 s( a );
  for( int i = 0; i < Matrix3::size; ++i )
  s( i ) -= b._mat[i];
  return s;
 #endif
 }

◆ operator-() [5/9]

MeshSet::hdl_iter::difference_type moab::operator-	(	const MeshSet::hdl_iter &	a,
		const MeshSet::hdl_iter &	b
	)

inline

Definition at line 387 of file MeshSet.hpp.

 {
  return (MeshSet::hdl_iter::difference_type)a.h - (MeshSet::hdl_iter::difference_type)b.h;
 }

References moab::MeshSet::hdl_iter::h.

◆ operator-() [6/9]

Range::const_iterator moab::operator-	(	const Range::const_iterator &	it,
		EntityID	step
	)

inline

Definition at line 792 of file Range.hpp.

 {
  Range::const_iterator tmp( it );
  return tmp -= step;
 }

◆ operator-() [7/9]

EntityID moab::operator-	(	const Range::const_iterator &	it1,
		const Range::const_iterator &	it2
	)

Definition at line 793 of file Range.cpp.

 {
  assert( !it2.mValue || *it2 >= *it1 );
  if( it2.mNode == it1.mNode )
  {
  return *it2 - *it1;
  }
  
  EntityID result = it1.mNode->second - it1.mValue + 1;
  for( Range::PairNode* n = it1.mNode->mNext; n != it2.mNode; n = n->mNext )
  result += n->second - n->first + 1;
  if( it2.mValue ) // (it2.mNode != &mHead)
  result += it2.mValue - it2.mNode->first;
  return result;
 }

◆ operator-() [8/9]

CartVect moab::operator-	(	double	s,
		const CartVect &	v
	)

inline

Definition at line 239 of file CartVect.hpp.

 {
  return CartVect( v[0] - s, v[1] - s, v[2] - s );
 }

◆ operator-() [9/9]

Range::const_iterator moab::operator-	(	EntityID	step,
		const Range::const_iterator &	it
	)

inline

Definition at line 798 of file Range.hpp.

 {
  Range::const_iterator tmp( it );
  return tmp -= step;
 }

◆ operator/()

CartVect moab::operator/	(	const CartVect &	v,
		double	s
	)

inline

Definition at line 231 of file CartVect.hpp.

 {
  return CartVect( v[0] / s, v[1] / s, v[2] / s );
 }

◆ operator<() [1/2]

static bool moab::operator<	(	const ProcList &	a,
		const ProcList &	b
	)

static

Definition at line 6242 of file ParallelComm.cpp.

 {
  for( int i = 0; i < MAX_SHARING_PROCS; i++ )
  {
  if( a.procs[i] < b.procs[i] )
  return true;
  else if( b.procs[i] < a.procs[i] )
  return false;
  else if( a.procs[i] < 0 )
  return false;
  }
  return false;
 }

References MAX_SHARING_PROCS, and moab::ProcList::procs.

◆ operator<() [2/2]

bool moab::operator<	(	Node const &	lhs,
		Node const &	rhs
	)

Definition at line 1036 of file TempestRemapper.cpp.

 {
  return std::pow( lhs.x - rhs.x, 2.0 ) + std::pow( lhs.y - rhs.y, 2.0 ) + std::pow( lhs.z - rhs.z, 2.0 );
 }

◆ operator<<() [1/8]

std::ostream & moab::operator<<	(	std::ostream &	s,
		const OrientedBox &	b
	)

Definition at line 45 of file OrientedBox.cpp.

 {
  return s << b.center << " + " << b.axes.col( 0 )
 #if MB_ORIENTED_BOX_UNIT_VECTORS
  << ":" << b.length[0]
 #endif
  << " x " << b.axes.col( 1 )
 #if MB_ORIENTED_BOX_UNIT_VECTORS
  << ":" << b.length[1]
 #endif
  << " x " << b.axes.col( 2 )
 #if MB_ORIENTED_BOX_UNIT_VECTORS
  << ":" << b.length[2]
 #endif
  ;
 }

References moab::OrientedBox::axes, moab::OrientedBox::center, moab::Matrix3::col(), and moab::OrientedBox::length.

◆ operator<<() [2/8]

std::ostream& moab::operator<<	(	std::ostream &	out,
		const BoundBox &	box
	)

inline

Definition at line 158 of file BoundBox.hpp.

 {
  out << ( std::string ) "Min: ";
  out << box.bMin;
  out << ( std::string ) ", Max: ";
  out << box.bMax;
  return out;
 }

References moab::BoundBox::bMax, and moab::BoundBox::bMin.

◆ operator<<() [3/8]

std::ostream & moab::operator<<	(	std::ostream &	s,
		const CartVect &	v
	)

Definition at line 22 of file CartVect.cpp.

 {
  return s << '[' << v[0] << ' ' << v[1] << ' ' << v[2] << ']';
 }

◆ operator<<() [4/8]

std::ostream& moab::operator<<	(	std::ostream &	s,
		const Range &	r
	)

inline

Definition at line 917 of file Range.hpp.

 {
  r.print( s );
  return s;
 }

References moab::Range::print().

◆ operator<<() [5/8]

std::ostream& moab::operator<<	(	std::ostream &	s,
		const SequenceManager &	seq_man
	)

Definition at line 895 of file SequenceManager.cpp.

 {
  for( EntityType t = MBVERTEX; t < MBMAXTYPE; ++t )
  {
  if( !seq_man.entity_map( t ).empty() )
  s << std::endl
  << "****************** " << CN::EntityTypeName( t ) << " ******************" << std::endl
  << seq_man.entity_map( t ) << std::endl;
  }
  
  return s;
 }

References moab::TypeSequenceManager::empty(), moab::SequenceManager::entity_map(), moab::CN::EntityTypeName(), MBMAXTYPE, MBVERTEX, and t.

◆ operator<<() [6/8]

std::ostream& moab::operator<<	(	std::ostream &	s,
		const TypeSequenceManager &	seq_man
	)

Definition at line 876 of file SequenceManager.cpp.

 {
  const SequenceData* prev_data = 0;
  for( TypeSequenceManager::const_iterator i = seq_man.begin(); i != seq_man.end(); ++i )
  {
  const EntitySequence* seq = *i;
  if( seq->data() != prev_data )
  {
  prev_data = seq->data();
  s << "SequenceData [" << ID_FROM_HANDLE( seq->data()->start_handle() ) << ","
  << ID_FROM_HANDLE( seq->data()->end_handle() ) << "]" << std::endl;
  }
  s << " Sequence [" << ID_FROM_HANDLE( seq->start_handle() ) << "," << ID_FROM_HANDLE( seq->end_handle() )
  << "]" << std::endl;
  }
  
  return s;
 }

References moab::TypeSequenceManager::begin(), moab::EntitySequence::data(), moab::TypeSequenceManager::end(), moab::EntitySequence::end_handle(), moab::SequenceData::end_handle(), ID_FROM_HANDLE(), moab::EntitySequence::start_handle(), and moab::SequenceData::start_handle().

◆ operator<<() [7/8]

std::ostream& moab::operator<<	(	std::ostream &	str,
		const HomCoord &	hc
	)

inline

Definition at line 491 of file HomXform.hpp.

 {
  str << "(" << hc.i() << "," << hc.j() << "," << hc.k() << ")";
  return str;
 }

References moab::HomCoord::i(), moab::HomCoord::j(), and moab::HomCoord::k().

◆ operator<<() [8/8]

std::ostream & moab::operator<<	(	std::ostream &	str,
		const ScdParData &	pd
	)

Definition at line 1513 of file ScdInterface.cpp.

 {
  str << "Partition method = " << ScdParData::PartitionMethodNames[pd.partMethod] << ", gDims = (" << pd.gDims[0]
  << "," << pd.gDims[1] << "," << pd.gDims[2] << ")-(" << pd.gDims[3] << "," << pd.gDims[4] << "," << pd.gDims[5]
  << "), gPeriodic = (" << pd.gPeriodic[0] << "," << pd.gPeriodic[1] << "," << pd.gPeriodic[2] << "), pDims = ("
  << pd.pDims[0] << "," << pd.pDims[1] << "," << pd.pDims[2] << ")" << std::endl;
  return str;
 }

References moab::ScdParData::gDims, moab::ScdParData::gPeriodic, moab::ScdParData::PartitionMethodNames, moab::ScdParData::partMethod, and moab::ScdParData::pDims.

◆ operator==() [1/2]

const bool moab::operator==	(	const damsel_err_t &	lhs,
		const damsel_err_t &	rhs
	)

inline

Definition at line 128 of file ReadDamsel.hpp.

 {
  return lhs.id == rhs.id;
 }

◆ operator==() [2/2]

bool moab::operator==	(	const Range &	r1,
		const Range &	r2
	)

Definition at line 987 of file Range.cpp.

 {
  Range::const_pair_iterator i1, i2;
  i1 = r1.const_pair_begin();
  i2 = r2.const_pair_begin();
  for( ; i1 != r1.const_pair_end(); ++i1, ++i2 )
  if( i2 == r2.const_pair_end() || i1->first != i2->first || i1->second != i2->second ) return false;
  return i2 == r2.const_pair_end();
 }

References moab::Range::const_pair_begin(), and moab::Range::const_pair_end().

◆ operator|()

AxisBox moab::operator\|	(	const AxisBox &	a,
		const AxisBox &	b
	)

inline

unite

Definition at line 122 of file AxisBox.hpp.

 {
  return AxisBox( a ) |= b;
 }

◆ operator||()

bool moab::operator\|\|	(	const AxisBox &	a,
		const AxisBox &	b
	)

inline

intersects

Definition at line 128 of file AxisBox.hpp.

 {
  return a.minimum()[0] <= b.maximum()[0] && a.minimum()[1] <= b.maximum()[1] && a.minimum()[2] <= b.maximum()[2] &&
  a.maximum()[0] >= b.minimum()[0] && a.maximum()[1] >= b.minimum()[1] && a.maximum()[2] >= b.minimum()[2];
 }

References moab::AxisBox::maximum(), and moab::AxisBox::minimum().

◆ outer_product()

template<typename Vector >

Matrix3 moab::outer_product	(	const Vector &	u,
		const Vector &	v
	)

inline

Definition at line 1021 of file Matrix3.hpp.

 {
  return Matrix3( u[0] * v[0], u[0] * v[1], u[0] * v[2], u[1] * v[0], u[1] * v[1], u[1] * v[2], u[2] * v[0],
  u[2] * v[1], u[2] * v[2] );
 }

Referenced by moab::OrientedBox::compute_from_covariance_data(), moab::OrientedBox::compute_from_vertices(), moab::OrientedBox::covariance_data_from_tris(), and moab::AffineXform::rotation().

◆ PACK()

template<typename T >

static void moab::PACK	(	unsigned char *&	buff,
		const T *	val,
		size_t	count
	)

inlinestatic

Definition at line 98 of file ParallelComm.cpp.

 {
  memcpy( buff, val, count * sizeof( T ) );
  buff += count * sizeof( T );
 }

References T.

Referenced by PACK_DBLS(), PACK_EH(), PACK_INTS(), and PACK_VOID().

◆ PACK_BYTES()

static void moab::PACK_BYTES	(	unsigned char *&	buff,
		const void *	val,
		int	num
	)

inlinestatic

Definition at line 145 of file ParallelComm.cpp.

 {
  PACK_INT( buff, num );
  PACK_VOID( buff, val, num );
 }

References PACK_INT(), and PACK_VOID().

Referenced by moab::ParallelComm::pack_tag().

◆ PACK_DBLS()

static void moab::PACK_DBLS	(	unsigned char *&	buff,
		const double *	dbl_val,
		size_t	num
	)

inlinestatic

Definition at line 115 of file ParallelComm.cpp.

 {
  PACK( buff, dbl_val, num );
  PC( num, " doubles" );
 }

References PACK(), and PC.

Referenced by moab::ParallelComm::pack_entities().

◆ PACK_EH()

static void moab::PACK_EH	(	unsigned char *&	buff,
		const EntityHandle *	eh_val,
		size_t	num
	)

inlinestatic

Definition at line 125 of file ParallelComm.cpp.

 {
  PACK( buff, eh_val, num );
  PC( num, " handles" );
 }

References PACK(), and PC.

Referenced by moab::ParallelComm::pack_entities(), moab::ParallelComm::pack_entity_seq(), PACK_RANGE(), moab::ParallelComm::pack_remote_handles(), moab::ParallelComm::pack_sets(), moab::ParallelComm::pack_tag(), moab::ParallelComm::send_recv_entities(), and moab::ParallelComm::settle_intersection_points().

◆ PACK_INT()

static void moab::PACK_INT	(	unsigned char *&	buff,
		int	int_val
	)

inlinestatic

Definition at line 110 of file ParallelComm.cpp.

 {
  PACK_INTS( buff, &int_val, 1 );
 }

References PACK_INTS().

Referenced by moab::ParallelComm::pack_buffer(), PACK_BYTES(), moab::ParallelComm::pack_entities(), moab::ParallelComm::pack_entity_seq(), PACK_RANGE(), moab::ParallelComm::pack_remote_handles(), moab::ParallelComm::pack_sets(), moab::ParallelComm::pack_tag(), moab::ParallelComm::pack_tags(), and moab::ParallelComm::settle_intersection_points().

◆ PACK_INTS()

static void moab::PACK_INTS	(	unsigned char *&	buff,
		const int *	int_val,
		size_t	num
	)

inlinestatic

Definition at line 104 of file ParallelComm.cpp.

 {
  PACK( buff, int_val, num );
  PC( num, " ints" );
 }

References PACK(), and PC.

Referenced by moab::ParallelComm::pack_entities(), PACK_INT(), moab::ParallelComm::pack_remote_handles(), moab::ParallelComm::pack_sets(), moab::ParallelComm::pack_tag(), and moab::ParallelComm::send_recv_entities().

◆ PACK_RANGE()

static void moab::PACK_RANGE	(	unsigned char *&	buff,
		const Range &	rng
	)

inlinestatic

Definition at line 151 of file ParallelComm.cpp.

 {
  PACK_INT( buff, rng.psize() );
  Range::const_pair_iterator cit;
  for( cit = rng.const_pair_begin(); cit != rng.const_pair_end(); ++cit )
  {
  EntityHandle eh[2] = { cit->first, cit->second };
  PACK_EH( buff, eh, 2 );
  }
  PC( rng.psize(), "-subranged range" );
 }

References moab::Range::const_pair_begin(), moab::Range::const_pair_end(), PACK_EH(), PACK_INT(), PC, and moab::Range::psize().

Referenced by moab::ParallelComm::pack_sets().

◆ pack_tuples()

int pack_tuples	(	TupleList *	tl,
		void **	ptr
	)

Definition at line 1853 of file Coupler.cpp.

 {
  uint mi, ml, mul, mr;
  tl->getTupleSize( mi, ml, mul, mr );
  
  uint n = tl->get_n();
  
  int sz_buf = 1 + 4 * UINT_PER_UNSIGNED +
  tl->get_n() * ( mi + ml * UINT_PER_LONG + mul * UINT_PER_LONG + mr * UINT_PER_REAL );
  
  uint* buf = (uint*)malloc( sz_buf * sizeof( uint ) );
  *ptr = (void*)buf;
  
  // Copy n
  memcpy( buf, &n, sizeof( uint ) ), buf += 1;
  // Copy mi
  memcpy( buf, &mi, sizeof( unsigned ) ), buf += UINT_PER_UNSIGNED;
  // Copy ml
  memcpy( buf, &ml, sizeof( unsigned ) ), buf += UINT_PER_UNSIGNED;
  // Copy mul
  memcpy( buf, &mul, sizeof( unsigned ) ), buf += UINT_PER_UNSIGNED;
  // Copy mr
  memcpy( buf, &mr, sizeof( unsigned ) ), buf += UINT_PER_UNSIGNED;
  // Copy vi_wr
  memcpy( buf, tl->vi_rd, tl->get_n() * mi * sizeof( sint ) ), buf += tl->get_n() * mi;
  // Copy vl_wr
  memcpy( buf, tl->vl_rd, tl->get_n() * ml * sizeof( slong ) ), buf += tl->get_n() * ml * UINT_PER_LONG;
  // Copy vul_wr
  memcpy( buf, tl->vul_rd, tl->get_n() * mul * sizeof( ulong ) ), buf += tl->get_n() * mul * UINT_PER_LONG;
  // Copy vr_wr
  memcpy( buf, tl->vr_rd, tl->get_n() * mr * sizeof( realType ) ), buf += tl->get_n() * mr * UINT_PER_REAL;
  
  return sz_buf;
 }

References moab::TupleList::get_n(), moab::TupleList::getTupleSize(), UINT_PER_LONG, UINT_PER_REAL, UINT_PER_UNSIGNED, moab::TupleList::vi_rd, moab::TupleList::vl_rd, moab::TupleList::vr_rd, and moab::TupleList::vul_rd.

Referenced by moab::Coupler::get_matching_entities(), and main().

◆ PACK_VOID()

static void moab::PACK_VOID	(	unsigned char *&	buff,
		const void *	val,
		size_t	num
	)

inlinestatic

Definition at line 139 of file ParallelComm.cpp.

 {
  PACK( buff, reinterpret_cast< const unsigned char* >( val ), num );
  PC( num, " void" );
 }

References PACK(), and PC.

Referenced by PACK_BYTES(), moab::ParallelComm::pack_sets(), and moab::ParallelComm::pack_tag().

◆ permute_this()

template<typename T >

int moab::permute_this	(	EntityType	t,
		const int	dim,
		T *	conn,
		const int	indices_per_ent,
		const int	num_entries
	)

inline

Definition at line 1029 of file CN.cpp.

 {
  T tmp_conn[MAX_SUB_ENTITIES];
  assert( indices_per_ent <= CN::permuteVec[t][dim][MAX_SUB_ENTITIES] );
  if( indices_per_ent > CN::permuteVec[t][dim][MAX_SUB_ENTITIES] ) return 1;
  short int* tvec = CN::permuteVec[t][dim];
  T* pvec = conn;
  for( int j = 0; j < num_entries; j++ )
  {
  for( int i = 0; i < indices_per_ent; i++ )
  tmp_conn[tvec[i]] = pvec[i];
  memcpy( pvec, tmp_conn, indices_per_ent * sizeof( T ) );
  pvec += indices_per_ent;
  }
  
  return 0;
 }

References dim, MAX_SUB_ENTITIES, moab::CN::permuteVec, t, and T.

Referenced by moab::CN::permuteThis().

◆ physField()

double moab::physField	(	double	x,
		double	y,
		double	z,
		double	factor
	)

Definition at line 14 of file addfield.cpp.

 {
  
  // 1/r^2 decay from {0,0,0}
  // tjt - changing to 1/r
  /*
  double scale = 1.0/factor;
  out = fabs(x*scale) + fabs(y*scale) + fabs(z*scale);
  out += 1e-1; // clamp
  out = 1/out;
  */
  double out = factor * sqrt( x * x + y * y + z * z );
  
  return out;
 }

Referenced by main(), putElementField(), putSpectralElementField(), and putVertexField().

◆ plane_cut_box()

static ErrorCode moab::plane_cut_box	(	double	cut_face_out[4][3],
		double	corners_inout[8][3],
		const BSPTree::Plane &	plane
	)

static

Given the corners of a hexahedron in corners_input and a plane, cut the hex with the plane, updating corners_input and storing the original,cut-off side of the hex in cut_face_out.

The portion of the hex below the plane is retained. cut_face_out will contain the side of the hex that is entirely above the plane.

Returns: MB_FAILURE if plane/hex intersection is not a quadrilateral.

Definition at line 667 of file BSPTree.cpp.

 {
  switch( BSPTreeBoxIter::side_above_plane( corners_inout, plane ) )
  {
  case BSPTreeBoxIter::B0154:
  plane_cut_edge( cut_face_out[0], corners_inout[3], corners_inout[0], plane );
  plane_cut_edge( cut_face_out[1], corners_inout[2], corners_inout[1], plane );
  plane_cut_edge( cut_face_out[2], corners_inout[6], corners_inout[5], plane );
  plane_cut_edge( cut_face_out[3], corners_inout[7], corners_inout[4], plane );
  break;
  case BSPTreeBoxIter::B1265:
  plane_cut_edge( cut_face_out[0], corners_inout[0], corners_inout[1], plane );
  plane_cut_edge( cut_face_out[1], corners_inout[3], corners_inout[2], plane );
  plane_cut_edge( cut_face_out[2], corners_inout[7], corners_inout[6], plane );
  plane_cut_edge( cut_face_out[3], corners_inout[4], corners_inout[5], plane );
  break;
  case BSPTreeBoxIter::B2376:
  plane_cut_edge( cut_face_out[0], corners_inout[1], corners_inout[2], plane );
  plane_cut_edge( cut_face_out[1], corners_inout[0], corners_inout[3], plane );
  plane_cut_edge( cut_face_out[2], corners_inout[4], corners_inout[7], plane );
  plane_cut_edge( cut_face_out[3], corners_inout[5], corners_inout[6], plane );
  break;
  case BSPTreeBoxIter::B3047:
  plane_cut_edge( cut_face_out[0], corners_inout[2], corners_inout[3], plane );
  plane_cut_edge( cut_face_out[1], corners_inout[1], corners_inout[0], plane );
  plane_cut_edge( cut_face_out[2], corners_inout[5], corners_inout[4], plane );
  plane_cut_edge( cut_face_out[3], corners_inout[6], corners_inout[7], plane );
  break;
  case BSPTreeBoxIter::B3210:
  plane_cut_edge( cut_face_out[0], corners_inout[7], corners_inout[3], plane );
  plane_cut_edge( cut_face_out[1], corners_inout[6], corners_inout[2], plane );
  plane_cut_edge( cut_face_out[2], corners_inout[5], corners_inout[1], plane );
  plane_cut_edge( cut_face_out[3], corners_inout[4], corners_inout[0], plane );
  break;
  case BSPTreeBoxIter::B4567:
  plane_cut_edge( cut_face_out[0], corners_inout[0], corners_inout[4], plane );
  plane_cut_edge( cut_face_out[1], corners_inout[1], corners_inout[5], plane );
  plane_cut_edge( cut_face_out[2], corners_inout[2], corners_inout[6], plane );
  plane_cut_edge( cut_face_out[3], corners_inout[3], corners_inout[7], plane );
  break;
  default:
  return MB_FAILURE; // child is not a box
  }
  
  return MB_SUCCESS;
 }

References moab::BSPTreeBoxIter::B0154, moab::BSPTreeBoxIter::B1265, moab::BSPTreeBoxIter::B2376, moab::BSPTreeBoxIter::B3047, moab::BSPTreeBoxIter::B3210, moab::BSPTreeBoxIter::B4567, MB_SUCCESS, plane_cut_edge(), and moab::BSPTreeBoxIter::side_above_plane().

Referenced by moab::BSPTreeBoxIter::down(), moab::BSPTreeBoxIter::step(), and moab::BSPTreeBoxIter::step_to_first_leaf().

◆ plane_cut_edge()

static void moab::plane_cut_edge	(	double	old_coords_out[3],
		const double	keep_end_coords[3],
		double	cut_end_coords[3],
		const BSPTree::Plane &	plane
	)

inlinestatic

Clip an edge using a plane.

Given an edge from keep_end_coords to cut_end_coords, cut the edge using the passed plane, such that cut_end_coords is updated with a new location on the plane, and old_coords_out contains the original value of cut_end_coords.

Definition at line 641 of file BSPTree.cpp.

 {
  const CartVect start( keep_end_coords ), end( cut_end_coords );
  const CartVect norm( plane.norm );
  CartVect xsect_point;
  
  const CartVect m = end - start;
  const double t = -( norm % start + plane.coeff ) / ( norm % m );
  assert( t > 0.0 && t < 1.0 );
  xsect_point = start + t * m;
  
  end.get( old_coords_out );
  xsect_point.get( cut_end_coords );
 }

References moab::BSPTree::Plane::coeff, moab::CartVect::get(), moab::BSPTree::Plane::norm, and t.

Referenced by plane_cut_box().

◆ plane_uncut_box()

static ErrorCode moab::plane_uncut_box	(	const double	cut_face_in[4][3],
		double	corners_inout[8][3],
		const BSPTree::Plane &	plane
	)

inlinestatic

reverse of plane_cut_box

Definition at line 722 of file BSPTree.cpp.

 {
  switch( BSPTreeBoxIter::side_on_plane( corners_inout, plane ) )
  {
  case BSPTreeBoxIter::B0154:
  copy_coords( corners_inout[0], cut_face_in[0] );
  copy_coords( corners_inout[1], cut_face_in[1] );
  copy_coords( corners_inout[5], cut_face_in[2] );
  copy_coords( corners_inout[4], cut_face_in[3] );
  break;
  case BSPTreeBoxIter::B1265:
  copy_coords( corners_inout[1], cut_face_in[0] );
  copy_coords( corners_inout[2], cut_face_in[1] );
  copy_coords( corners_inout[6], cut_face_in[2] );
  copy_coords( corners_inout[5], cut_face_in[3] );
  break;
  case BSPTreeBoxIter::B2376:
  copy_coords( corners_inout[2], cut_face_in[0] );
  copy_coords( corners_inout[3], cut_face_in[1] );
  copy_coords( corners_inout[7], cut_face_in[2] );
  copy_coords( corners_inout[6], cut_face_in[3] );
  break;
  case BSPTreeBoxIter::B3047:
  copy_coords( corners_inout[3], cut_face_in[0] );
  copy_coords( corners_inout[0], cut_face_in[1] );
  copy_coords( corners_inout[4], cut_face_in[2] );
  copy_coords( corners_inout[7], cut_face_in[3] );
  break;
  case BSPTreeBoxIter::B3210:
  copy_coords( corners_inout[3], cut_face_in[0] );
  copy_coords( corners_inout[2], cut_face_in[1] );
  copy_coords( corners_inout[1], cut_face_in[2] );
  copy_coords( corners_inout[0], cut_face_in[3] );
  break;
  case BSPTreeBoxIter::B4567:
  copy_coords( corners_inout[4], cut_face_in[0] );
  copy_coords( corners_inout[5], cut_face_in[1] );
  copy_coords( corners_inout[6], cut_face_in[2] );
  copy_coords( corners_inout[7], cut_face_in[3] );
  break;
  default:
  return MB_FAILURE; // child is not a box
  }
  
  return MB_SUCCESS;
 }

References moab::BSPTreeBoxIter::B0154, moab::BSPTreeBoxIter::B1265, moab::BSPTreeBoxIter::B2376, moab::BSPTreeBoxIter::B3047, moab::BSPTreeBoxIter::B3210, moab::BSPTreeBoxIter::B4567, copy_coords(), MB_SUCCESS, and moab::BSPTreeBoxIter::side_on_plane().

Referenced by moab::BSPTreeBoxIter::step(), and moab::BSPTreeBoxIter::up().

◆ point_in_box()

static bool moab::point_in_box	(	const double	corners[8][3],
		const double	point[3]
	)

static

Definition at line 67 of file BSPTree.cpp.

 {
  const unsigned side_verts[6][3] = { { 0, 3, 1 }, { 4, 5, 7 }, { 0, 1, 4 }, { 1, 2, 5 }, { 2, 3, 6 }, { 3, 0, 7 } };
  // If we assume planar sides, then the box is the intersection
  // of 6 half-spaces defined by the planes of the sides.
  const CartVect pt( point );
  for( unsigned s = 0; s < 6; ++s )
  {
  CartVect v0( corners[side_verts[s][0]] );
  CartVect v1( corners[side_verts[s][1]] );
  CartVect v2( corners[side_verts[s][2]] );
  CartVect N = ( v1 - v0 ) * ( v2 - v0 );
  if( ( v0 - pt ) % N < 0 ) return false;
  }
  return true;
 }

Referenced by moab::BSPTreeBoxIter::initialize().

◆ point_perp()

static double moab::point_perp	(	const CartVect &	p,
		const CartVect &	b,
		const CartVect &	m
	)

static

Find closest point on line.

Find the point on the line for which a line trough the input point p and the result position is orthogonal to the input line.

Parameters

p	The point for which to find the perpendicular
b	A point on the line
m	The direction of the line

Returns: The location on the line specified as 't' in the formula t * m + b

Definition at line 73 of file OrientedBox.cpp.

 {
 #if MB_ORIENTED_BOX_UNIT_VECTORS
  double t = ( m % ( p - b ) );
 #else
  double t = ( m % ( p - b ) ) / ( m % m );
 #endif
  return Util::is_finite( t ) ? t : 0.0;
 }

References moab::Util::is_finite(), and t.

Referenced by box_from_axes().

◆ print_buff()

void moab::print_buff	(	unsigned char *	ch,
		int	size
	)

Definition at line 867 of file ParallelComm.cpp.

 {
  for( int i = 0; i < size; i++ )
  std::cout << ch[i];
  std::cout << "\n";
 }

References size.

◆ print_range()

static void moab::print_range	(	char *	buffer,
		unsigned long	begin,
		unsigned long	end
	)

static

Definition at line 232 of file DebugOutput.cpp.

 {
  assert( end > begin );
  // begin with a space
  *buffer = ' ';
  char* b1 = buffer + 1;
  // print begin-end, but keep track of where each peice is written
  char* e1 = b1 + sprintf( b1, "%lu", begin );
  *e1 = '-';
  char* b2 = e1 + 1;
  char* e2 = b2 + sprintf( b2, "%lu", end );
  // if the printed strings for both numbers don't contain the same
  // number of digits, don't do anything more
  if( e1 - b1 == e2 - b2 )
  {
  // see how many leading digits the two numbers have in common
  char* p = b2;
  while( *p && *p == *b1 )
  {
  ++p;
  ++b1;
  }
  // remove common shared leading digits from second number
  if( p > b2 && *p )
  {
  // shift second value down so that common leading digits are not repeated
  while( *p )
  {
  *b2 = *p;
  ++b2;
  ++p;
  }
  e2 = b2;
  }
  }
  // add trailing comma
  *e2 = ',';
  ++e2;
  *e2 = '\0';
 }

References buffer.

Referenced by moab::DebugOutput::list_ints_real(), and moab::DebugOutput::list_range_real().

◆ print_sequences() [1/2]

void moab::print_sequences ( const SequenceManager & seqman )

Definition at line 908 of file SequenceManager.cpp.

 {
  std::cout << seqman << std::endl;
 }

◆ print_sequences() [2/2]

void moab::print_sequences ( const TypeSequenceManager & seqman )

Definition at line 913 of file SequenceManager.cpp.

 {
  std::cout << seqman << std::endl;
 }

◆ print_type_sets()

static void moab::print_type_sets	(	Interface *	iFace,
		DebugOutput *	str,
		Range &	sets
	)

static

Definition at line 213 of file WriteHDF5Parallel.cpp.

 {
  const unsigned VB = 2;
  if( str->get_verbosity() < VB ) return;
  
  Tag gid, did, bid, sid, nid;
  gid = iFace->globalId_tag();
  iFace->tag_get_handle( GEOM_DIMENSION_TAG_NAME, 1, MB_TYPE_INTEGER, did );
  iFace->tag_get_handle( MATERIAL_SET_TAG_NAME, 1, MB_TYPE_INTEGER, bid );
  iFace->tag_get_handle( DIRICHLET_SET_TAG_NAME, 1, MB_TYPE_INTEGER, nid );
  iFace->tag_get_handle( NEUMANN_SET_TAG_NAME, 1, MB_TYPE_INTEGER, sid );
  Range typesets[10];
  const char* typenames[] = { "Block ", "Sideset ", "NodeSet", "Vertex", "Curve",
  "Surface", "Volume", "Body", "Other" };
  for( Range::iterator riter = sets.begin(); riter != sets.end(); ++riter )
  {
  unsigned dim, id; //, oldsize;
  if( MB_SUCCESS == iFace->tag_get_data( bid, &*riter, 1, &id ) )
  dim = 0;
  else if( MB_SUCCESS == iFace->tag_get_data( sid, &*riter, 1, &id ) )
  dim = 1;
  else if( MB_SUCCESS == iFace->tag_get_data( nid, &*riter, 1, &id ) )
  dim = 2;
  else if( MB_SUCCESS == iFace->tag_get_data( did, &*riter, 1, &dim ) )
  {
  id = 0;
  iFace->tag_get_data( gid, &*riter, 1, &id );
  dim += 3;
  }
  else
  {
  id = *riter;
  dim = 9;
  }
  
  // oldsize = typesets[dim].size();
  typesets[dim].insert( id );
  // assert(typesets[dim].size() - oldsize == 1);
  }
  for( int ii = 0; ii < 9; ++ii )
  {
  char tmp[64];
  sprintf( tmp, "%s (%lu) ", typenames[ii], (unsigned long)typesets[ii].size() );
  str->print( VB, tmp, typesets[ii] );
  }
  str->printf( VB, "Total: %lu\n", (unsigned long)sets.size() );
 }

References moab::Range::begin(), dim, DIRICHLET_SET_TAG_NAME, moab::Range::end(), GEOM_DIMENSION_TAG_NAME, moab::DebugOutput::get_verbosity(), moab::Interface::globalId_tag(), moab::Range::insert(), MATERIAL_SET_TAG_NAME, MB_SUCCESS, MB_TYPE_INTEGER, NEUMANN_SET_TAG_NAME, moab::DebugOutput::print(), moab::DebugOutput::printf(), size, moab::Range::size(), moab::Interface::tag_get_data(), and moab::Interface::tag_get_handle().

Referenced by moab::WriteHDF5Parallel::create_meshset_tables().

◆ putElementField()

void moab::putElementField	(	Interface *	mbi,
		const char *	tagname,
		double	factor
	)

Definition at line 30 of file addfield.cpp.

 {
  Range elems;
  
  mbi->get_entities_by_dimension( 0, 3, elems );
  
  const double defVal = 0.;
  Tag fieldTag;
  ErrorCode rval = mbi->tag_get_handle( tagname, 1, MB_TYPE_DOUBLE, fieldTag, MB_TAG_DENSE | MB_TAG_CREAT, &defVal );
  assert( MB_SUCCESS == rval );
 #ifdef NDEBUG
  if( MB_SUCCESS == rval )
  {
  }; // Line to avoid compiler warning about unused variable
 #endif
  
  int numElems = elems.size();
  
  for( int i = 0; i < numElems; i++ )
  {
  // cout << elems[i] << endl;
  EntityHandle elem = elems[i];
  
  double xyz[3];
  mbi->get_coords( &elem, 1, xyz );
  
  double fieldValue = physField( xyz[0], xyz[1], xyz[2], factor );
  
  mbi->tag_set_data( fieldTag, &elem, 1, &fieldValue );
  }
 }

References ErrorCode, moab::Interface::get_coords(), moab::Interface::get_entities_by_dimension(), MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_DOUBLE, physField(), moab::Range::size(), moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by main().

◆ putSpectralElementField()

void moab::putSpectralElementField	(	Interface *	mbi,
		int	dim,
		int	np,
		const char *	tagname,
		double	factor
	)

Definition at line 62 of file addfield.cpp.

 {
  Range elems;
  
  mbi->get_entities_by_dimension( 0, dim, elems );
  
  const int ndofperE = np * np;
  double* defDouble = new double[ndofperE];
  Tag fieldTag;
  ErrorCode rval =
  mbi->tag_get_handle( tagname, ndofperE, MB_TYPE_DOUBLE, fieldTag, MB_TAG_DENSE | MB_TAG_CREAT, &defDouble );
  std::cout << "rval = " << rval << std::endl;
  assert( MB_SUCCESS == rval || rval == MB_ALREADY_ALLOCATED );
 #ifdef NDEBUG
  if( MB_SUCCESS == rval || rval == MB_ALREADY_ALLOCATED )
  {
  }; // Line to avoid compiler warning about unused variable
 #endif
  
  int numElems = elems.size();
  std::vector< double > tData( ndofperE, 0.0 );
  
  for( int i = 0; i < numElems; i++ )
  {
  EntityHandle elem = elems[i];
  
  double xyz[3];
  mbi->get_coords( &elem, 1, xyz );
  
  double fieldValue = physField( xyz[0], xyz[1], xyz[2], factor );
  for( int j = 0; j < ndofperE; ++j )
  tData[j] = fieldValue; // same value evaluated at the center; could modify it to use
  // GLL points ?
  
  mbi->tag_set_data( fieldTag, &elem, 1, &tData[0] );
  }
  
  delete[] defDouble;
  tData.clear();
 }

References dim, ErrorCode, moab::Interface::get_coords(), moab::Interface::get_entities_by_dimension(), MB_ALREADY_ALLOCATED, MB_SUCCESS, MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_DOUBLE, physField(), moab::Range::size(), moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by main().

◆ putVertexField()

void moab::putVertexField	(	Interface *	mbi,
		const char *	tagname,
		double	factor
	)

Definition at line 103 of file addfield.cpp.

 {
  Range verts;
  
  mbi->get_entities_by_type( 0, MBVERTEX, verts );
  
  const double defVal = 0.;
  Tag fieldTag;
  mbi->tag_get_handle( tagname, 1, MB_TYPE_DOUBLE, fieldTag, MB_TAG_DENSE | MB_TAG_CREAT, &defVal );
  
  int numVerts = verts.size();
  for( int i = 0; i < numVerts; i++ )
  {
  EntityHandle vert = verts[i]; //?
  
  double vertPos[3];
  mbi->get_coords( &vert, 1, vertPos );
  
  double fieldValue = physField( vertPos[0], vertPos[1], vertPos[2], factor );
  
  mbi->tag_set_data( fieldTag, &vert, 1, &fieldValue );
  }
 }

References moab::Interface::get_coords(), moab::Interface::get_entities_by_type(), MB_TAG_CREAT, MB_TAG_DENSE, MB_TYPE_DOUBLE, MBVERTEX, physField(), moab::Range::size(), moab::Interface::tag_get_handle(), and moab::Interface::tag_set_data().

Referenced by main().

◆ QualityType_ToString()

std::string moab::QualityType_ToString ( QualityType qtype )

inline

Definition at line 60 of file VerdictWrapper.hpp.

 {
  switch( qtype )
  {
  case MB_UNDEFINED_QUALITY:
  return "MB_UNDEFINED_QUALITY";
  case MB_EDGE_RATIO:
  return "MB_EDGE_RATIO";
  case MB_MAX_EDGE_RATIO:
  return "MB_MAX_EDGE_RATIO";
  case MB_SKEW:
  return "MB_SKEW";
  case MB_TAPER:
  return "MB_TAPER";
  case MB_VOLUME:
  return "MB_VOLUME";
  case MB_STRETCH:
  return "MB_STRETCH";
  case MB_DIAGONAL:
  return "MB_DIAGONAL";
  case MB_DIMENSION:
  return "MB_DIMENSION";
  case MB_ODDY:
  return "MB_ODDY";
  case MB_MED_ASPECT_FROBENIUS:
  return "MB_MED_ASPECT_FROBENIUS";
  case MB_MAX_ASPECT_FROBENIUS:
  return "MB_MAX_ASPECT_FROBENIUS";
  case MB_CONDITION:
  return "MB_CONDITION";
  case MB_JACOBIAN:
  return "MB_JACOBIAN";
  case MB_SCALED_JACOBIAN:
  return "MB_SCALED_JACOBIAN";
  case MB_SHEAR:
  return "MB_SHEAR";
  case MB_SHAPE:
  return "MB_SHAPE";
  case MB_RELATIVE_SIZE_SQUARED:
  return "MB_RELATIVE_SIZE_SQUARED";
  case MB_SHAPE_AND_SIZE:
  return "MB_SHAPE_AND_SIZE";
  case MB_SHEAR_AND_SIZE:
  return "MB_SHEAR_AND_SIZE";
  case MB_DISTORTION:
  return "MB_DISTORTION";
  case MB_LENGTH:
  return "MB_LENGTH";
  case MB_RADIUS_RATIO:
  return "MB_RADIUS_RATIO";
  case MB_ASPECT_BETA:
  return "MB_ASPECT_BETA";
  case MB_ASPECT_RATIO:
  return "MB_ASPECT_RATIO";
  case MB_ASPECT_GAMMA:
  return "MB_ASPECT_GAMMA";
  case MB_MINIMUM_ANGLE:
  return "MB_MINIMUM_ANGLE";
  case MB_COLLAPSE_RATIO:
  return "MB_COLLAPSE_RATIO";
  case MB_WARPAGE:
  return "MB_WARPAGE";
  case MB_AREA:
  return "MB_AREA";
  case MB_MAXIMUM_ANGLE:
  return "MB_MAXIMUM_ANGLE";
  default:
  return "MB_QUALITY_COUNT";
  }
 }

References MB_AREA, MB_ASPECT_BETA, MB_ASPECT_GAMMA, MB_ASPECT_RATIO, MB_COLLAPSE_RATIO, MB_CONDITION, MB_DIAGONAL, MB_DIMENSION, MB_DISTORTION, MB_EDGE_RATIO, MB_JACOBIAN, MB_LENGTH, MB_MAX_ASPECT_FROBENIUS, MB_MAX_EDGE_RATIO, MB_MAXIMUM_ANGLE, MB_MED_ASPECT_FROBENIUS, MB_MINIMUM_ANGLE, MB_ODDY, MB_RADIUS_RATIO, MB_RELATIVE_SIZE_SQUARED, MB_SCALED_JACOBIAN, MB_SHAPE, MB_SHAPE_AND_SIZE, MB_SHEAR, MB_SHEAR_AND_SIZE, MB_SKEW, MB_STRETCH, MB_TAPER, MB_UNDEFINED_QUALITY, MB_VOLUME, and MB_WARPAGE.

◆ RANGE_SIZE()

static size_t moab::RANGE_SIZE ( const Range & rng )

inlinestatic

Definition at line 240 of file ParallelComm.cpp.

 {
  return 2 * sizeof( EntityHandle ) * rng.psize() + sizeof( int );
 }

References moab::Range::psize().

Referenced by moab::ParallelComm::estimate_sets_buffer_size(), and moab::ParallelComm::pack_sets().

◆ range_to_blocked_list_templ()

template<class HandleRangeIter >

ErrorCode moab::range_to_blocked_list_templ	(	HandleRangeIter	begin,
		HandleRangeIter	end,
		const RangeMap< EntityHandle, WriteHDF5::wid_t > &	idMap,
		std::vector< WriteHDF5::wid_t > &	output_id_list,
		bool &	ranged_list
	)

inline

Definition at line 1632 of file WriteHDF5.cpp.

 {
  output_id_list.clear();
  if( begin == end )
  {
  ranged_list = false;
  return MB_SUCCESS;
  }
  
  // First try ranged format, but give up if we reach the
  // non-range format size.
  RangeMap< EntityHandle, WriteHDF5::wid_t >::iterator ri = idMap.begin();
  
  const size_t num_handles = count_num_handles( begin, end );
  // If we end up with more than this many range blocks, then
  // we're better off just writing the set as a simple list
  size_t pairs_remaining = num_handles / 2;
  for( HandleRangeIter pi = begin; pi != end; ++pi )
  {
  EntityHandle h = pi->first;
  WriteHDF5::wid_t local_mapped_from_subrange = 0;
  while( h <= pi->second )
  {
  ri = idMap.lower_bound( ri, idMap.end(), h );
  if( ri == idMap.end() || ri->begin > h )
  {
  ++h;
  continue;
  }
  
  WriteHDF5::wid_t n = pi->second - pi->first + 1 - local_mapped_from_subrange;
  if( n > ri->count ) n = ri->count;
  
  WriteHDF5::wid_t id = ri->value + ( h - ri->begin );
  // see if we can go to the end of the range
  if( id + n > ri->value + ri->count ) // we have to reduce n, because we cannot go over next subrange
  {
  if( ri->value + ri->count - id > 0 ) n = ri->value + ri->count - id;
  }
  
  // See if we can append it to the previous range
  if( !output_id_list.empty() && output_id_list[output_id_list.size() - 2] + output_id_list.back() == id )
  {
  output_id_list.back() += n;
  }
  
  // If we ran out of space, (or set is empty) just do list format
  else if( !pairs_remaining )
  {
  ranged_list = false;
  output_id_list.resize( num_handles );
  range_to_id_list_templ( begin, end, idMap, &output_id_list[0] );
  output_id_list.erase( std::remove( output_id_list.begin(), output_id_list.end(), 0u ),
  output_id_list.end() );
  return MB_SUCCESS;
  }
  
  //
  else
  {
  --pairs_remaining;
  output_id_list.push_back( id );
  output_id_list.push_back( n );
  }
  local_mapped_from_subrange += n; // we already mapped so many
  h += n;
  }
  }
  
  ranged_list = true;
  return MB_SUCCESS;
 }

References moab::RangeMap< KeyType, ValType, NullVal >::back(), moab::RangeMap< KeyType, ValType, NullVal >::begin(), count_num_handles(), moab::RangeMap< KeyType, ValType, NullVal >::end(), moab::RangeMap< KeyType, ValType, NullVal >::lower_bound(), MB_SUCCESS, and range_to_id_list_templ().

Referenced by moab::WriteHDF5::range_to_blocked_list().

◆ range_to_id_list_templ()

template<class HandleRangeIter >

ErrorCode moab::range_to_id_list_templ	(	HandleRangeIter	begin,
		HandleRangeIter	end,
		const RangeMap< EntityHandle, WriteHDF5::wid_t > &	idMap,
		WriteHDF5::wid_t *	array
	)

inline

Definition at line 1589 of file WriteHDF5.cpp.

 {
  ErrorCode rval = MB_SUCCESS;
  RangeMap< EntityHandle, WriteHDF5::wid_t >::iterator ri = idMap.begin();
  WriteHDF5::wid_t* i = array;
  for( HandleRangeIter pi = begin; pi != end; ++pi )
  {
  EntityHandle h = pi->first;
  while( h <= pi->second )
  {
  ri = idMap.lower_bound( ri, idMap.end(), h );
  if( ri == idMap.end() || ri->begin > h )
  {
  rval = MB_ENTITY_NOT_FOUND;
  *i = 0;
  ++i;
  ++h;
  continue;
  }
  
  // compute the last available value of the found target range (ri iterator)
  WriteHDF5::wid_t last_valid_input_value_in_current_map_range = ri->begin + ri->count - 1;
  // limit the number of steps we do on top of h so we do not overflow the output range
  // span
  WriteHDF5::wid_t step_until = std::min( last_valid_input_value_in_current_map_range, pi->second );
  WriteHDF5::wid_t n = step_until - h + 1;
  assert( n > 0 ); // We must at least step 1
  
  WriteHDF5::wid_t id = ri->value + ( h - ri->begin );
  for( WriteHDF5::wid_t j = 0; j < n; ++i, ++j )
  *i = id + j;
  h += n;
  }
  }
  
  assert( i == array + count_num_handles( begin, end ) );
  return rval;
 }

References moab::RangeMap< KeyType, ValType, NullVal >::begin(), count_num_handles(), moab::RangeMap< KeyType, ValType, NullVal >::end(), ErrorCode, moab::RangeMap< KeyType, ValType, NullVal >::lower_bound(), MB_ENTITY_NOT_FOUND, and MB_SUCCESS.

Referenced by range_to_blocked_list_templ(), and moab::WriteHDF5::range_to_id_list().

◆ ray_intersect_halfspaces()

template<typename PlaneIter >

static bool moab::ray_intersect_halfspaces	(	const CartVect &	ray_pt,
		const CartVect &	ray_dir,
		const PlaneIter &	begin,
		const PlaneIter &	end,
		double &	t_enter,
		double &	t_exit
	)

inlinestatic

Definition at line 1179 of file BSPTree.cpp.

 {
  const double epsilon = 1e-12;
  
  // begin with inifinite ray
  t_enter = 0.0;
  t_exit = std::numeric_limits< double >::infinity();
  
  // cut ray such that we keep only the portion contained
  // in each halfspace
  for( PlaneIter i = begin; i != end; ++i )
  {
  CartVect norm( i->norm );
  double coeff = i->coeff;
  double den = norm % ray_dir;
  if( fabs( den ) < epsilon )
  { // ray is parallel to plane
  if( i->above( ray_pt.array() ) ) return false; // ray entirely outside half-space
  }
  else
  {
  double t_xsect = ( -coeff - ( norm % ray_pt ) ) / den;
  // keep portion of ray/segment below plane
  if( den > 0 )
  {
  if( t_xsect < t_exit ) t_exit = t_xsect;
  }
  else
  {
  if( t_xsect > t_enter ) t_enter = t_xsect;
  }
  }
  }
  
  return t_exit >= t_enter;
 }

References moab::CartVect::array().

Referenced by moab::BSPTreeIter::intersect_ray(), and moab::BSPTreeBoxIter::intersect_ray().

◆ ReleaseInterface()

MB_EXPORT void moab::ReleaseInterface ( UnknownInterface * iface )

Definition at line 141 of file Factory.cpp.

 {
  if( !iface ) return;
  // remove this object from our list and delete it
  ComponentFactory::objects_in_use.remove( iface );
  delete iface;
 }

References iface, and moab::ComponentFactory::objects_in_use.

◆ remove_from_vector()

static MeshSet::Count moab::remove_from_vector	(	const MeshSet::Count	count,
		MeshSet::CompactList &	list,
		const EntityHandle	h,
		int &	result
	)

inlinestatic

Remvoe from parent/child list.

Definition at line 162 of file MeshSet.cpp.

 {
  switch( count )
  {
  case MeshSet::ZERO:
  result = false;
  return MeshSet::ZERO;
  case MeshSet::ONE:
  if( h == list.hnd[0] )
  {
  result = true;
  return MeshSet::ZERO;
  }
  else
  {
  result = false;
  return MeshSet::ONE;
  }
  case MeshSet::TWO:
  if( h == list.hnd[0] )
  {
  list.hnd[0] = list.hnd[1];
  result = true;
  return MeshSet::ONE;
  }
  else if( h == list.hnd[1] )
  {
  result = true;
  return MeshSet::ONE;
  }
  else
  {
  result = false;
  return MeshSet::TWO;
  }
  case MeshSet::MANY: {
  EntityHandle *i, *j, *p;
  i = std::find( list.ptr[0], list.ptr[1], h );
  if( i == list.ptr[1] )
  {
  result = false;
  return MeshSet::MANY;
  }
  
  result = true;
  p = list.ptr[1] - 1;
  while( i != p )
  {
  j = i + 1;
  *i = *j;
  i = j;
  }
  int size = p - list.ptr[0];
  if( size == 2 )
  {
  p = list.ptr[0];
  list.hnd[0] = p[0];
  list.hnd[1] = p[1];
  free( p );
  return MeshSet::TWO;
  }
  else
  {
  list.ptr[0] = (EntityHandle*)realloc( list.ptr[0], size * sizeof( EntityHandle ) );
  list.ptr[1] = list.ptr[0] + size;
  return MeshSet::MANY;
  }
  }
  }
  
  return MeshSet::ZERO;
 }

References moab::MeshSet::CompactList::hnd, moab::MeshSet::MANY, moab::MeshSet::ONE, moab::MeshSet::CompactList::ptr, size, moab::MeshSet::TWO, and moab::MeshSet::ZERO.

Referenced by main(), moab::MeshSet::remove_child(), and moab::MeshSet::remove_parent().

◆ resize_compact_list()

static EntityHandle * moab::resize_compact_list	(	MeshSet::Count &	count,
		MeshSet::CompactList &	clist,
		size_t	new_list_size
	)

static

Resize MeshSet::CompactList. Returns pointer to storage.

Definition at line 390 of file MeshSet.cpp.

 {
  if( count <= 2 )
  {
  if( new_list_size <= 2 )
  {
  count = (MeshSet::Count)new_list_size;
  return clist.hnd;
  }
  else
  {
  EntityHandle* list = (EntityHandle*)malloc( new_list_size * sizeof( EntityHandle ) );
  list[0] = clist.hnd[0];
  list[1] = clist.hnd[1];
  clist.ptr[0] = list;
  clist.ptr[1] = list + new_list_size;
  count = MeshSet::MANY;
  return list;
  }
  }
  else if( new_list_size > 2 )
  {
  if( new_list_size > (size_t)( clist.ptr[1] - clist.ptr[0] ) )
  clist.ptr[0] = (EntityHandle*)realloc( clist.ptr[0], new_list_size * sizeof( EntityHandle ) );
  clist.ptr[1] = clist.ptr[0] + new_list_size;
  count = MeshSet::MANY;
  return clist.ptr[0];
  }
  else
  {
  EntityHandle* list = clist.ptr[0];
  clist.hnd[0] = list[0];
  clist.hnd[1] = list[1];
  free( list );
  count = (MeshSet::Count)new_list_size;
  return clist.hnd;
  }
 }

References moab::MeshSet::CompactList::hnd, moab::MeshSet::MANY, and moab::MeshSet::CompactList::ptr.

Referenced by moab::MeshSet::convert(), moab::range_tool< pair_iter_t >::ranged_insert_entities(), moab::range_tool< pair_iter_t >::ranged_remove_entities(), moab::range_tool< pair_iter_t >::vector_insert_entities(), vector_insert_vector(), vector_remove_range(), vector_remove_ranges(), and vector_remove_vector().

◆ rev_permute_this()

template<typename T >

int moab::rev_permute_this	(	EntityType	t,
		const int	dim,
		T *	conn,
		const int	indices_per_ent,
		const int	num_entries
	)

inline

Definition at line 1048 of file CN.cpp.

 {
  T tmp_conn[MAX_SUB_ENTITIES];
  assert( indices_per_ent <= CN::revPermuteVec[t][dim][MAX_SUB_ENTITIES] );
  if( indices_per_ent > CN::revPermuteVec[t][dim][MAX_SUB_ENTITIES] ) return 1;
  short int* tvec = CN::revPermuteVec[t][dim];
  T* pvec = conn;
  for( int j = 0; j < num_entries; j++ )
  {
  for( int i = 0; i < indices_per_ent; i++ )
  tmp_conn[i] = pvec[tvec[i]];
  memcpy( pvec, tmp_conn, indices_per_ent * sizeof( T ) );
  pvec += indices_per_ent;
  }
  
  return 0;
 }

References dim, MAX_SUB_ENTITIES, moab::CN::revPermuteVec, t, and T.

Referenced by moab::CN::revPermuteThis().

◆ set_bit()

static void moab::set_bit	(	int	position,
		unsigned char *	bytes
	)

static

Definition at line 739 of file WriteHDF5Parallel.cpp.

 {
  int byte = position / 8;
  int bit = position % 8;
  bytes[byte] |= ( ( (unsigned char)1 ) << bit );
 }

Referenced by moab::WriteHDF5Parallel::create_tag_tables().

◆ set_map_intersect()

static bool moab::set_map_intersect	(	bool	ranged,
		const long *	contents,
		int	content_len,
		const RangeMap< long, EntityHandle > &	id_map
	)

static

Definition at line 2159 of file ReadHDF5.cpp.

 {
  if( ranged )
  {
  if( !content_len || id_map.empty() ) return false;
  
  const long* j = contents;
  const long* const end = contents + content_len;
  assert( content_len % 2 == 0 );
  while( j != end )
  {
  long start = *( j++ );
  long count = *( j++ );
  if( id_map.intersects( start, count ) ) return true;
  }
  }
  else
  {
  const long* const end = contents + content_len;
  for( const long* i = contents; i != end; ++i )
  if( id_map.exists( *i ) ) return true;
  }
  
  return false;
 }

References moab::RangeMap< KeyType, ValType, NullVal >::empty(), moab::RangeMap< KeyType, ValType, NullVal >::exists(), and moab::RangeMap< KeyType, ValType, NullVal >::intersects().

Referenced by moab::ReadHDF5::find_sets_containing().

◆ side_number()

template<typename T >

static short int moab::side_number	(	const T *	parent_conn,
		const EntityType	parent_type,
		const T *	child_conn,
		const int	child_num_verts,
		const int	child_dim,
		int &	side_no,
		int &	sense,
		int &	offset
	)

static

Definition at line 218 of file CN.cpp.

 {
  int parent_num_verts = CN::VerticesPerEntity( parent_type );
  int side_indices[8];
  assert( sizeof( side_indices ) / sizeof( side_indices[0] ) >= (size_t)child_num_verts );
  
  for( int i = 0; i < child_num_verts; i++ )
  {
  side_indices[i] = std::find( parent_conn, parent_conn + parent_num_verts, child_conn[i] ) - parent_conn;
  if( side_indices[i] == parent_num_verts ) return -1;
  }
  
  return CN::SideNumber( parent_type, &side_indices[0], child_num_verts, child_dim, side_no, sense, offset );
 }

References moab::CN::SideNumber(), and moab::CN::VerticesPerEntity().

Referenced by create_fine_mesh(), fill_coord_on_edges(), iMOAB_GetPointerToSurfaceBC(), MBCN_SideNumberInt(), MBCN_SideNumberLong(), MBCN_SideNumberUint(), MBCN_SideNumberUlong(), MBCN_SideNumberVoid(), moab::CN::SideNumber(), and moab::HigherOrderFactory::tag_for_deletion().

◆ split_box()

static ErrorCode moab::split_box	(	Interface *	instance,
		const OrientedBox &	box,
		int	axis,
		const Range &	entities,
		Range &	left_list,
		Range &	right_list
	)

static

Split triangles by which side of a plane they are on.

Given a plane specified as a bisecting plane normal to one of the axes of a box, split triangles based on which side of the plane they are on.

Parameters

instance	MOAB instance
box	The oriented box containing all the entities
axis	The axis for which the split plane is orthogonal
entities	The entities intersecting plane
left_list	Output, entities to the left of the plane
right_list	Output, entities to the right of the plane

Definition at line 167 of file OrientedBoxTreeTool.cpp.

 {
  ErrorCode rval;
  left_list.clear();
  right_list.clear();
  
  std::vector< CartVect > coords;
  for( Range::reverse_iterator i = entities.rbegin(); i != entities.rend(); ++i )
  {
  const EntityHandle* conn = NULL;
  int conn_len = 0;
  rval = instance->get_connectivity( *i, conn, conn_len );
  if( MB_SUCCESS != rval ) return rval;
  
  coords.resize( conn_len );
  rval = instance->get_coords( conn, conn_len, coords[0].array() );
  if( MB_SUCCESS != rval ) return rval;
  
  CartVect centroid( 0.0 );
  for( int j = 0; j < conn_len; ++j )
  centroid += coords[j];
  centroid /= conn_len;
  
  if( ( box.axis( axis ) % ( centroid - box.center ) ) < 0.0 )
  left_list.insert( *i );
  else
  right_list.insert( *i );
  }
  
  return MB_SUCCESS;
 }

References moab::OrientedBoxTreeTool::box(), moab::Range::clear(), entities, ErrorCode, moab::Interface::get_connectivity(), moab::Interface::get_coords(), moab::Range::insert(), moab::OrientedBoxTreeTool::instance, and MB_SUCCESS.

Referenced by moab::OrientedBoxTreeTool::build_tree().

◆ split_edge()

static BSPTreePoly::Edge * moab::split_edge	(	BSPTreePoly::Vertex *&	new_vtx,
		BSPTreePoly::Edge *	into_edge
	)

static

Definition at line 546 of file BSPTreePoly.cpp.

 {
  // split edge, creating new edge
  BSPTreePoly::Edge* new_edge = new BSPTreePoly::Edge( new_vtx, into_edge->end() );
  into_edge->endPtr->set_vertex( new_vtx ); // This call might delete new_vtx
  
  // update coedge loops in faces
  if( into_edge->forwardPtr )
  {
  new_edge->forwardPtr = new BSPTreePoly::EdgeUse( new_edge );
  new_edge->forwardPtr->insert_after( into_edge->forwardPtr );
  }
  if( into_edge->reversePtr )
  {
  new_edge->reversePtr = new BSPTreePoly::EdgeUse( new_edge );
  new_edge->reversePtr->insert_before( into_edge->reversePtr );
  }
  
  return new_edge;
 }

References moab::BSPTreePoly::Edge::end(), moab::BSPTreePoly::Edge::endPtr, moab::BSPTreePoly::Edge::forwardPtr, moab::BSPTreePoly::EdgeUse::insert_after(), moab::BSPTreePoly::EdgeUse::insert_before(), moab::BSPTreePoly::Edge::reversePtr, and moab::BSPTreePoly::VertexUse::set_vertex().

Referenced by moab::BSPTreePoly::cut_polyhedron().

◆ split_face()

static BSPTreePoly::Face* moab::split_face	(	BSPTreePoly::EdgeUse *	start,
		BSPTreePoly::EdgeUse *	end
	)

static

Definition at line 567 of file BSPTreePoly.cpp.

 {
  BSPTreePoly::Face* face = start->facePtr;
  assert( face == end->facePtr );
  BSPTreePoly::Face* new_face = new BSPTreePoly::Face;
  BSPTreePoly::EdgeUse* keep_start = start->prevPtr;
  BSPTreePoly::EdgeUse* keep_end = end->nextPtr;
  for( BSPTreePoly::EdgeUse* ptr = start; ptr != keep_end; ptr = ptr->nextPtr )
  {
  if( face->usePtr == ptr ) face->usePtr = keep_start;
  ptr->facePtr = new_face;
  }
  new_face->usePtr = start;
  BSPTreePoly::Edge* edge = new BSPTreePoly::Edge( start->start(), end->end() );
  edge->forwardPtr = new BSPTreePoly::EdgeUse( edge );
  edge->reversePtr = new BSPTreePoly::EdgeUse( edge );
  
  edge->forwardPtr->facePtr = face;
  edge->forwardPtr->prevPtr = keep_start;
  keep_start->nextPtr = edge->forwardPtr;
  edge->forwardPtr->nextPtr = keep_end;
  keep_end->prevPtr = edge->forwardPtr;
  
  edge->reversePtr->facePtr = new_face;
  edge->reversePtr->nextPtr = start;
  start->prevPtr = edge->reversePtr;
  edge->reversePtr->prevPtr = end;
  end->nextPtr = edge->reversePtr;
  
  return new_face;
 }

References moab::BSPTreePoly::EdgeUse::end(), moab::BSPTreePoly::EdgeUse::facePtr, moab::BSPTreePoly::EdgeUse::nextPtr, moab::BSPTreePoly::EdgeUse::prevPtr, moab::BSPTreePoly::EdgeUse::start(), and moab::BSPTreePoly::Face::usePtr.

Referenced by moab::BSPTreePoly::cut_polyhedron().

◆ split_sets()

static ErrorCode moab::split_sets	(	Interface *	,
		const OrientedBox &	box,
		int	axis,
		const std::list< OrientedBoxTreeTool::SetData > &	sets,
		std::list< OrientedBoxTreeTool::SetData > &	left,
		std::list< OrientedBoxTreeTool::SetData > &	right
	)

static

Definition at line 317 of file OrientedBoxTreeTool.cpp.

 {
  left.clear();
  right.clear();
  
  std::list< OrientedBoxTreeTool::SetData >::const_iterator i;
  for( i = sets.begin(); i != sets.end(); ++i )
  {
  CartVect centroid( i->box_data.center / i->box_data.area );
  if( ( box.axis( axis ) % ( centroid - box.center ) ) < 0.0 )
  left.push_back( *i );
  else
  right.push_back( *i );
  }
  
  return MB_SUCCESS;
 }

References moab::OrientedBoxTreeTool::box(), and MB_SUCCESS.

Referenced by moab::OrientedBoxTreeTool::build_sets().

◆ STATIC_ASSERT() [1/2]

moab::STATIC_ASSERT ( (sizeof(DatasetVals)==3 *sizeof(long)) )

◆ STATIC_ASSERT() [2/2]

moab::STATIC_ASSERT ( sizeof(unsigned long) >=sizeof(EntityHandle) )

Referenced by merge_ranged_ids().

◆ std_dev()

static double moab::std_dev	(	double	sqr,
		double	sum,
		double	count
	)

inlinestatic

Definition at line 1878 of file OrientedBoxTreeTool.cpp.

 {
  sum /= count;
  sqr /= count;
  return sqrt( sqr - sum * sum );
 }

References sum().

Referenced by moab::OrientedBoxTreeTool::stats(), and TriStats::write_results().

◆ strempty()

static bool moab::strempty ( const char * s )

inlinestatic

Definition at line 33 of file FileOptions.cpp.

 {
  return !*s;
 }

Referenced by moab::FileOptions::compare(), moab::FileOptions::FileOptions(), moab::FileOptions::get_int_option(), moab::FileOptions::get_ints_option(), moab::FileOptions::get_null_option(), moab::FileOptions::get_real_option(), moab::FileOptions::get_reals_option(), moab::FileOptions::get_str_option(), and moab::FileOptions::get_strs_option().

◆ subtr()

static void moab::subtr	(	double	result[3],
		const double	a[3],
		const double	b[3]
	)

static

Definition at line 914 of file BSPTree.cpp.

 {
  result[0] = a[0] - b[0];
  result[1] = a[1] - b[1];
  result[2] = a[2] - b[2];
 }

Referenced by moab::BSPTreeBoxIter::volume().

◆ subtract()

Range moab::subtract	(	const Range &	from,
		const Range &	range2
	)

subtract range2 from this, placing the results in the return range

Examples: DeformMeshRemap.cpp.

Definition at line 664 of file Range.cpp.

 {
  const bool braindead = false;
  
  if( braindead )
  {
  // brain-dead implementation right now
  Range res( range1 );
  for( Range::const_iterator rit = range2.begin(); rit != range2.end(); ++rit )
  res.erase( *rit );
  
  return res;
  }
  else
  {
  Range lhs( range1 );
  
  Range::pair_iterator r_it0 = lhs.pair_begin();
  Range::const_pair_iterator r_it1 = range2.const_pair_begin();
  
  // terminate the while loop when at least one "start" iterator is at the
  // end of the list
  while( r_it0 != lhs.end() && r_it1 != range2.end() )
  {
  // case a: pair wholly within subtracted pair
  if( r_it0->first >= r_it1->first && r_it0->second <= r_it1->second )
  {
  Range::PairNode* rtmp = r_it0.node();
  ++r_it0;
  lhs.delete_pair_node( rtmp );
  }
  // case b: pair overlaps upper part of subtracted pair
  else if( r_it0->first <= r_it1->second && r_it0->first >= r_it1->first )
  {
  r_it0->first = r_it1->second + 1;
  ++r_it1;
  }
  // case c: pair overlaps lower part of subtracted pair
  else if( r_it0->second >= r_it1->first && r_it0->second <= r_it1->second )
  {
  r_it0->second = r_it1->first - 1;
  ++r_it0;
  }
  // case d: pair completely surrounds subtracted pair
  else if( r_it0->first < r_it1->first && r_it0->second > r_it1->second )
  {
  Range::PairNode* new_node =
  alloc_pair( r_it0.node(), r_it0.node()->mPrev, r_it0->first, r_it1->first - 1 );
  new_node->mPrev->mNext = new_node->mNext->mPrev = new_node;
  r_it0.node()->first = r_it1->second + 1;
  ++r_it1;
  }
  else
  {
  while( r_it0->second < r_it1->first && r_it0 != lhs.end() )
  ++r_it0;
  if( r_it0 == lhs.end() ) break;
  while( r_it1->second < r_it0->first && r_it1 != range2.end() )
  ++r_it1;
  }
  }
  
  return lhs;
  }
 }

Referenced by add_dead_elems_to_impl_compl(), moab::ParallelComm::assign_global_ids(), moab::GeomTopoTool::check_model(), moab::Core::clean_up_failed_read(), cleanup_after_intersection(), compute_tracer_case1(), moab::TempestRemapper::ComputeOverlapMesh(), moab::WriteHDF5Parallel::create_meshset_tables(), IntxUtilsCSLAM::create_span_quads(), DeformMeshRemap::deform_master(), moab::Core::delete_entities(), moab::ReadHDF5::delete_non_side_elements(), moab::ReadParallel::delete_nonlocal_entities(), dot_get_sets(), dot_nodes(), moab::ParallelComm::exchange_owned_mesh(), moab::ParallelComm::exchange_owned_meshs(), DeformMeshRemap::find_other_sets(), moab::DualTool::foc_get_ents(), moab::DualTool::fsr_get_fourth_quad(), moab::WriteHDF5Parallel::gather_interface_meshes(), moab::WriteNCDF::gather_mesh_information(), moab::MeshTopoUtil::get_bridge_adjacencies(), moab::Core::get_entities_by_type_and_tag(), moab::DualTool::get_opposite_verts(), moab::ParallelComm::get_sent_ents(), moab::FBEngine::getAdjacentEntities(), moab::TempestRemapper::GetOverlapAugmentedEntities(), moab::FBEngine::gsubtract(), iMOAB_DeregisterApplication(), iMOAB_UpdateMeshInfo(), moab::MeshSet::intersect(), moab::Tqdcfr::load_file(), moab::Coupler::locate_points(), main(), moab::MergeMesh::merge_all(), moab::DualTool::next_loop_vertex(), moab::Tqdcfr::read_nodes(), moab::ReadNCDF::read_nodesets(), moab::ReadHDF5::read_set_ids_recursive(), moab::ReadNCDF::read_sidesets(), moab::ParCommGraph::receive_mesh(), ZoltanPartitioner::repartition(), moab::ParallelComm::resolve_shared_sets(), moab::DualTool::rev_atomic_pillow(), moab::ParallelComm::send_entities(), moab::FBEngine::separate(), moab::Core::serial_load_file(), moab::FBEngine::smooth_new_intx_points(), moab::MeshTopoUtil::split_entity_nonmanifold(), moab::FBEngine::split_internal_edge(), moab::ParCommGraph::split_owned_range(), moab::ParallelComm::tag_iface_entities(), moab::DualTool::traverse_hyperplane(), moab::WriteVtk::write_elems(), and moab::IODebugTrack::~IODebugTrack().

◆ sum()

static void moab::sum	(	double	result[3],
		const double	a[3],
		const double	b[3],
		const double	c[3],
		const double	d[3]
	)

static

Definition at line 922 of file BSPTree.cpp.

 {
  result[0] = a[0] + b[0] + c[0] + d[0];
  result[1] = a[1] + b[1] + c[1] + d[1];
  result[2] = a[2] + b[2] + c[2] + d[2];
 }

Referenced by moab::StatData::Ratio::accum(), moab::StatData::Stat< T >::accum(), stat_set::add(), moab::SimpleStat< T >::add(), moab::TypeSequenceManager::append_memory_use(), moab::HiReconstruction::check_barycentric_coords(), moab::TagInfo::check_valid_sizes(), stat_set::clear(), moab::GeomTopoTool::get_bounding_coords(), moab::SequenceManager::get_number_entities(), moab::MeshSetSequence::get_per_entity_memory_use(), hash_build_2(), hash_build_3(), inner(), moab::element_utility::Linear_tet_map< Entity_handle, Matrix >::is_contained(), TriStats::leaf(), lobatto_to_legendre(), ZoltanPartitioner::mbInitializePoints(), measure(), mxv_r(), obbvis_create(), moab::GeomQueryTool::point_in_volume(), moab::GeomQueryTool::point_in_volume_slow(), moab::TupleList::radix_offsets(), moab::BSPTreePoly::Face::signed_volume(), std_dev(), std_dev(), moab::BSPTreeBoxIter::volume(), and TriStats::write_results().

◆ swap4_uint()

static void moab::swap4_uint ( unsigned int * data )

static

Definition at line 168 of file Tqdcfr.cpp.

 {
  unsigned char tmp, *cdat = (unsigned char*)data;
  tmp = cdat[0];
  cdat[0] = cdat[3], cdat[3] = tmp;
  tmp = cdat[1];
  cdat[1] = cdat[2], cdat[2] = tmp;
 }

Referenced by moab::Tqdcfr::FREADIA().

◆ swap8_voff()

static void moab::swap8_voff ( long * data )

static

Definition at line 155 of file Tqdcfr.cpp.

 {
  unsigned char tmp, *cdat = (unsigned char*)data;
  tmp = cdat[0];
  cdat[0] = cdat[7], cdat[7] = tmp;
  tmp = cdat[1];
  cdat[1] = cdat[6], cdat[6] = tmp;
  tmp = cdat[2];
  cdat[2] = cdat[5], cdat[5] = tmp;
  tmp = cdat[3];
  cdat[3] = cdat[4], cdat[4] = tmp;
 }

Referenced by moab::Tqdcfr::FREADDA().

◆ TYPE_FROM_HANDLE()

EntityType moab::TYPE_FROM_HANDLE ( EntityHandle handle )

inline

Get the type out of the handle. Can do a simple shift because handles are unsigned (therefore shifting fills with zero's)

Definition at line 92 of file Internals.hpp.

 {
  return static_cast< EntityType >( handle >> MB_ID_WIDTH );
 }

References MB_ID_WIDTH.

◆ type_range()

static std::pair< EntityType, EntityType > moab::type_range ( EntityType type )

inlinestatic

Definition at line 524 of file TagCompare.hpp.

 {
  if( type == MBMAXTYPE )
  return std::pair< EntityType, EntityType >( MBVERTEX, MBMAXTYPE );
  else
  {
  EntityType next = type;
  ++next;
  return std::pair< EntityType, EntityType >( type, next );
  }
 }

References MBMAXTYPE, and MBVERTEX.

Referenced by moab::VarLenDenseTag::find_entities_with_value(), moab::DenseTag::find_entities_with_value(), moab::BitTag::get_entities_with_bits(), get_tagged(), moab::BitTag::get_tagged(), and moab::DenseTag::get_tagged_entities().

◆ unit()

CartVect moab::unit ( const CartVect & v )

inline

Get unit vector in same direction.

Definition at line 249 of file CartVect.hpp.

 {
  const double len = v.length();
  return CartVect( v[0] / len, v[1] / len, v[2] / len );
 }

References moab::CartVect::length().

Referenced by mem_to_string().

◆ unite()

Range moab::unite	(	const Range &	r1,
		const Range &	r2
	)

inline

unite two ranges, placing the results in the return range

Definition at line 773 of file Range.hpp.

 {
  Range r( r1 );
  r.insert( r2.begin(), r2.end() );
  return r;
 }

References moab::Range::begin(), moab::Range::end(), and moab::Range::insert().

Referenced by ZoltanPartitioner::repartition(), and moab::FBEngine::separate().

◆ UNPACK()

template<typename T >

static void moab::UNPACK	(	unsigned char *&	buff,
		T *	val,
		size_t	count
	)

inlinestatic

Definition at line 91 of file ParallelComm.cpp.

 {
  memcpy( val, buff, count * sizeof( T ) );
  buff += count * sizeof( T );
 }

References T.

Referenced by UNPACK_DBLS(), UNPACK_EH(), UNPACK_INTS(), and UNPACK_VOID().

◆ UNPACK_DBL()

static void moab::UNPACK_DBL	(	unsigned char *&	buff,
		double &	dbl_val
	)

inlinestatic

Definition at line 180 of file ParallelComm.cpp.

 {
  UNPACK_DBLS( buff, &dbl_val, 1 );
 }

References UNPACK_DBLS().

Referenced by moab::ParallelComm::print_buffer().

◆ UNPACK_DBLS()

static void moab::UNPACK_DBLS	(	unsigned char *&	buff,
		double *	dbl_val,
		size_t	num
	)

inlinestatic

Definition at line 174 of file ParallelComm.cpp.

 {
  UNPACK( buff, dbl_val, num );
  UPC( num, " doubles" );
 }

References UNPACK(), and UPC.

Referenced by moab::ParallelComm::print_buffer(), moab::ParallelComm::settle_intersection_points(), UNPACK_DBL(), and moab::ParallelComm::unpack_entities().

◆ UNPACK_EH()

static void moab::UNPACK_EH	(	unsigned char *&	buff,
		EntityHandle *	eh_val,
		size_t	num
	)

inlinestatic

Definition at line 185 of file ParallelComm.cpp.

 {
  UNPACK( buff, eh_val, num );
  UPC( num, " handles" );
 }

References UNPACK(), and UPC.

Referenced by moab::ParallelComm::print_buffer(), moab::ParallelComm::send_recv_entities(), moab::ParallelComm::settle_intersection_points(), moab::ParallelComm::unpack_entities(), UNPACK_RANGE(), moab::ParallelComm::unpack_remote_handles(), moab::ParallelComm::unpack_sets(), and moab::ParallelComm::unpack_tags().

◆ UNPACK_INT()

static void moab::UNPACK_INT	(	unsigned char *&	buff,
		int &	int_val
	)

inlinestatic

Definition at line 169 of file ParallelComm.cpp.

 {
  UNPACK_INTS( buff, &int_val, 1 );
 }

References UNPACK_INTS().

Referenced by moab::ParallelComm::print_buffer(), moab::ParallelComm::settle_intersection_points(), moab::ParallelComm::unpack_entities(), UNPACK_RANGE(), moab::ParallelComm::unpack_remote_handles(), moab::ParallelComm::unpack_sets(), moab::ParallelComm::unpack_tags(), and UNPACK_TYPE().

◆ UNPACK_INTS()

static void moab::UNPACK_INTS	(	unsigned char *&	buff,
		int *	int_val,
		size_t	num
	)

inlinestatic

Definition at line 163 of file ParallelComm.cpp.

 {
  UNPACK( buff, int_val, num );
  UPC( num, " ints" );
 }

References UNPACK(), and UPC.

Referenced by moab::ParallelComm::print_buffer(), moab::ParallelComm::send_recv_entities(), moab::ParallelComm::unpack_entities(), UNPACK_INT(), moab::ParallelComm::unpack_sets(), and moab::ParallelComm::unpack_tags().

◆ UNPACK_RANGE()

static void moab::UNPACK_RANGE	(	unsigned char *&	buff,
		Range &	rng
	)

inlinestatic

Definition at line 213 of file ParallelComm.cpp.

 {
  int num_subs;
  EntityHandle eh[2];
  UNPACK_INT( buff, num_subs );
  for( int i = 0; i < num_subs; i++ )
  {
  UPC( num_subs, "-subranged range" );
  UNPACK_EH( buff, eh, 2 );
  rng.insert( eh[0], eh[1] );
  }
 }

References moab::Range::insert(), UNPACK_EH(), UNPACK_INT(), and UPC.

Referenced by moab::ParallelComm::unpack_sets().

◆ unpack_tuples()

void unpack_tuples	(	void *	ptr,
		TupleList **	tlp
	)

Definition at line 1889 of file Coupler.cpp.

 {
  TupleList* tl = new TupleList();
  *tlp = tl;
  
  uint nt;
  unsigned mit, mlt, mult, mrt;
  uint* buf = (uint*)ptr;
  
  // Get n
  memcpy( &nt, buf, sizeof( uint ) ), buf += 1;
  // Get mi
  memcpy( &mit, buf, sizeof( unsigned ) ), buf += UINT_PER_UNSIGNED;
  // Get ml
  memcpy( &mlt, buf, sizeof( unsigned ) ), buf += UINT_PER_UNSIGNED;
  // Get mul
  memcpy( &mult, buf, sizeof( unsigned ) ), buf += UINT_PER_UNSIGNED;
  // Get mr
  memcpy( &mrt, buf, sizeof( unsigned ) ), buf += UINT_PER_UNSIGNED;
  
  // Initialize tl
  tl->initialize( mit, mlt, mult, mrt, nt );
  tl->enableWriteAccess();
  tl->set_n( nt );
  
  uint mi, ml, mul, mr;
  tl->getTupleSize( mi, ml, mul, mr );
  
  // Get vi_rd
  memcpy( tl->vi_wr, buf, tl->get_n() * mi * sizeof( sint ) ), buf += tl->get_n() * mi;
  // Get vl_rd
  memcpy( tl->vl_wr, buf, tl->get_n() * ml * sizeof( slong ) ), buf += tl->get_n() * ml * UINT_PER_LONG;
  // Get vul_rd
  memcpy( tl->vul_wr, buf, tl->get_n() * mul * sizeof( ulong ) ), buf += tl->get_n() * mul * UINT_PER_LONG;
  // Get vr_rd
  memcpy( tl->vr_wr, buf, tl->get_n() * mr * sizeof( realType ) ), buf += tl->get_n() * mr * UINT_PER_REAL;
  
  tl->disableWriteAccess();
  return;
 }

References moab::TupleList::disableWriteAccess(), moab::TupleList::enableWriteAccess(), moab::TupleList::get_n(), moab::TupleList::getTupleSize(), moab::TupleList::initialize(), moab::TupleList::set_n(), UINT_PER_LONG, UINT_PER_REAL, UINT_PER_UNSIGNED, moab::TupleList::vi_wr, moab::TupleList::vl_wr, moab::TupleList::vr_wr, and moab::TupleList::vul_wr.

Referenced by moab::Coupler::get_matching_entities(), and main().

◆ UNPACK_TYPE()

static void moab::UNPACK_TYPE	(	unsigned char *&	buff,
		EntityType &	type
	)

inlinestatic

Definition at line 205 of file ParallelComm.cpp.

 {
  int int_type = MBMAXTYPE;
  UNPACK_INT( buff, int_type );
  type = static_cast< EntityType >( int_type );
  assert( type >= MBVERTEX && type <= MBMAXTYPE );
 }

References MBMAXTYPE, MBVERTEX, and UNPACK_INT().

Referenced by moab::ParallelComm::print_buffer(), and moab::ParallelComm::unpack_entities().

◆ UNPACK_VOID()

static void moab::UNPACK_VOID	(	unsigned char *&	buff,
		void *	val,
		size_t	num
	)

inlinestatic

Definition at line 199 of file ParallelComm.cpp.

 {
  UNPACK( buff, reinterpret_cast< unsigned char* >( val ), num );
  UPC( num, " void" );
 }

References UNPACK(), and UPC.

Referenced by moab::ParallelComm::unpack_sets().

◆ VALGRIND_MAKE_VEC_UNDEFINED()

template<typename T >

void moab::VALGRIND_MAKE_VEC_UNDEFINED ( std::vector< T > & )

inline

Definition at line 163 of file WriteHDF5Parallel.cpp.

 {
  /* Nothing to do */
 }

Referenced by moab::WriteHDF5Parallel::negotiate_type_list().

◆ vector_insert_vector()

static ErrorCode moab::vector_insert_vector	(	MeshSet::Count &	count,
		MeshSet::CompactList &	clist,
		const EntityHandle *	vect,
		size_t	vect_size,
		EntityHandle	my_handle,
		AEntityFactory *	adj
	)

static

Insert unsorted array of handles into vector-based MeshSet

Definition at line 1036 of file MeshSet.cpp.

 {
  const size_t orig_size = count < MeshSet::MANY ? (int)count : clist.ptr[1] - clist.ptr[0];
  EntityHandle* list = resize_compact_list( count, clist, orig_size + vect_size );
  if( adj )
  for( size_t i = 0; i < vect_size; ++i )
  adj->add_adjacency( vect[i], my_handle, false );
  memcpy( list + orig_size, vect, sizeof( EntityHandle ) * vect_size );
  return MB_SUCCESS;
 }

References moab::AEntityFactory::add_adjacency(), moab::MeshSet::MANY, MB_SUCCESS, moab::MeshSet::CompactList::ptr, and resize_compact_list().

Referenced by moab::MeshSet::insert_entity_vector().

◆ vector_remove_range()

static ErrorCode moab::vector_remove_range	(	MeshSet::Count &	count,
		MeshSet::CompactList &	clist,
		const Range &	range,
		EntityHandle	my_handle,
		AEntityFactory *	adj
	)

static

Remove Range of handles fromr vector-based MeshSet

Definition at line 913 of file MeshSet.cpp.

 {
  EntityHandle* list;
  size_t list_size;
  if( count < MeshSet::MANY )
  {
  list = clist.hnd;
  list_size = count;
  }
  else
  {
  list = clist.ptr[0];
  list_size = clist.ptr[1] - clist.ptr[0];
  }
  
  const EntityHandle* const list_end = list + list_size;
  EntityHandle* list_write = list;
  for( const EntityHandle* list_read = list; list_read != list_end; ++list_read )
  {
  if( range.find( *list_read ) == range.end() )
  { // keep
  *list_write = *list_read;
  ++list_write;
  }
  else if( adj )
  {
  adj->remove_adjacency( *list_read, my_handle );
  }
  }
  
  resize_compact_list( count, clist, list_write - list );
  return MB_SUCCESS;
 }

References moab::Range::end(), moab::Range::find(), moab::MeshSet::CompactList::hnd, moab::MeshSet::MANY, MB_SUCCESS, moab::MeshSet::CompactList::ptr, moab::AEntityFactory::remove_adjacency(), and resize_compact_list().

Referenced by moab::MeshSet::remove_entity_ranges().

◆ vector_remove_ranges()

static ErrorCode moab::vector_remove_ranges	(	MeshSet::Count &	count,
		MeshSet::CompactList &	clist,
		const EntityHandle *	pair_list,
		size_t	num_pairs,
		EntityHandle	my_handle,
		AEntityFactory *	adj
	)

static

Remove range-based MeshSet contents from vector-based MeshSet

Definition at line 951 of file MeshSet.cpp.

 {
  EntityHandle* list;
  size_t list_size;
  if( count < MeshSet::MANY )
  {
  list = clist.hnd;
  list_size = count;
  }
  else
  {
  list = clist.ptr[0];
  list_size = clist.ptr[1] - clist.ptr[0];
  }
  
  const EntityHandle *const list_end = list + list_size, *const input_end = pair_list + 2 * num_pairs;
  EntityHandle* list_write = list;
  for( const EntityHandle* list_read = list; list_read != list_end; ++list_read )
  {
  const EntityHandle* ptr = std::lower_bound( pair_list, input_end, *list_read );
  if( ( ptr != input_end && ( *ptr == *list_read || ( ptr - pair_list ) % 2 ) ) && // if in delete list
  std::find( list_read + 1, list_end, *list_read ) == list_end )
  { // and is last occurance in list
  // only remove adj if no previous occurance
  if( adj && std::find( list, list_write, *list_read ) == list_write )
  adj->remove_adjacency( *list_read, my_handle );
  }
  else
  {
  *list_write = *list_read;
  ++list_write;
  }
  }
  
  resize_compact_list( count, clist, list_write - list );
  return MB_SUCCESS;
 }

References moab::MeshSet::CompactList::hnd, moab::MeshSet::MANY, MB_SUCCESS, moab::MeshSet::CompactList::ptr, moab::AEntityFactory::remove_adjacency(), and resize_compact_list().

Referenced by moab::MeshSet::remove_entity_ranges().

◆ vector_remove_vector()

static ErrorCode moab::vector_remove_vector	(	MeshSet::Count &	count,
		MeshSet::CompactList &	clist,
		const EntityHandle *	vect,
		size_t	vect_size,
		EntityHandle	my_handle,
		AEntityFactory *	adj
	)

static

Remove unsorted array of handles from vector-based MeshSet

Definition at line 994 of file MeshSet.cpp.

 {
  EntityHandle* list;
  size_t list_size;
  if( count < MeshSet::MANY )
  {
  list = clist.hnd;
  list_size = count;
  }
  else
  {
  list = clist.ptr[0];
  list_size = clist.ptr[1] - clist.ptr[0];
  }
  
  const EntityHandle *const list_end = list + list_size, *const input_end = vect + vect_size;
  EntityHandle* list_write = list;
  for( const EntityHandle* list_read = list; list_read != list_end; ++list_read )
  {
  if( std::find( vect, input_end, *list_read ) != input_end && // if in delete list
  std::find( list_read + 1, list_end, *list_read ) == list_end )
  { // and is last occurance in list
  // only remove adj if no previous occurance?
  if( adj ) // && std::find(list, list_write, *list_read) == list_write)
  adj->remove_adjacency( *list_read, my_handle );
  }
  else
  {
  *list_write = *list_read;
  ++list_write;
  }
  }
  
  resize_compact_list( count, clist, list_write - list );
  return MB_SUCCESS;
 }

References moab::MeshSet::CompactList::hnd, moab::MeshSet::MANY, MB_SUCCESS, moab::MeshSet::CompactList::ptr, moab::AEntityFactory::remove_adjacency(), and resize_compact_list().

Referenced by moab::MeshSet::remove_entity_vector().

◆ verify()

static bool moab::verify	(	CartVect	a,
		CartVect	b,
		CartVect	c,
		CartVect	d,
		double	x,
		double	y,
		double	z
	)

static

Definition at line 1399 of file IntxUtils.cpp.

 {
  // to check, the point has to be between a and b on a great arc, and between c and d on a const
  // lat circle
  CartVect s( x, y, z );
  CartVect n1 = a * b;
  CartVect n2 = a * s;
  CartVect n3 = s * b;
  if( n1 % n2 < 0 || n1 % n3 < 0 ) return false;
  
  // do the same for c, d, s, in plane z=0
  c[2] = d[2] = s[2] = 0.; // bring everything in the same plane, z=0;
  
  n1 = c * d;
  n2 = c * s;
  n3 = s * d;
  if( n1 % n2 < 0 || n1 % n3 < 0 ) return false;
  
  return true;
 }

Referenced by moab::IntxUtils::intersect_great_circle_arc_with_clat_arc().

◆ within_tolerance()

bool moab::within_tolerance	(	CartVect &	p1,
		CartVect &	p2,
		const double &	tolerance
	)

Definition at line 18 of file SmoothFace.cpp.

 {
  if( ( fabs( p1[0] - p2[0] ) < tolerance ) && ( fabs( p1[1] - p2[1] ) < tolerance ) &&
  ( fabs( p1[2] - p2[2] ) < tolerance ) )
  return true;
  return false;
 }

References tolerance.

Referenced by moab::SmoothFace::facet_area_coordinate().

Variable Documentation

◆ __PACK_count

unsigned int moab::__PACK_count = 0

Definition at line 55 of file ParallelComm.cpp.

◆ __PACK_num

unsigned int moab::__PACK_num = 0

Definition at line 55 of file ParallelComm.cpp.

◆ __PACK_string

std::string moab::__PACK_string

Definition at line 56 of file ParallelComm.cpp.

◆ __UNPACK_count

unsigned int moab::__UNPACK_count = 0

Definition at line 55 of file ParallelComm.cpp.

◆ __UNPACK_num

unsigned int moab::__UNPACK_num = 0

Definition at line 55 of file ParallelComm.cpp.

◆ __UNPACK_string

std::string moab::__UNPACK_string

Definition at line 56 of file ParallelComm.cpp.

◆ AFFINE_XFORM_TAG_NAME

const char* const moab::AFFINE_XFORM_TAG_NAME = "AFFINE_TRANSFORM"

Definition at line 36 of file AffineXform.cpp.

Referenced by moab::AffineXform::get_tag().

◆ AXIS_BOX_TAG_NAME

const char* const moab::AXIS_BOX_TAG_NAME = "AXIS_BOX"

Definition at line 29 of file AxisBox.cpp.

Referenced by moab::AxisBox::get_tag().

◆ BLOCK_NODESET_OFFSET_TAG_NAME

const char* const moab::BLOCK_NODESET_OFFSET_TAG_NAME = "BLOCK_NODESET_OFFSET"

Definition at line 103 of file Tqdcfr.cpp.

Referenced by moab::Tqdcfr::convert_nodesets_sidesets().

◆ BLOCK_SIDESET_OFFSET_TAG_NAME

const char* const moab::BLOCK_SIDESET_OFFSET_TAG_NAME = "BLOCK_SIDESET_OFFSET"

Definition at line 104 of file Tqdcfr.cpp.

Referenced by moab::Tqdcfr::convert_nodesets_sidesets().

◆ box_face_corners

const int moab::box_face_corners[6][4]

static

Initial value:

= { { 0, 1, 5, 4 }, { 1, 2, 6, 5 }, { 2, 3, 7, 6 },

{ 3, 0, 4, 7 }, { 3, 2, 1, 0 }, { 4, 5, 6, 7 } }

Definition at line 1248 of file BSPTree.cpp.

Referenced by moab::BoxPlaneIter::BoxPlaneIter().

◆ cub_elem_order_map

const int* const* const* const moab::cub_elem_order_map = exodus_elem_order_map

Definition at line 101 of file Tqdcfr.cpp.

Referenced by moab::Tqdcfr::read_elements().

◆ debug

bool moab::debug = false

Examples: DeformMeshRemap.cpp.

Definition at line 45 of file DualTool.cpp.

◆ debug_ap

bool moab::debug_ap = false

Definition at line 46 of file DualTool.cpp.

Referenced by moab::DualTool::atomic_pillow(), moab::DualTool::face_open_collapse(), moab::DualTool::face_shrink(), moab::DualTool::rev_atomic_pillow(), moab::DualTool::rev_face_shrink(), and moab::DualTool::traverse_hyperplane().

◆ debug_splits

bool moab::debug_splits = false

Definition at line 46 of file FBEngine.cpp.

Referenced by area_coordinates(), moab::FBEngine::BreakTriangle2(), moab::FBEngine::compute_intersection_points(), moab::FBEngine::create_new_gedge(), moab::FBEngine::divide_triangle(), intersect_segment_and_plane_slice(), moab::FBEngine::separate(), moab::FBEngine::split_bedge_at_new_mesh_node(), moab::FBEngine::split_boundary(), moab::FBEngine::split_edge_at_mesh_node(), moab::FBEngine::split_edge_at_point(), moab::FBEngine::split_internal_edge(), moab::FBEngine::split_surface(), and moab::FBEngine::split_surface_with_direction().

◆ Debug_surf_eval

const bool moab::Debug_surf_eval = false

Definition at line 45 of file FBEngine.cpp.

Referenced by moab::FBEngine::initializeSmoothing().

◆ debug_surf_eval1

bool moab::debug_surf_eval1 = false

Definition at line 39 of file SmoothFace.cpp.

Referenced by moab::SmoothFace::init_bezier_edge(), and moab::SmoothFace::init_gradient().

◆ DEFAULT_BCAST_DUPLICATE_READS

const bool moab::DEFAULT_BCAST_DUPLICATE_READS = true

Definition at line 81 of file ReadHDF5.cpp.

Referenced by moab::ReadHDF5::set_up_read().

◆ DEFAULT_BCAST_SUMMARY

const bool moab::DEFAULT_BCAST_SUMMARY = true

Definition at line 75 of file ReadHDF5.cpp.

Referenced by moab::ReadHDF5::set_up_read().

◆ DEFAULT_BLOCKED_COORDINATE_IO

const bool moab::DEFAULT_BLOCKED_COORDINATE_IO = false

Definition at line 68 of file ReadHDF5.cpp.

Referenced by moab::ReadHDF5::set_up_read().

◆ DEFAULT_HYPERSLAB_SELECTION_LIMIT

const size_t moab::DEFAULT_HYPERSLAB_SELECTION_LIMIT = 200

Definition at line 31 of file ReadHDF5Dataset.cpp.

Referenced by moab::ReadHDF5Dataset::default_hyperslab_selection_limit().

◆ DEFAULT_MAX_EDGES_PER_CELL

const int moab::DEFAULT_MAX_EDGES_PER_CELL = 10

Definition at line 21 of file NCHelperESMF.cpp.

Referenced by moab::NCHelperMPAS::create_gather_set_cells(), moab::NCHelperESMF::create_local_cells(), moab::NCHelperMPAS::create_local_cells(), moab::NCHelperESMF::init_mesh_vals(), and moab::NCHelperMPAS::init_mesh_vals().

◆ DEFAULT_PRECISION

const int moab::DEFAULT_PRECISION = 10

Definition at line 18 of file WriteGmsh.cpp.

Referenced by moab::WriteGmsh::write_file(), moab::WriteSmf::write_file(), moab::WriteSTL::write_file(), and moab::WriteVtk::write_file().

◆ DEFAULT_SEPARATOR

const char moab::DEFAULT_SEPARATOR = ';'

Definition at line 31 of file FileOptions.cpp.

Referenced by moab::FileOptions::FileOptions().

◆ DEFAULT_STRICT

const bool moab::DEFAULT_STRICT = true

Definition at line 51 of file WriteVtk.cpp.

Referenced by moab::WriteVtk::write_file().

◆ DEFAULT_TAG_NAME

const char moab::DEFAULT_TAG_NAME[] = "OBB"

Definition at line 45 of file OrientedBoxTreeTool.cpp.

Referenced by main(), and moab::OrientedBoxTreeTool::OrientedBoxTreeTool().

◆ dum

int moab::dum[] = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 }

Definition at line 30 of file HomXform.cpp.

Referenced by moab::DualTool::check_1d_loop_edge(), compute_tracer_case1(), create_lagr_mesh(), IntxUtilsCSLAM::deep_copy_set(), moab::IntxUtils::deep_copy_set_with_quads(), moab::MeshTopoUtil::equivalent_entities(), moab::EvalSet::evaluate_reverse(), moab::LinearTet::evaluate_reverse(), moab::ScdInterface::find_boxes(), moab::DualTool::fs_check_quad_sense(), moab::WriteSLAC::gather_interior_exterior(), moab::AEntityFactory::get_associated_meshsets(), get_departure_grid(), moab::DualTool::get_dual_entities(), moab::AEntityFactory::get_element(), moab::AEntityFactory::get_up_adjacency_elements(), moab::Core::high_order_node(), moab::Core::list_entity(), main(), moab::ReadNC::parse_options(), moab::ParallelComm::resolve_shared_sets(), moab::SpectralMeshTool::spectral_order_tag(), moab::HigherOrderFactory::tag_for_deletion(), moab::ScdInterface::tag_shared_vertices(), test_hex_nat_coords(), update_density(), and moab::Intx2MeshOnSphere::update_tracer_data().

◆ E

const unsigned char moab::E = CN::MID_EDGE_BIT

Definition at line 952 of file MBCNArrays.hpp.

Referenced by moab::IntxAreaUtils::area_spherical_triangle_lHuiller(), moab::MeshGeneration::BrickInstance(), moab::IntxUtils::EdgeIntxRllCs(), moab::IntxUtils::intersect_great_circle_arc_with_clat_arc(), and moab::IntxUtils::intersect_great_circle_arcs().

◆ EDGES_PER_CELL

const int moab::EDGES_PER_CELL = 6

Definition at line 17 of file NCHelperGCRM.cpp.

Referenced by moab::NCHelperGCRM::create_local_edges(), moab::NCHelperGCRM::create_mesh(), moab::NCHelperGCRM::create_padded_gather_set_cells(), and moab::NCHelperGCRM::create_padded_local_cells().

◆ errorOutput

ErrorOutput* moab::errorOutput = NULL

static

Definition at line 27 of file ErrorHandler.cpp.

Referenced by MBErrorHandler_Finalize(), MBErrorHandler_Init(), MBErrorHandler_Initialized(), and MBTraceBackErrorHandler().

◆ F

const unsigned char moab::F = CN::MID_FACE_BIT

Definition at line 953 of file MBCNArrays.hpp.

Referenced by moab::MeshGeneration::BrickInstance().

◆ face_start_token

const char* moab::face_start_token = "f"

Definition at line 51 of file ReadOBJ.cpp.

◆ geom_category

const char moab::geom_category[][CATEGORY_TAG_SIZE] = { "Vertex\0", "Curve\0", "Surface\0", "Volume\0", "Group\0" }

Definition at line 60 of file ReadOBJ.cpp.

Referenced by build_new_surface(), and moab::ReadOBJ::create_new_object().

◆ geom_name

const char* const moab::geom_name[] = { "Vertex\0", "Curve\0", "Surface\0", "Volume\0" }

Definition at line 57 of file ReadOBJ.cpp.

Referenced by moab::ReadOBJ::create_new_object().

◆ GEOM_SENSE_2_TAG_NAME

const char moab::GEOM_SENSE_2_TAG_NAME[] = "GEOM_SENSE_2"

Definition at line 37 of file GeomTopoTool.cpp.

Referenced by moab::GeomTopoTool::check_face_sense_tag().

◆ GEOM_SENSE_N_ENTS_TAG_NAME

const char moab::GEOM_SENSE_N_ENTS_TAG_NAME[] = "GEOM_SENSE_N_ENTS"

Definition at line 39 of file GeomTopoTool.cpp.

Referenced by moab::GeomTopoTool::check_edge_sense_tags().

◆ GEOM_SENSE_N_SENSES_TAG_NAME

const char moab::GEOM_SENSE_N_SENSES_TAG_NAME[] = "GEOM_SENSE_N_SENSES"

Definition at line 40 of file GeomTopoTool.cpp.

Referenced by moab::GeomTopoTool::check_edge_sense_tags().

◆ group_start_token

const char* moab::group_start_token = "g"

Definition at line 49 of file ReadOBJ.cpp.

◆ hex_27_node_order

const int moab::hex_27_node_order[]

Initial value:

= { 0, 1, 2, 3, 4, 5, 6, 7, 
 8, 11, 12, 9, 13, 10, 14, 15, 16, 19, 17, 18, 
 24, 20, 23, 21, 22, 25, 
 26 }

Definition at line 23 of file GmshUtil.cpp.

◆ IDD_MBCore

const MBuuid moab::IDD_MBCore = MBuuid( 0x8956e0a, 0xc300, 0x4005, 0xbd, 0xf6, 0xc3, 0x4e, 0xf7, 0x1f, 0x5a, 0x52 )

static

Definition at line 84 of file Interface.hpp.

Referenced by moab::ComponentFactory::QueryInterface(), and moab::Core::QueryInterface().

◆ IDD_MBUnknown

const MBuuid moab::IDD_MBUnknown

static

Initial value:

=

MBuuid( 0xf4f6605e, 0x2a7e, 0x4760, 0xbb, 0x06, 0xb9, 0xed, 0x27, 0xe9, 0x4a, 0xec )

uuid for an unknown interface this can be used to either return a default interface or a NULL interface

Definition at line 92 of file UnknownInterface.hpp.

Referenced by moab::ComponentFactory::QueryInterface(), and moab::Core::QueryInterface().

◆ IMPLICIT_COMPLEMENT_NAME

const char moab::IMPLICIT_COMPLEMENT_NAME[] = "impl_complement"

Definition at line 44 of file GeomTopoTool.cpp.

Referenced by moab::GeomTopoTool::setup_implicit_complement().

◆ kCellInc

int const moab::kCellInc = 4

static

Definition at line 78 of file ReadCCMIO.cpp.

◆ kDefaultState

char const moab::kDefaultState[] = "default"

static

Definition at line 75 of file ReadCCMIO.cpp.

◆ kNValues

int const moab::kNValues = 10

static

Definition at line 74 of file ReadCCMIO.cpp.

◆ kStateName

char const moab::kStateName[] = "default"

static

Definition at line 81 of file WriteCCMIO.cpp.

Referenced by moab::WriteCCMIO::create_ccmio_structure().

◆ kUnitsName

char const moab::kUnitsName[] = "Units"

static

Definition at line 76 of file ReadCCMIO.cpp.

◆ kVertOffset

int const moab::kVertOffset = 2

static

Definition at line 77 of file ReadCCMIO.cpp.

◆ lastError

std::string moab::lastError = "No error"

static

Definition at line 28 of file ErrorHandler.cpp.

Referenced by MBError(), MBErrorHandler_GetLastError(), and MBTraceBackErrorHandler().

◆ major

int moab::major = -1

static

Definition at line 49 of file Tqdcfr.cpp.

Referenced by moab::ReadVtk::load_file(), moab::Tqdcfr::load_file(), moab::Tqdcfr::parse_acis_attribs(), moab::Tqdcfr::read_block(), moab::Tqdcfr::read_elements(), moab::Tqdcfr::BlockHeader::read_info_header(), and moab::Tqdcfr::GeomHeader::read_info_header().

◆ MAX_BCAST_SIZE

const int moab::MAX_BCAST_SIZE = ( 1 << 28 )

Definition at line 52 of file ParallelComm.cpp.

Referenced by moab::ParallelComm::broadcast_entities().

◆ MAX_NODES

const int moab::MAX_NODES = 28

Definition at line 85 of file GmshUtil.cpp.

Referenced by moab::GmshUtil::get_gmsh_type().

◆ MAXSIZE

const int moab::MAXSIZE = 200

Definition at line 51 of file HalfFacetRep.hpp.

Referenced by moab::HalfFacetRep::collect_and_compare(), moab::HalfFacetRep::init_surface(), and moab::HalfFacetRep::init_volume().

◆ mb_to_gmsh_type

const int moab::mb_to_gmsh_type[][MAX_NODES]

Initial value:

= {
 
 TWENTYEIGHT_ZEROS, 
 { 0, 0, 1, 8, 26, 27, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
 { 0, 0, 0, 2, 0, 0, 9, 0, 0, 20, 21, 0, 22, 0, 0, 23, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0 }, 
 { 0, 0, 0, 0, 3, 0, 0, 0, 16, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
 TWENTYEIGHT_ZEROS, 
 { 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0 }, 
 { 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 19, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
 { 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
 TWENTYEIGHT_ZEROS, 
 { 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 12 }, 
 TWENTYEIGHT_ZEROS, 
 TWENTYEIGHT_ZEROS, 
 TWENTYEIGHT_ZEROS }

Definition at line 86 of file GmshUtil.cpp.

Referenced by moab::GmshUtil::get_gmsh_type().

◆ mb_to_vtk_type

const int moab::mb_to_vtk_type[][3]

Initial value:

= { { 1, 0, 0 }, 
 { 3, 21, 0 }, 
 { 5, 22, 0 }, 
 { 9, 23, 28 }, 
 { 7, 0, 0 }, 
 { 10, 24, 0 }, 
 { 14, 27, 0 }, 
 { 13, 26, 0 }, 
 { 0, 0, 0 }, 
 { 12, 25, 29 }, 
 { 42, 0, 0 }, 
 { 0, 0, 0 }, 
 { 0, 0, 0 } }

Definition at line 111 of file VtkUtil.cpp.

Referenced by moab::VtkUtil::get_vtk_type().

◆ minor

int moab::minor = -1

static

Definition at line 49 of file Tqdcfr.cpp.

Referenced by moab::ReadVtk::load_file(), moab::Tqdcfr::load_file(), moab::Tqdcfr::read_block(), and moab::Tqdcfr::BlockHeader::read_info_header().

◆ msgs

std::vector< ParallelComm::Buffer* > moab::msgs

Definition at line 54 of file ParallelComm.cpp.

Referenced by moab::ParallelComm::exchange_ghost_cells(), moab::ParallelComm::exchange_owned_mesh(), moab::ParallelComm::recv_entities(), moab::ParallelComm::send_entities(), and moab::ParallelComm::send_recv_entities().

◆ nameQuality

char const* moab::nameQuality[MB_QUALITY_COUNT]

static

Definition at line 90 of file VerdictWrapper.cpp.

Referenced by moab::VerdictWrapper::quality_name().

◆ nameType

const char* moab::nameType[MBMAXTYPE]

static

Initial value:

= {
 "MBVERTEX", 
 "MBEDGE", 
 "MBTRI", 
 "MBQUAD", 
 "MBPOLYGON", 
 "MBTET", 
 "MBPYRAMID", 
 "MBPRISM", 
 "MBKNIFE", 
 "MBHEX", 
 "MBPOLYHEDRON", 
 "MBENTITYSET", 
}

Definition at line 125 of file VerdictWrapper.cpp.

Referenced by moab::VerdictWrapper::entity_type_name().

◆ numQualities

int moab::numQualities[MBMAXTYPE]

static

Initial value:

= {
 0, 
 1, 
 13, 
 22, 
 0, 
 14, 
 0, 
 1, 
 1, 
 20, 
 0, 
 0, 
}

Definition at line 76 of file VerdictWrapper.cpp.

Referenced by moab::VerdictWrapper::num_qualities().

◆ OBB_GSET_TAG_NAME

const char moab::OBB_GSET_TAG_NAME[] = "OBB_GSET"

Definition at line 42 of file GeomTopoTool.cpp.

Referenced by moab::GeomTopoTool::GeomTopoTool().

◆ OBB_ROOT_TAG_NAME

const char moab::OBB_ROOT_TAG_NAME[] = "OBB_ROOT"

Definition at line 41 of file GeomTopoTool.cpp.

Referenced by moab::GeomTopoTool::GeomTopoTool().

◆ object_start_token

const char* moab::object_start_token = "o"

Definition at line 48 of file ReadOBJ.cpp.

◆ PARTITIONING_PCOMM_TAG_NAME

const char* moab::PARTITIONING_PCOMM_TAG_NAME = "__PRTN_PCOMM"

Name of tag used to store ParallelComm Index on mesh paritioning sets

Definition at line 296 of file ParallelComm.cpp.

Referenced by moab::ParallelComm::get_pcomm(), and moab::ParallelComm::set_partitioning().

◆ pideg

const double moab::pideg = acos( -1.0 ) / 180.0

Definition at line 22 of file NCHelperESMF.cpp.

Referenced by moab::NCHelperESMF::create_local_vertices(), moab::NCHelperDomain::create_mesh(), moab::NCHelperHOMME::create_mesh(), and moab::NCHelperScrip::create_mesh().

◆ pixel

const unsigned moab::pixel[] = { 0, 1, 3, 2 }

Definition at line 44 of file VtkUtil.cpp.

◆ possibleQuality

int moab::possibleQuality[MBMAXTYPE][MB_QUALITY_COUNT]

static

Initial value:

= {
 
 
 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
 { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1 }, 
 { 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1 }, 
 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
 { 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0 }, 
 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
 { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
 { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
 { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 
 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } 
}

Definition at line 25 of file VerdictWrapper.cpp.

Referenced by moab::VerdictWrapper::possible_quality(), and moab::VerdictWrapper::quality_measure().

◆ pri_15_node_order

const int moab::pri_15_node_order[]

Initial value:

= {
 0, 1, 2, 3, 4, 5, 
 6, 8, 9, 7, 10, 11, 12, 14, 13 
}

Definition at line 32 of file GmshUtil.cpp.

◆ pyr_13_node_order

const int moab::pyr_13_node_order[]

Initial value:

= {
 0, 1, 2, 3, 4, 
 5, 8, 9, 6, 10, 7, 11, 12 
}

Definition at line 36 of file GmshUtil.cpp.

◆ qhex

const unsigned moab::qhex[]

Initial value:

= { 0, 1, 2, 3, 
 4, 5, 6, 7, 8, 9, 10, 11, 
 16, 17, 18, 19, 12, 13, 14, 15, 23, 21, 20, 22, 
 24, 25, 26 }

Definition at line 52 of file VtkUtil.cpp.

◆ R

const unsigned char moab::R = CN::MID_REGION_BIT

Definition at line 954 of file MBCNArrays.hpp.

◆ SSVB

const unsigned moab::SSVB = 3

Definition at line 1451 of file WriteHDF5Parallel.cpp.

Referenced by moab::WriteHDF5Parallel::communicate_shared_set_ids(), and moab::WriteHDF5Parallel::print_set_sharing_data().

◆ tet_10_node_order

const int moab::tet_10_node_order[] = { 0, 1, 2, 3, 4, 5, 6, 7, 9, 8 }

Definition at line 28 of file GmshUtil.cpp.

◆ TIME_STR_LEN

const int moab::TIME_STR_LEN = 11

Definition at line 53 of file WriteNCDF.cpp.

Referenced by moab::WriteNCDF::time_and_date(), and moab::WriteNCDF::write_header().

◆ tolerance

static double moab::tolerance = 0.01

Definition at line 38 of file FBEngine.cpp.

Referenced by moab::GeomUtil::bounding_boxes_overlap(), moab::GeomUtil::bounding_boxes_overlap_2d(), moab::GeomUtil::box_point_overlap(), moab::GeomUtil::box_tri_overlap(), moab::GeomUtil::boxes_overlap(), moab::GeomUtil::closest_location_on_tri(), moab::OrientedBoxTreeTool::closest_to_location(), moab::TempestRemapper::ConstructCoveringSet(), moab::FBEngine::getPntRayIntsct(), moab::Intx2Mesh::intersect_meshes_kdtree(), moab::AxisBox::intersects(), main(), moab::NCHelper::Node3D::operator<(), moab::SmoothFace::project_to_facets_main(), moab::OrientedBoxTreeTool::ray_intersect_boxes(), moab::OrientedBoxTreeTool::ray_intersect_sets(), moab::OrientedBoxTreeTool::ray_intersect_triangles(), moab::ParallelComm::settle_intersection_points(), moab::FBEngine::split_surface_with_direction(), moab::SmoothCurve::u_from_position(), within_tolerance(), and VerdictVector::within_tolerance().

◆ tolerance_segment

double moab::tolerance_segment = 0.01

Definition at line 39 of file FBEngine.cpp.

Referenced by area_coordinates(), moab::FBEngine::compute_intersection_points(), and intersect_segment_and_plane_slice().

◆ UNUSED_SIZE

const int moab::UNUSED_SIZE = 0

Definition at line 29 of file SequenceManager.cpp.

Referenced by moab::SequenceManager::release_tag_array(), and moab::SequenceManager::reserve_tag_array().

◆ vertex_start_token

const char* moab::vertex_start_token = "v"

Definition at line 50 of file ReadOBJ.cpp.

◆ voxel

const unsigned moab::voxel[] = { 0, 1, 3, 2, 4, 5, 7, 6 }

Definition at line 45 of file VtkUtil.cpp.

◆ vtk_type_names

const char* const moab::vtk_type_names[]

Initial value:

= {
 "bit", "char", "unsigned_char", "short", "unsigned_short", "int", "unsigned_int",
 "long", "unsigned_long", "float", "double", "vtkIdType", 0 }

Definition at line 175 of file ReadVtk.cpp.

Referenced by moab::ReadVtk::vtk_read_field(), moab::ReadVtk::vtk_read_field_attrib(), moab::ReadVtk::vtk_read_polydata(), moab::ReadVtk::vtk_read_rectilinear_grid(), moab::ReadVtk::vtk_read_scalar_attrib(), moab::ReadVtk::vtk_read_structured_grid(), moab::ReadVtk::vtk_read_tensor_attrib(), moab::ReadVtk::vtk_read_texture_attrib(), moab::ReadVtk::vtk_read_unstructured_grid(), and moab::ReadVtk::vtk_read_vector_attrib().

◆ wedge

const unsigned moab::wedge[]

Initial value:

= { 0, 2, 1, 
 3, 5, 4, 
 8, 7, 6, 
 14, 13, 12, 
 9, 11, 10, 
 17, 16, 15 }

Definition at line 46 of file VtkUtil.cpp.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

left and right, as well as internal and external.

the outside sense defines the Fuel.

Defines that there is 1 region called Pyrex

Defines that this is node 100, and has the coordinates 1890.0, 0.0 5000.0 cm

side ID 3 and surface number 6365

1. Why won't this code compile?

}

Typedef Documentation

◆ AdjacencyVector

◆ DimensionPair

◆ EntityHandle

◆ EntityID

◆ EvalFcn

◆ HandleMap

◆ HandleVec

◆ HDF5_Error_Func_Type

◆ HFacet

◆ InitFcn

◆ InsideFcn

◆ IntegrateFcn

◆ JacobianFcn

◆ MeshSetRange

◆ NormalFcn

◆ ReverseEvalFcn

◆ TagDoublesEqual

◆ TagDoublesLess

◆ TagHandlesEqual

◆ TagHandlesLess

◆ TagIntsEqual

◆ TagIntsLess

◆ TagOneDoubleEqual

◆ TagOneDoubleLess

◆ TagOneHandleEqual

◆ TagOneHandleLess

◆ TagOneIntEqual

◆ TagOneIntLess

◆ TagVarDoublesEqual

◆ TagVarDoublesLess

◆ TagVarHandlesEqual

◆ TagVarHandlesLess

◆ TagVarIntsEqual

◆ TagVarIntsLess

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

◆ abaqus_assembly_params

◆ abaqus_element_params

◆ abaqus_element_type

◆ abaqus_elset_params

◆ abaqus_instance_params

◆ abaqus_keyword_type

◆ abaqus_line_types

◆ abaqus_node_params

◆ abaqus_nset_params

◆ abaqus_part_params

◆ abaqus_solid_section_params

◆ ErrorType

◆ ExoIIElementType

◆ GEOMTYPE

◆ keyword_type

◆ MBMessageTag

◆ MESHTYPE

◆ QualityType

Function Documentation

◆ ADD()

◆ all_root_set()

◆ allocate_mpe_state()

◆ angle()

◆ angleCompare()

◆ area_coordinates()

◆ box_from_axes()

◆ check_int_tag()

◆ check_range()