BulkData.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 Sandia Corporation.                     */
/*  Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive   */
/*  license for use of this work by or on behalf of the U.S. Government.  */
/*  Export of this program may require a license from the                 */
/*  United States Government.                                             */
/*------------------------------------------------------------------------*/


#ifndef stk_mesh_BulkData_hpp
#define stk_mesh_BulkData_hpp

//----------------------------------------------------------------------

#include <map>

#include <stk_util/parallel/Parallel.hpp>
#include <stk_util/parallel/DistributedIndex.hpp>

#include <stk_mesh/base/Types.hpp>
#include <stk_mesh/base/Field.hpp>
#include <stk_mesh/base/MetaData.hpp>
#include <stk_mesh/baseImpl/EntityRepository.hpp>
#include <stk_mesh/base/Ghosting.hpp>
#include <stk_mesh/base/Selector.hpp>
#include <stk_mesh/baseImpl/BucketRepository.hpp>

//----------------------------------------------------------------------

namespace stk {
namespace mesh {

//----------------------------------------------------------------------
class BulkData {
public:

  enum BulkDataSyncState { MODIFIABLE = 1 , SYNCHRONIZED = 2 };

  ~BulkData();

  BulkData( const MetaData & mesh_meta_data ,
            ParallelMachine parallel ,
            unsigned bucket_max_size = 1000 );

  //------------------------------------
  const MetaData & mesh_meta_data() const { return m_mesh_meta_data ; }

  ParallelMachine parallel() const { return m_parallel_machine ; }

  unsigned parallel_size()   const { return m_parallel_size ; }

  unsigned parallel_rank()   const { return m_parallel_rank ; }

  //------------------------------------
  unsigned bucket_capacity() const { return m_bucket_repository.bucket_capacity(); }

  //------------------------------------
  BulkDataSyncState synchronized_state() const { return m_sync_state ; }

  size_t synchronized_count() const { return m_sync_count ; }

  bool modification_begin();

  bool modification_end();

  void change_entity_owner( const std::vector<EntityProc> & );

  void update_field_data_states() const { m_bucket_repository.update_field_data_states(); }


  void copy_entity_fields( const Entity & src, Entity & dest) {
    //TODO fix const correctness for src
    Entity & non_const_src = const_cast<Entity &>(src);
    m_bucket_repository.copy_fields(
        dest.bucket(),
        dest.bucket_ordinal(),
        non_const_src.bucket(),
        non_const_src.bucket_ordinal()
    );
  }

  //------------------------------------
  const std::vector<Bucket*> & buckets( EntityRank type ) const
  { return m_bucket_repository.buckets(type); }


  Entity * get_entity( EntityRank entity_rank , EntityId entity_id , const char * /* required_by */ = NULL  ) const {
    verify_type_and_id("BulkData::get_entity", entity_rank, entity_id);
    return m_entity_repo.get_entity( EntityKey(entity_rank, entity_id));
  }

  Entity * get_entity( const EntityKey key ) const  {
    return m_entity_repo.get_entity(key);
  }
  //------------------------------------
  Entity & declare_entity( EntityRank ent_type ,
                           EntityId ent_id , const std::vector<Part*> & parts);

  void change_entity_parts( Entity & ,
                            const std::vector<Part*> & add_parts ,
                            const std::vector<Part*> & remove_parts =
                                  std::vector<Part*>() );

  bool destroy_entity( Entity * & );

  //------------------------------------

  void generate_new_entities(const std::vector<size_t>& requests,
                         std::vector<Entity *>& requested_entities);

  //------------------------------------
  void declare_relation( Entity & e_from ,
                         Entity & e_to ,
                         const unsigned local_id );

  void declare_relation( Entity & , const std::vector<Relation> & );

  void destroy_relation( Entity & e_from , Entity & e_to );

  //------------------------------------
  //------------------------------------
  const std::vector<Entity*> & entity_comm() const
    { return m_entity_comm ; }

  //------------------------------------
  Ghosting & shared_aura() const { return * m_ghosting[1] ; }

  Ghosting & create_ghosting( const std::string & name );

  void change_ghosting( Ghosting & ,
                        const std::vector<EntityProc> & add_send ,
                        const std::vector<Entity*> & remove_receive );

  void destroy_all_ghosting();

  const std::vector<Ghosting*> & ghostings() const { return m_ghosting ; }

  //------------------------------------
  void assert_ok_to_modify( const char * ) const ;

  void assert_entity_owner( const char * , const Entity & , unsigned ) const ;

  void assert_good_key( const char * , const EntityKey & ) const ;

  //------------------------------------
private:
  void verify_type_and_id(const char* calling_method,
                          EntityRank ent_type, EntityId ent_id) const;

#ifndef DOXYGEN_COMPILE


  BulkData();
  BulkData( const BulkData & );
  BulkData & operator = ( const BulkData & );


  parallel::DistributedIndex          m_entities_index ;
  impl::EntityRepository              m_entity_repo ;
  impl::BucketRepository              m_bucket_repository ;
  std::vector<Entity*>                m_entity_comm ;
  std::vector<Ghosting*>              m_ghosting ; 
  // Other information:
  const MetaData &   m_mesh_meta_data ;
  ParallelMachine    m_parallel_machine ;
  unsigned           m_parallel_size ;
  unsigned           m_parallel_rank ;
  size_t             m_sync_count ;
  BulkDataSyncState  m_sync_state ;
  bool               m_meta_data_verified ;

  unsigned determine_new_owner( Entity & ) const ;

  /*  Entity modification consequences:
   *  1) Change entity relation => update via part relation => change parts
   *  2) Change parts => update forward relations via part relation
   *                  => update via field relation
   */
  void internal_change_entity_parts( Entity & ,
                                     const PartVector & add_parts ,
                                     const PartVector & remove_parts );

  void internal_propagate_part_changes( Entity & , const PartVector & removed );

  void internal_change_ghosting( Ghosting & ,
                                 const std::vector<EntityProc> & add_send ,
                                 const std::vector<Entity*> & remove_receive );

  bool internal_modification_end( bool regenerate_aura );
    void internal_resolve_shared_modify_delete();
    void internal_resolve_ghosted_modify_delete();
    void internal_resolve_parallel_create();
    void internal_resolve_shared_membership();

  void internal_update_distributed_index( std::vector<Entity*> & shared_new );

  void owner_send_to_all( Entity * , std::vector<EntityProc> & ) const ;

  void internal_regenerate_shared_aura();

  friend class UnitTestBulkData ;
#endif /* DOXYGEN_COMPILE */
};

void set_field_relations( Entity & e_from ,
                          Entity & e_to ,
                          const unsigned ident );

} // namespace mesh
} // namespace stk

//----------------------------------------------------------------------
//----------------------------------------------------------------------

#endif //  stk_mesh_BulkData_hpp