SequenceManager.hpp

Go to the documentation of this file.

#ifndef SEQUENCE_MANAGER_HPP
#define SEQUENCE_MANAGER_HPP
 
#include "TypeSequenceManager.hpp"
#include "TagInfo.hpp"
#include <vector>
 
namespace moab
{
 
class HomCoord;
class Error;
 
class SequenceManager
{
 public:
 SequenceManager( double default_seq_multiplier = 1.0 ) : sequence_multiplier( default_seq_multiplier ) {}
 
 ~SequenceManager();
 
 /** Delete all contained data */
 void clear();
 
 /** Find entity sequence containing specified handle.
 *\return MB_SUCCESS or MB_ENTITY_NOT_FOUND
 */
 ErrorCode find( EntityHandle handle, EntitySequence*& sequence_out )
 {
 return typeData[TYPE_FROM_HANDLE( handle )].find( handle, sequence_out );
 }
 
 /** Find entity sequence containing specified handle.
 *\return MB_SUCCESS or MB_ENTITY_NOT_FOUND
 */
 ErrorCode find( EntityHandle handle, const EntitySequence*& sequence_out ) const
 {
 return typeData[TYPE_FROM_HANDLE( handle )].find( handle, sequence_out );
 }
 
 /** Get all entities of a given EntityType, return all entities
 * if type == MBMAXTYPE */
 void get_entities( EntityType type, Range& entities_out ) const
 {
 if( type == MBMAXTYPE )
 get_entities( entities_out );
 else
 typeData[type].get_entities( entities_out );
 }
 
 void get_entities( Range& entities_out ) const;
 
 /** Get all entities of a given EntityType, return all entities
 * if type == MBMAXTYPE */
 void get_entities( EntityType type, std::vector< EntityHandle >& entities_out ) const
 {
 if( type == MBMAXTYPE )
 get_entities( entities_out );
 else
 typeData[type].get_entities( entities_out );
 }
 
 void get_entities( std::vector< EntityHandle >& entities_out ) const;
 
 /** Count entities of a given EntityType */
 EntityID get_number_entities( EntityType type ) const
 {
 return type == MBMAXTYPE ? get_number_entities() : typeData[type].get_number_entities();
 }
 
 /** Count entities of a given EntityType */
 EntityID get_number_entities() const;
 
 /** Get most recently accessed sequence for a given type */
 const EntitySequence* get_last_accessed_sequence( EntityType type ) const
 {
 return typeData[type].get_last_accessed();
 }
 
 /**\brief Replace subset of existing sequence with new
 * sequence (splits existing sequence)
 *
 * Used for converting number of nodes for fixed-connectivity-length
 * elements. Input sequence must be a non-strict subset of an existing
 * sequence. Existing sequence will be removed, modified, or split
 * into two prevent it from overlapping the new sequence.
 */
 ErrorCode replace_subsequence( EntitySequence* new_seq );
 
 /** Check if passed entity handles are valid */
 ErrorCode check_valid_entities( Error* error_handler, const Range& entities ) const;
 
 /** Check if passed entity handles are valid
 *\param root_set_okay If true, do not returnan error if the passed
 * array contains one or more zero-valued handles
 */
 ErrorCode check_valid_entities( Error* error_handler,
 const EntityHandle entities[],
 size_t num_entities,
 bool root_set_okay = false ) const;
 
 /** Delete an entity. Deletes sequence if only contained entity. */
 ErrorCode delete_entity( Error* error_handler, EntityHandle entity );
 
 /** Delete entities */
 ErrorCode delete_entities( Error* error_handler, const Range& entities );
 
 /** Allocate a vertex (possibly in an existing sequence) and
 * assign it the passed coordinate values.
 */
 ErrorCode create_vertex( const double coords[3], EntityHandle& handle_out );
 
 /** Allocate a element (possibly in an existing sequence) and
 * assign it the passed connectivity.
 */
 ErrorCode create_element( EntityType type,
 const EntityHandle* conn_array,
 unsigned num_vertices,
 EntityHandle& handle_out );
 
 /** Allocate an entity set (possibly in an existing sequence) */
 ErrorCode create_mesh_set( unsigned flags, EntityHandle& handle_out );
 /** Allocate an entity set with the specified handle.
 *\return MB_ALREADY_ALLOCATED if handle is in use, MB_SUCCESS otherwise.
 */
 ErrorCode allocate_mesh_set( EntityHandle at_this_handle, unsigned flags );
 
 /**\brief Allocate a block of consecutive entity handles
 *
 * Allocate a block of consecutive entity handles. Handles
 * may be appended or prepended to an existing entity sequence.
 *\param type The type of of entity for which to allocate handles
 *\param num_entities Number of entities to allocate
 *\param nodes_per_entity Number of nodes in connectivity for elements,
 * ignored MBVERTEX, MBPOLYGON, MBPOLYHEDRON, and
 * MBENTITYSET types.
 *\param start_id_hint Preferred ID portion for first handle.
 * May be ignored if not available.
 *\param first_handle_out First allocated handle. Allocated handles
 * are [first_handle_out, first_handle_out+num_entities-1].
 *\param sequence_out The sequence in which the entities were allocated.
 * NOTE: first_handle_out may not be first handle in
 * sequence.
 *\param sequence_size If specified, allocate this sequence size instead of
 *DEFAULT_***_SEQUENCE_SIZE
 */
 ErrorCode create_entity_sequence( EntityType type,
 EntityID num_entities,
 int nodes_per_entity,
 EntityID start_id_hint,
 EntityHandle& first_handle_out,
 EntitySequence*& sequence_out,
 int sequence_size );
 
 /**\brief Allocate a block of consecutive mesh sets
 *
 * Allocate a block of consecutive entity handles. Handles
 * may be appended or prepended to an existing entity sequence.
 *\param type The type of of entity for which to allocate handles
 *\param num_sets Number of entities to allocate
 *\param start_id_hint Preferred ID portion for first handle.
 * May be ignored if not available.
 *\param processor_id Processor ID to embed in handles
 *\param flags Array of length 'num_sets' containing entity set
 * creating flags.
 *\param first_handle_out First allocated handle. Allocated handles
 * are [first_handle_out, first_handle_out+num_entities-1].
 *\param sequence_out The sequence in which the entities were allocated.
 * NOTE: first_handle_out may not be first handle in
 * sequence.
 */
 ErrorCode create_meshset_sequence( EntityID num_sets,
 EntityID start_id_hint,
 const unsigned* flags,
 EntityHandle& first_handle_out,
 EntitySequence*& sequence_out );
 
 /**\brief Allocate a block of consecutive mesh sets
 *
 * Alternate form that creates all mesh sets with same flags.
 */
 ErrorCode create_meshset_sequence( EntityID num_sets,
 EntityID start_id_hint,
 unsigned flags,
 EntityHandle& first_handle_out,
 EntitySequence*& sequence_out );
 
 /** Create structured mesh */
 ErrorCode create_scd_sequence( int imin,
 int jmin,
 int kmin,
 int imax,
 int jmax,
 int kmax,
 EntityType type,
 EntityID start_id_hint,
 EntityHandle& first_handle_out,
 EntitySequence*& sequence_out,
 int* is_periodic = NULL );
 
 /** Create structured mesh */
 ErrorCode create_scd_sequence( const HomCoord& coord_min,
 const HomCoord& coord_max,
 EntityType type,
 EntityID start_id_hint,
 EntityHandle& first_handle_out,
 EntitySequence*& sequence_out,
 int* is_periodic = NULL );
 
 /** Create swept mesh */
 ErrorCode create_sweep_sequence( int imin,
 int jmin,
 int kmin,
 int imax,
 int jmax,
 int kmax,
 int* Cq,
 EntityType type,
 EntityID start_id_hint,
 EntityHandle& first_handle_out,
 EntitySequence*& sequence_out );
 
 /** Create swept mesh */
 ErrorCode create_sweep_sequence( const HomCoord& coord_min,
 const HomCoord& coord_max,
 int* Cq,
 EntityType type,
 EntityID start_id_hint,
 EntityHandle& first_handle_out,
 EntitySequence*& sequence_out );
 
 /** Add a structured vertex sequence to this structured element sequence;
 * see comments in ScdElementData */
 ErrorCode add_vsequence( EntitySequence* vert_seq,
 EntitySequence* elem_seq,
 const HomCoord& p1,
 const HomCoord& q1,
 const HomCoord& p2,
 const HomCoord& q2,
 const HomCoord& p3,
 const HomCoord& q3,
 bool bb_input = false,
 const HomCoord* bb_min = NULL,
 const HomCoord* bb_max = NULL );
 
 /** Get data for a specific EntityType */
 TypeSequenceManager& entity_map( EntityType type )
 {
 return typeData[type];
 }
 
 /** Get data for a specific EntityType */
 const TypeSequenceManager& entity_map( EntityType type ) const
 {
 return typeData[type];
 }
 
 void get_memory_use( unsigned long long& total_entity_storage, unsigned long long& total_storage ) const;
 
 void get_memory_use( EntityType type,
 unsigned long long& total_entity_storage,
 unsigned long long& total_storage ) const;
 
 void get_memory_use( const Range& entities,
 unsigned long long& total_entity_storage,
 unsigned long long& total_amortized_storage ) const;
 
 /* Dense Tag Functions */
 
 /** Allocate a tag ID
 *\param tag_size The size of the tag value for each entity
 */
 ErrorCode reserve_tag_array( Error* error_handler, int tag_size, int& array_id_out );
 
 /** Release any storage assocociated with a tag ID, and optionally,
 * release the reserved tag ID. */
 ErrorCode release_tag_array( Error* error_handler, int id, bool release_id );
 
 /**\brief Get default size of POLYGON and POLYHEDRON SequenceData */
 static EntityID default_poly_sequence_size( int entity_connectivity_length );
 
 /**\brief Size to allocate for new SquenceData
 * THIS FUNCTION SHOULD ONLY BE CALLED WHEN ALLOCATING FROM ReadUtil IN BULK
 * (since it will allocate lesser of requested_size and default_size)
 * If sequence_size != -1, will try to allocate that, unless there isn't available
 * space
 */
 EntityID new_sequence_size( EntityHandle start_handle, EntityID requested_size, int sequence_size ) const;
 
 /** \brief Interface to control memory allocation for sequences
 * Provide a factor that controls the size of the sequence that gets allocated.
 * This is typically useful in the parallel setting when a-priori, the number of ghost entities
 * and the memory required for them within the same sequence as the owned entities are unknown.
 * The default factor is 1.0 but this can be appropriately updated at runtime so that we do not
 * have broken sequences.
 */
 double get_sequence_multiplier() const
 {
 return sequence_multiplier;
 }
 
 /** \brief Interface to control memory allocation for sequences
 * Provide a factor that controls the size of the sequence that gets allocated.
 * This is typically useful in the parallel setting when a-priori, the number of ghost entities
 * and the memory required for them within the same sequence as the owned entities are unknown.
 * The default factor is 1.0 but this can be appropriately updated at runtime so that we do not
 * have broken sequences.
 *
 * \param meshset User specified multiplier (should be greater than 1.0)
 */
 void set_sequence_multiplier( double factor )
 {
 sequence_multiplier = factor;
 }
 
 /**\brief Default allocation size for vertices */
 static const EntityID DEFAULT_VERTEX_SEQUENCE_SIZE;
 
 /**\brief Default allocation size for elements */
 static const EntityID DEFAULT_ELEMENT_SEQUENCE_SIZE;
 
 /**\brief Default allocation size for poly's */
 static const EntityID DEFAULT_POLY_SEQUENCE_SIZE;
 
 /**\brief Default allocation size for meshsets */
 static const EntityID DEFAULT_MESHSET_SEQUENCE_SIZE;
 
 private:
 /**\brief Utility function for allocate_mesh_set (and similar)
 *
 * Given a block of available handles, determine the non-strict
 * subset at which to create a new EntitySequence.
 */
 void trim_sequence_block( EntityHandle start_handle,
 EntityHandle& end_handle_in_out,
 unsigned maximum_sequence_size );
 
 /**\brief Get range of handles in which to create an entity sequence
 *
 * Get range of handles in whcih to place a new entity sequence.
 *\param type The EntityType for the contents of the sequence
 *\param entity_count The number of entities in the range
 *\param values_per_entity Vertices per element, zero for other types
 *\param start_id_hint Preferred id of first handle
 *\param processor_rank MPI processor ID
 *\param data_out Output: Either NULL or an existing SequenceData
 * with a sufficiently large block to accomodate
 * the handle range.
 *\return zero if no available handle range, start handle otherwise.
 */
 EntityHandle sequence_start_handle( EntityType type,
 EntityID entity_count,
 int values_per_entity,
 EntityID start_id_hint,
 SequenceData*& data_out,
 EntityID& data_size );
 
 TypeSequenceManager typeData[MBMAXTYPE];
 
 std::vector< int > tagSizes;
 
 /**\brief The over-allocation factor for entities in a sequence (strictly >= 1.0) */
 double sequence_multiplier;
};
 
} // namespace moab
 
#endif