AEntityFactory.hpp

Go to the documentation of this file.

/**
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 *
 * Copyright 2004 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
 * retains certain rights in this software.
 *
 * 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.
 *
 */
 
#ifndef AENTITY_FACTORY_HPP
#define AENTITY_FACTORY_HPP
 
#ifndef IS_BUILDING_MB
#error "AEntityFactory.hpp isn't supposed to be included into an application"
#endif
 
#include "moab/Forward.hpp"
#include <vector>
 
namespace moab
{
 
typedef std::vector< EntityHandle > AdjacencyVector;
class Core;
 
//! class AEntityFactory
class AEntityFactory
{
 public:
 //! require an Interface object in order to access tags on that interface
 AEntityFactory( Core* mdb );
 
 //! destructor
 ~AEntityFactory();
 
 //! add an adjacency from from_ent to to_ent; if both_ways is true, add one
 //! in reverse too
 //! NOTE: this function is defined even though we may only be implementing
 //! vertex-based up-adjacencies
 ErrorCode add_adjacency( EntityHandle from_ent, EntityHandle to_ent, const bool both_ways = false );
 
 //! remove an adjacency from from the base_entity.
 ErrorCode remove_adjacency( EntityHandle base_entity, EntityHandle adjacency_to_remove );
 
 //! remove all adjacencies from from the base_entity.
 ErrorCode remove_all_adjacencies( EntityHandle base_entity, const bool delete_adj_list = false );
 
 /**\brief Get adjacencies for a single source entity.
 *
 * Get adjacent entities.
 *
 *\param source_entity The entity for which to retrieve the adjacencies.
 *\param target_dimension Retrieve adjacent entities of this dimension. Must
 * be in the range [1,3], where 4 is used to indicated entity sets.
 *\param target_entities Requested adjacent entities will be appended to this list.
 *\param create_if_missing If true, adjacent elements of the specified dimension will
 * be created if they do not already exist. If the target dimension
 * is less than the dimension of the input entity and greater than zero,
 *the elements will be created as required to represent the "sides" of the source element. If
 *the target dimension is greater than that of the source entity and less than 3, then sides of
 *the specified dimension on that are a) of greater dimension and b) adjacent to the input
 *entity will be created. \param create_adjacency_option If create_adjacency_option is >= 0,
 *adjacencies from entities of that dimension to each target_entity are created (this function
 *uses AEntityFactory::get_element for each element)
 */
 ErrorCode get_elements( EntityHandle source_entity,
 const unsigned int target_dimension,
 std::vector< EntityHandle >& target_entities,
 const bool create_if_missing,
 const int create_adjacency_option = -1 );
 
 //! get the vertices for a polyhedron (special implementation because for polyhedra
 //! connectivity array stores faces)
 ErrorCode get_polyhedron_vertices( const EntityHandle source_entity, std::vector< EntityHandle >& target_entities );
 
 //! get the meshsets that are in source_entitiy's adjacency vector
 ErrorCode get_associated_meshsets( EntityHandle source_entity, std::vector< EntityHandle >& target_entities );
 
 //! get the element defined by the vertices in vertex_list, of the
 //! type target_type, passing back in target_entity; if create_if_missing
 //! is true and no entity is found, one is created; if create_adjacency_option
 //! is >= 0, adjacencies from entities of that dimension to target_entity
 //! are created (only create_adjacency_option=0 is supported right now,
 //! so that never creates other ancillary entities); explicitly require
 //! the vertex_list_size for consistency, even though we could probably get
 //! it from target_type
 ErrorCode get_element( const EntityHandle* vertex_list,
 const int vertex_list_size,
 const EntityType target_type,
 EntityHandle& target_entity,
 const bool create_if_missing,
 const EntityHandle source_entity = 0,
 const int create_adjacency_option = -1 );
 
 /**\brief Get adjacent entities
 *
 *\param entity The source entity for which to retrieve adjacent entities.
 *\param to_dimension The adjacent entities to retrieve, specified by dimension.
 *\param create_if_missing Create adjacent entities that do not already exist.
 *\param adjacent_entities The resulting adjacent entities are appended to this
 * list.
 */
 ErrorCode get_adjacencies( const EntityHandle entity,
 const unsigned int to_dimension,
 bool create_if_missing,
 std::vector< EntityHandle >& adjacent_entities );
 
 //! return const array * for adjacencies
 ErrorCode get_adjacencies( EntityHandle entity, const EntityHandle*& adjacent_entities, int& num_entities ) const;
 
 ErrorCode get_adjacencies( EntityHandle entity,
 std::vector< EntityHandle >*& adj_vec_ptr_out,
 bool create_if_missing = false );
 
 //! returns the entities in sorted order
 ErrorCode get_adjacencies( EntityHandle entity, std::vector< EntityHandle >& adjacent_entities ) const;
 
 //! creates vertex to element adjacency information
 ErrorCode create_vert_elem_adjacencies();
 
 //! returns whether vertex to element adjacencies are being stored
 bool vert_elem_adjacencies() const
 {
 return mVertElemAdj;
 }
 
 //! calling code notifying this that an entity is getting deleted
 ErrorCode notify_delete_entity( EntityHandle entity );
 
 //! calling code notifying this that to update connectivity of 'entity'
 ErrorCode notify_create_entity( const EntityHandle entity, const EntityHandle* node_array, const int number_nodes );
 
 //! calling code notifying that an entity changed its connectivity
 ErrorCode notify_change_connectivity( EntityHandle entity,
 const EntityHandle* old_array,
 const EntityHandle* new_array,
 int number_nodes );
 
 //! return true if 2 entities are explicitly adjacent
 bool explicitly_adjacent( const EntityHandle ent1, const EntityHandle ent2 );
 
 //! in preparation for merging two entities, adjust adjacencies so that
 //! entity_to_keep will be adjacent to the "right" entities after merge
 //! (also checks for potential formation of equivalent entities and
 //! creates explicit adjacencies accordingly)
 ErrorCode merge_adjust_adjacencies( EntityHandle entity_to_keep, EntityHandle entity_to_remove );
 
 void get_memory_use( unsigned long long& total_entity_storage, unsigned long long& total_storage );
 ErrorCode get_memory_use( const Range& entities,
 unsigned long long& total_entity_storage,
 unsigned long long& total_amortized_storage );
 
 private:
 ErrorCode get_adjacency_ptr( EntityHandle, std::vector< EntityHandle >*& );
 ErrorCode get_adjacency_ptr( EntityHandle, const std::vector< EntityHandle >*& ) const;
 ErrorCode set_adjacency_ptr( EntityHandle, std::vector< EntityHandle >* );
 
 ErrorCode get_vertices( EntityHandle h,
 const EntityHandle*& vect_out,
 int& count_out,
 std::vector< EntityHandle >& storage );
 
 //! private constructor to prevent the construction of a default one
 AEntityFactory();
 
 //! interface associated with this tool
 Core* thisMB;
 
 //! whether vertex to element adjacencies are begin done
 bool mVertElemAdj;
 
 //! compare vertex_list to the vertices in this_entity,
 //! and return true if they contain the same vertices
 bool entities_equivalent( const EntityHandle this_entity,
 const EntityHandle* vertex_list,
 const int vertex_list_size,
 const EntityType target_type );
 
 ErrorCode get_zero_to_n_elements( EntityHandle source_entity,
 const unsigned int target_dimension,
 std::vector< EntityHandle >& target_entities,
 const bool create_if_missing,
 const int create_adjacency_option = -1 );
 
 ErrorCode get_down_adjacency_elements( EntityHandle source_entity,
 const unsigned int target_dimension,
 std::vector< EntityHandle >& target_entities,
 const bool create_if_missing,
 const int create_adjacency_option = -1 );
 
 ErrorCode get_down_adjacency_elements_poly( EntityHandle source_entity,
 const unsigned int target_dimension,
 std::vector< EntityHandle >& target_entities,
 const bool create_if_missing,
 const int create_adjacency_option = -1 );
 
 ErrorCode get_up_adjacency_elements( EntityHandle source_entity,
 const unsigned int target_dimension,
 std::vector< EntityHandle >& target_entities,
 const bool create_if_missing,
 const int create_adjacency_option = -1 );
 
 //! check for equivalent entities that may be formed when merging two entities, and
 //! create explicit adjacencies accordingly
 ErrorCode check_equiv_entities( EntityHandle entity_to_keep, EntityHandle entity_to_remove );
 
 //! create explicit adjacencies between this_ent and all adjacent entities of higher
 //! dimension
 ErrorCode create_explicit_adjs( EntityHandle this_ent );
};
 
} // namespace moab
 
#endif