MetaData.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010, 2011 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_MetaData_hpp
#define stk_mesh_MetaData_hpp

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

#include <iosfwd>

#include <stk_util/util/SameType.hpp>
#include <stk_util/util/StaticAssert.hpp>
#include <stk_util/parallel/Parallel.hpp>

#include <stk_mesh/base/Types.hpp>
#include <stk_mesh/base/Part.hpp>
#include <stk_mesh/base/Field.hpp>
#include <stk_mesh/base/PropertyBase.hpp>
#include <stk_mesh/base/EntityKey.hpp>
#include <stk_mesh/base/Selector.hpp>

#include <stk_mesh/baseImpl/PartRepository.hpp>
#include <stk_mesh/baseImpl/FieldBaseImpl.hpp>
#include <stk_mesh/baseImpl/FieldRepository.hpp>

namespace stk_classic {
namespace mesh {

namespace fem {
class FEMMetaData;
}

std::ostream &
print_entity_key( std::ostream & os, const MetaData & meta_data, const EntityKey & key);

std::string
print_entity_key( const MetaData & meta_data, const EntityKey & key );

//----------------------------------------------------------------------
class MetaData {
public:

  //------------------------------------
  inline static MetaData & get( const Part & part ) { return part.meta_data(); }
  inline static MetaData & get( const FieldBase & field ) { return field.meta_data(); }
  inline static MetaData & get( const PropertyBase & property ) { return property.meta_data(); }

  static MetaData & get( const BulkData & bulk_data );
  static MetaData & get( const Bucket & bucket );
  static MetaData & get( const Entity & entity );
  static MetaData & get( const Ghosting & ghost );

  explicit MetaData( const std::vector<std::string>& entity_rank_names );

  MetaData();

  //------------------------------------
  Part & universal_part() const { return *m_universal_part; }

  Part & locally_owned_part()  const { return *m_owns_part ; }

  Part & globally_shared_part() const { return *m_shares_part ; }

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

  Part * get_part( const std::string & p_name,
                   const char * required_by = NULL ) const ;

  Part & get_part( unsigned ord ) const ;

  const PartVector & get_parts() const { return m_part_repo.get_all_parts(); }

  Part & declare_part( const std::string & p_name, EntityRank rank );

  Part & declare_part( const std::string & p_name);

  Part & declare_part( const PartVector & p_name);

  void declare_part_subset( Part & superset , Part & subset );

  void declare_part_relation( Part & root_part ,
                              relation_stencil_ptr stencil ,
                              Part & target_part );

  template<class T>
  const T * declare_attribute_with_delete( Part & part, const T * attribute);
  template<class T>
  const T * declare_attribute_no_delete( Part & part, const T * attribute);
  template<class T>
  bool remove_attribute( Part & part, const T * attribute);

  //------------------------------------
  void set_entity_rank_names(const std::vector<std::string> &entity_rank_names);

  EntityRank entity_rank( const std::string &name ) const;

  const std::vector<std::string> & entity_rank_names() const
    { return m_entity_rank_names ; }

  std::vector<std::string>::size_type entity_rank_count() const
    { return m_entity_rank_names.size(); }

  const std::string & entity_rank_name( EntityRank entity_rank ) const ;

  bool check_rank(EntityRank rank) const;

  //------------------------------------
  template< class field_type >
  field_type * get_field( const std::string & name ) const ;

  const FieldVector & get_fields() const {
    return m_field_repo.get_fields() ;
  }

  template< class field_type >
  field_type & declare_field( const std::string & name ,
                              unsigned number_of_states = 1 );

  template<class T>
  const T * declare_attribute_with_delete( FieldBase & field, const T * attribute);
  template<class T>
  const T * declare_attribute_no_delete( FieldBase & field, const T * attribute);

  template< class PointerFieldType , class ReferencedFieldType >
  void declare_field_relation( PointerFieldType & pointer_field ,
                               relation_stencil_ptr stencil ,
                               ReferencedFieldType & referenced_field );

  const std::vector<FieldRelation> & get_field_relations() const
    { return m_field_relations ; }

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

  template<class T>
  const T * get_attribute() const ;

  template<class T>
  const T * declare_attribute_with_delete( const T * attribute);

  template<class T>
  const T * declare_attribute_no_delete( const T * attribute);

  template<class T>
  bool remove_attribute( const T * );

  //------------------------------------
  template< typename DataType >
  Property<DataType> * get_property( const std::string & name ) const ;

  const std::vector< PropertyBase * > & get_properties() const
    { return m_properties ; }

  template< typename DataType >
  Property<DataType> & declare_property( const std::string & name ,
                                         unsigned size = 1 );

  void put_property( PropertyBase & property, Part & part);

  unsigned get_spatial_dimension() const { return m_spatial_dimension; }

  void commit();

  bool is_commit() const { return m_commit ; }

  ~MetaData();

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

  FieldBase * declare_field_base(
    const std::string & arg_name,
    const DataTraits  & arg_traits ,
    unsigned            arg_rank ,
    const shards::ArrayDimTag * const * arg_dim_tags ,
    unsigned arg_num_states );

  void declare_field_restriction( FieldBase      & arg_field ,
                                  EntityRank       arg_entity_rank ,
                                  const Part     & arg_part ,
                                  const unsigned * arg_stride ,
                                  const void*      arg_init_value = NULL );

  void declare_field_restriction( FieldBase      & arg_field ,
                                  EntityRank       arg_entity_rank ,
                                  const Selector & arg_selector ,
                                  const unsigned * arg_stride ,
                                  const void*      arg_init_value = NULL );
private:
  MetaData( const MetaData & );                
  MetaData & operator = ( const MetaData & );  

  Part & declare_internal_part( const std::string & p_name);

  Part & declare_internal_part( const std::string & p_name, EntityRank rank);

  bool   m_commit ;
  impl::PartRepository m_part_repo ;
  CSet   m_attributes ;

  Part * m_universal_part ;
  Part * m_owns_part ;
  Part * m_shares_part ;


  impl::FieldRepository        m_field_repo ;

  std::vector< FieldRelation > m_field_relations ;
  std::vector< PropertyBase* > m_properties ;
  std::vector< std::string >   m_entity_rank_names ;

  unsigned m_spatial_dimension;
  friend class fem::FEMMetaData;

  void require_committed() const ;

  void require_not_committed() const ;

  void require_same_mesh_meta_data( const MetaData & rhs ) const ;

  void require_valid_entity_rank( EntityRank rank) const ;

  void require_not_relation_target( const Part * const part ) const ;
  //------------------------------------

  Property<void> * get_property_base( const std::string & ,
                                      const std::type_info & ,
                                      unsigned = 0 ) const ;

  void internal_declare_field_relation( FieldBase & ,
                                        relation_stencil_ptr ,
                                        FieldBase & );

  void clean_field_restrictions();
};

void verify_parallel_consistency( const MetaData & , ParallelMachine );

template< class field_type >
field_type & put_field( field_type & field ,
                        EntityRank  entity_rank ,
                        const Part & part ,
                        const void* init_value = NULL);

template< class field_type >
field_type & put_field( field_type & field ,
                        EntityRank  entity_rank ,
                        const Selector & selector ,
                        const void* init_value = NULL);

template< class field_type >
field_type & put_field( field_type & field ,
                        EntityRank  entity_rank ,
                        const Part & part ,
                        unsigned     n1 ,
                        const void* init_value = NULL);

template< class field_type >
field_type & put_field( field_type & field ,
                        EntityRank  entity_rank ,
                        const Selector & selector ,
                        unsigned     n1 ,
                        const void* init_value = NULL);

template< class field_type >
field_type & put_field( field_type & field ,
                        EntityRank  entity_rank ,
                        const Part & part ,
                        unsigned     n1 ,
                        unsigned     n2 ,
                        const void* init_value = NULL);

template< class field_type >
field_type & put_field( field_type & field ,
                        EntityRank  entity_rank ,
                        const Selector & selector ,
                        unsigned     n1 ,
                        unsigned     n2 ,
                        const void* init_value = NULL);

template< class field_type >
field_type & put_field( field_type & field ,
                        EntityRank  entity_rank ,
                        const Part & part ,
                        unsigned     n1 ,
                        unsigned     n2 ,
                        unsigned     n3 ,
                        const void* init_value = NULL);

template< class field_type >
field_type & put_field( field_type & field ,
                        EntityRank  entity_rank ,
                        const Selector & selector ,
                        unsigned     n1 ,
                        unsigned     n2 ,
                        unsigned     n3 ,
                        const void* init_value = NULL);

template< class field_type >
field_type & put_field( field_type & field ,
                        EntityRank  entity_rank ,
                        const Part & part ,
                        unsigned     n1 ,
                        unsigned     n2 ,
                        unsigned     n3 ,
                        unsigned     n4 ,
                        const void* init_value = NULL);

template< class field_type >
field_type & put_field( field_type & field ,
                        EntityRank  entity_rank ,
                        const Part & part ,
                        unsigned     n1 ,
                        unsigned     n2 ,
                        unsigned     n3 ,
                        unsigned     n4 ,
                        unsigned     n5 ,
                        const void* init_value = NULL);

template< class field_type >
field_type & put_field( field_type & field ,
                        EntityRank  entity_rank ,
                        const Part & part ,
                        unsigned     n1 ,
                        unsigned     n2 ,
                        unsigned     n3 ,
                        unsigned     n4 ,
                        unsigned     n5 ,
                        unsigned     n6 ,
                        const void* init_value = NULL);

template< class field_type >
field_type & put_field( field_type & field ,
                        EntityRank  entity_rank ,
                        const Part & part ,
                        unsigned     n1 ,
                        unsigned     n2 ,
                        unsigned     n3 ,
                        unsigned     n4 ,
                        unsigned     n5 ,
                        unsigned     n6 ,
                        unsigned     n7 ,
                        const void* init_value = NULL);
} // namespace mesh
} // namespace stk_classic

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

#ifndef DOXYGEN_COMPILE

namespace stk_classic {
namespace mesh {

inline
Part & MetaData::get_part( unsigned ord ) const
{ return * m_part_repo.get_all_parts()[ord] ; }

template< class field_type >
inline
field_type * MetaData::get_field( const std::string & name ) const
{
  typedef FieldTraits< field_type > Traits ;

  const DataTraits & dt = data_traits< typename Traits::data_type >();

  const shards::ArrayDimTag * tags[8] ;

  Traits::assign_tags( tags );

  FieldBase * const field =
    m_field_repo.get_field( "stk_classic::mesh::MetaData::get_field" ,
                          name , dt , Traits::Rank , tags , 0 );

  return static_cast< field_type * >( field );
}

template< class field_type >
inline
field_type & MetaData::declare_field( const std::string & name ,
                                      unsigned number_of_states )
{
  typedef FieldTraits< field_type > Traits ;

  const DataTraits & dt = data_traits< typename Traits::data_type >();

  const shards::ArrayDimTag * tags[8] ;

  Traits::assign_tags( tags );

  return * static_cast< field_type * >(
    declare_field_base( name , dt , Traits::Rank , tags , number_of_states ) );
}

template< class field_type >
inline
field_type & put_field(
  field_type & field ,
  EntityRank entity_rank ,
  const Part & part ,
  const void* init_value)
{
  typedef FieldTraits< field_type > Traits ;
  typedef typename Traits::Helper   Helper ;

  unsigned stride[8] ;

  Helper::assign( stride );

  MetaData::get(field).declare_field_restriction( field, entity_rank, part, stride, init_value);

  return field ;
}

template< class field_type >
inline
field_type & put_field(
  field_type & field ,
  EntityRank entity_rank ,
  const Selector & selector ,
  const void* init_value)
{
  typedef FieldTraits< field_type > Traits ;
  typedef typename Traits::Helper   Helper ;

  unsigned stride[8] ;

  Helper::assign( stride );

  MetaData::get(field).declare_field_restriction( field, entity_rank, selector, stride, init_value);

  return field ;
}

template< class field_type >
inline
field_type & put_field( field_type &field ,
                        EntityRank entity_rank ,
                        const Part &part ,
                        unsigned    n1 ,
                        const void* init_value )
{
  typedef FieldTraits< field_type > Traits ;
  typedef typename Traits::Helper   Helper ;

  unsigned stride[8] ;

  Helper::assign( stride , n1 );

  MetaData::get(field).declare_field_restriction( field, entity_rank, part, stride, init_value);

  return field ;
}

template< class field_type >
inline
field_type & put_field( field_type &field ,
                        EntityRank entity_rank ,
                        const Selector &selector ,
                        unsigned    n1 ,
                        const void* init_value )
{
  typedef FieldTraits< field_type > Traits ;
  typedef typename Traits::Helper   Helper ;

  unsigned stride[8] ;

  Helper::assign( stride , n1 );

  MetaData::get(field).declare_field_restriction( field, entity_rank, selector, stride, init_value);

  return field ;
}

template< class field_type >
inline
field_type & put_field( field_type &field ,
                        EntityRank entity_rank ,
                        const Part &part ,
                        unsigned    n1 ,
                        unsigned    n2 ,
                        const void* init_value )
{
  typedef FieldTraits< field_type > Traits ;
  typedef typename Traits::Helper   Helper ;

  unsigned stride[8] ;

  Helper::assign( stride , n1 , n2 );

  MetaData::get(field).declare_field_restriction( field, entity_rank, part, stride, init_value);

  return field ;
}

template< class field_type >
inline
field_type & put_field( field_type &field ,
                        EntityRank entity_rank ,
                        const Selector &selector ,
                        unsigned    n1 ,
                        unsigned    n2 ,
                        const void* init_value )
{
  typedef FieldTraits< field_type > Traits ;
  typedef typename Traits::Helper   Helper ;

  unsigned stride[8] ;

  Helper::assign( stride , n1 , n2 );

  MetaData::get(field).declare_field_restriction( field, entity_rank, selector, stride, init_value);

  return field ;
}

template< class field_type >
inline
field_type & put_field( field_type &field ,
                        EntityRank entity_rank ,
                        const Part &part ,
                        unsigned    n1 ,
                        unsigned    n2 ,
                        unsigned    n3 ,
                        const void* init_value )
{
  typedef FieldTraits< field_type > Traits ;
  typedef typename Traits::Helper   Helper ;

  unsigned stride[8] ;

  Helper::assign( stride , n1 , n2 , n3 );

  MetaData::get(field).declare_field_restriction( field, entity_rank, part, stride, init_value);

  return field ;
}

template< class field_type >
inline
field_type & put_field( field_type &field ,
                        EntityRank entity_rank ,
                        const Selector &selector ,
                        unsigned    n1 ,
                        unsigned    n2 ,
                        unsigned    n3 ,
                        const void* init_value )
{
  typedef FieldTraits< field_type > Traits ;
  typedef typename Traits::Helper   Helper ;

  unsigned stride[8] ;

  Helper::assign( stride , n1 , n2 , n3 );

  MetaData::get(field).declare_field_restriction( field, entity_rank, selector, stride, init_value);

  return field ;
}

template< class field_type >
inline
field_type & put_field( field_type &field ,
                        EntityRank entity_rank ,
                        const Part &part ,
                        unsigned    n1 ,
                        unsigned    n2 ,
                        unsigned    n3 ,
                        unsigned    n4 ,
                        const void* init_value )
{
  typedef FieldTraits< field_type > Traits ;
  typedef typename Traits::Helper   Helper ;

  unsigned stride[8] ;

  Helper::assign( stride , n1 , n2 , n3 , n4 );

  MetaData::get(field).declare_field_restriction( field, entity_rank, part, stride, init_value);

  return field ;
}

template< class field_type >
inline
field_type & put_field( field_type &field ,
                        EntityRank entity_rank ,
                        const Part &part ,
                        unsigned    n1 ,
                        unsigned    n2 ,
                        unsigned    n3 ,
                        unsigned    n4 ,
                        unsigned    n5 ,
                        const void* init_value )
{
  typedef FieldTraits< field_type > Traits ;
  typedef typename Traits::Helper   Helper ;

  unsigned stride[8] ;

  Helper::assign( stride , n1 , n2 , n3 , n4, n5 );

  MetaData::get(field).declare_field_restriction( field, entity_rank, part, stride, init_value);

  return field ;
}

template< class field_type >
inline
field_type & put_field( field_type &field ,
                        EntityRank entity_rank ,
                        const Part &part ,
                        unsigned    n1 ,
                        unsigned    n2 ,
                        unsigned    n3 ,
                        unsigned    n4 ,
                        unsigned    n5 ,
                        unsigned    n6 ,
                        const void* init_value )
{
  typedef FieldTraits< field_type > Traits ;
  typedef typename Traits::Helper   Helper ;

  unsigned stride[8] ;

  Helper::assign( stride , n1 , n2 , n3 , n4, n5, n6 );

  MetaData::get(field).declare_field_restriction( field, entity_rank, part, stride, init_value);

  return field ;
}

template< class field_type >
inline
field_type & put_field( field_type &field ,
                        EntityRank entity_rank ,
                        const Part &part ,
                        unsigned    n1 ,
                        unsigned    n2 ,
                        unsigned    n3 ,
                        unsigned    n4 ,
                        unsigned    n5 ,
                        unsigned    n6 ,
                        unsigned    n7 ,
                        const void* init_value )
{
  typedef FieldTraits< field_type > Traits ;
  typedef typename Traits::Helper   Helper ;

  unsigned stride[8] ;

  Helper::assign( stride , n1 , n2 , n3 , n4, n5, n6, n7 );

  MetaData::get(field).declare_field_restriction( field, entity_rank, part, stride, init_value);

  return field ;
}

template<class T>
inline
const T *
MetaData::declare_attribute_with_delete( const T * a )
{
  require_not_committed();
  return m_attributes.insert_with_delete( a );
}

template<class T>
inline
const T *
MetaData::get_attribute() const
{ return m_attributes.get<T>(); }

template<class T>
inline
const T *
MetaData::declare_attribute_no_delete( const T * attribute )
{
  require_not_committed();
  return m_attributes.insert_no_delete( attribute );
}

template<class T>
inline
bool
MetaData::remove_attribute( const T * a )
{
  return m_attributes.remove( a );
}

template<class T>
inline
const T *
MetaData::declare_attribute_with_delete( Part & part , const T * attribute )
{
  require_not_committed();
  return m_part_repo.declare_attribute_with_delete( part, attribute );
}

template<class T>
inline
const T *
MetaData::declare_attribute_no_delete( Part & part , const T * attribute )
{
  require_not_committed();
  return m_part_repo.declare_attribute_no_delete( part, attribute );
}

template<class T>
inline
bool
MetaData::remove_attribute( Part & part , const T * attribute )
{
  return m_part_repo.remove_attribute(part, attribute);
}

template<class T>
inline
const T *
MetaData::declare_attribute_with_delete( FieldBase & field , const T * attribute )
{
  require_not_committed();
  return m_field_repo.declare_attribute_with_delete(field, attribute);
}

template<class T>
inline
const T *
MetaData::declare_attribute_no_delete( FieldBase & field , const T * attribute )
{
  require_not_committed();
  return m_field_repo.declare_attribute_no_delete(field, attribute);
}

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

template< class PointerFieldType , class ReferencedFieldType >
inline
void MetaData::declare_field_relation(
  PointerFieldType & pointer_field ,
  relation_stencil_ptr stencil ,
  ReferencedFieldType & referenced_field )
{
  typedef typename FieldTraits< PointerFieldType >::data_type pointer_type ;
  typedef typename FieldTraits< ReferencedFieldType >::data_type data_type ;

  StaticAssert< SameType< pointer_type , data_type * >::value >::ok();
  StaticAssert< FieldTraits< PointerFieldType >::Rank == 1 >::ok();

  internal_declare_field_relation( pointer_field , stencil , referenced_field );
}

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

template< typename DataType >
inline
Property<DataType> *
MetaData::get_property( const std::string & name ) const
{
  Property<void> * const pv = get_property_base( name, typeid(DataType) );
  return pv ? pv->property<DataType>() : (Property<DataType>*) NULL ;
}

template< typename DataType >
inline
Property<DataType> &
MetaData::declare_property( const std::string & name , unsigned size )
{
  Property<void> * pv = get_property_base(name,typeid(DataType),size);
  Property<DataType> * prop = NULL ;

  if ( pv != NULL ) {
    prop = pv->property<DataType>();
  }
  else {
    if ( 1 == size ) {
      pv = prop = new Property<DataType>( *this , m_properties.size() , name );
    }
    else {
      pv = prop = new Property< std::vector<DataType> >(
                    *this , m_properties.size() , name , size );
    }
    m_properties.push_back( pv );
  }
  return *prop ;
}

inline
void MetaData::put_property( PropertyBase & property , Part & part )
{
  property.add_property( part.mesh_meta_data_ordinal() );
}

inline
bool MetaData::check_rank(EntityRank rank) const
{
  return rank < m_entity_rank_names.size();
}

inline
bool
is_auto_declared_part(const Part &part)
{
  const std::string &part_name = part.name();

  return !part_name.empty() && part_name[0] == '{';
}

} // namespace mesh
} // namespace stk_classic

#endif /* DOXYGEN_COMPILE */

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

#endif /* stk_mesh_MetaData_hpp */