FEMMetaData.hpp

#ifndef stk_mesh_FEMMetaData_hpp
#define stk_mesh_FEMMetaData_hpp

#include <stk_util/environment/ReportHandler.hpp>
#include <stk_util/util/string_case_compare.hpp>
#include <stk_mesh/base/Types.hpp>
#include <stk_mesh/base/MetaData.hpp>
#include <stk_mesh/base/BulkData.hpp> // TODO:  Remove!
#include <stk_mesh/fem/CellTopology.hpp>

#include <vector>
#include <string>

namespace stk_classic {
namespace mesh {
namespace fem {


// 02/10/11 FEMMetaData Todo:
// * Implement get_cell_topology for Part.
// * Implement declare_part with cell topology
// Non-critical:
// * Implement stk_classic::mesh::fem::get namespace to include getters for MetaData,
//   BulkData, FEMMetaData, FEMBulkData, CellTopology from things like Part,
//   Bucket, Entity, etc.
// * Create impl class inside the handle classes to hold their parent pointer
//   and a friend to the getter above.

class FEMMetaData {
  public:

  typedef std::map<fem::CellTopology, std::pair<Part *, EntityRank> > CellTopologyPartEntityRankMap;
  typedef std::vector<fem::CellTopology> PartCellTopologyVector;


#ifdef SWIG   //SRK from NLM, this is to avoid pulling in a bunch more headers just to define EntityRank
  enum
  {
    INVALID_RANK = stk_classic::mesh::InvalidEntityRank,
    NODE_RANK = 0u,
    EDGE_RANK = 1u,
    FACE_RANK = 2u,
    VOLUME_RANK = 3u
  };
#else
  static const EntityRank INVALID_RANK = stk_classic::mesh::InvalidEntityRank;
  static const EntityRank NODE_RANK = 0u;
  static const EntityRank EDGE_RANK = 1u;
  static const EntityRank FACE_RANK = 2u;
  static const EntityRank VOLUME_RANK = 3u;
#endif

  FEMMetaData();
  ~FEMMetaData() {}

  FEMMetaData(size_t spatial_dimension,
              const std::vector<std::string>& in_entity_rank_names = std::vector<std::string>());



  void FEM_initialize(
      size_t spatial_dimension,
      const std::vector<std::string>& in_entity_rank_names = std::vector<std::string>()
      );

  bool is_FEM_initialized() const
  {
    return m_fem_initialized;
  }

  // NOTE: This is a temporary function that will be removed once a FEMBulkData exists.
  inline static MetaData & get_meta_data( FEMMetaData & fem_meta )
    { return fem_meta.m_meta_data; }

  size_t spatial_dimension() const
  {
    return m_spatial_dimension;
  }

  EntityRank node_rank() const
  {
    return NODE_RANK;
  }

  EntityRank edge_rank() const
  {
    return EDGE_RANK;
  }

  EntityRank face_rank() const
  {
    return FACE_RANK;
  }

  EntityRank volume_rank() const
  {
    return VOLUME_RANK;
  }

  EntityRank side_rank() const
  {
    return m_side_rank;
  }

  EntityRank element_rank() const
  {
    return m_element_rank;
  }
  //  void check_topo_db();

  bool check_rank(EntityRank rank) const;

  void register_cell_topology(const fem::CellTopology cell_topology, EntityRank in_entity_rank);

  Part &get_cell_topology_root_part(const fem::CellTopology cell_topology) const;

  fem::CellTopology get_cell_topology( const Part & part) const;

  fem::CellTopology get_cell_topology( const std::string & topology_name) const;

  EntityRank get_entity_rank(const fem::CellTopology cell_topology) const;

  inline static FEMMetaData & get ( const MetaData & meta )
    { return *const_cast<FEMMetaData * >(meta.get_attribute<FEMMetaData>()); }

  inline static FEMMetaData & get( const Part & part )
    { return FEMMetaData::get(MetaData::get(part)); }

  inline static FEMMetaData & get( const FieldBase & field )
    { return FEMMetaData::get(MetaData::get(field)); }

  inline static FEMMetaData & get( const PropertyBase & property )
    { return FEMMetaData::get(MetaData::get(property)); }

  inline static FEMMetaData & get( const BulkData & bulk_data )
    { return FEMMetaData::get(MetaData::get(bulk_data)); }

  inline static FEMMetaData & get( const Bucket & bucket )
    { return FEMMetaData::get(MetaData::get(bucket)); }

  inline static FEMMetaData & get( const Entity & entity )
    { return FEMMetaData::get(MetaData::get(entity)); }

  inline static FEMMetaData & get( const Ghosting & ghost )
    { return FEMMetaData::get(MetaData::get(ghost)); }

  Part &declare_part( const std::string &name, fem::CellTopology cell_topology)
  {
    ThrowRequireMsg(is_FEM_initialized(),"FEMMetaData::declare_part: FEM_initialize() must be called before this function");
    Part &root_part = get_cell_topology_root_part(cell_topology);
    EntityRank primary_entity_rank = root_part.primary_entity_rank();
    Part & part = m_meta_data.declare_part(name, primary_entity_rank);
    declare_part_subset(root_part, part);
    return part;
  }

  template< class Top >
  Part &declare_part(const std::string &name) {
    return declare_part(name, shards::getCellTopologyData<Top>());
  }



  //------------------------------------
  Part & universal_part() const { return m_meta_data.universal_part(); }

  Part & locally_owned_part()  const { return m_meta_data.locally_owned_part(); }

  Part & globally_shared_part() const { return m_meta_data.globally_shared_part(); }

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

  Part * get_part( const std::string & p_name,
                   const char * required_by = NULL ) const
    { return m_meta_data.get_part(p_name,required_by); }

  Part & get_part( unsigned ord ) const
    { return m_meta_data.get_part(ord); }

  const PartVector & get_parts() const
    { return m_meta_data.get_parts(); }

  Part & declare_part( const std::string & p_name, EntityRank rank )
    { return m_meta_data.declare_part(p_name,rank); }

  Part & declare_part( const std::string & p_name)
    { return m_meta_data.declare_part(p_name); }

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

  void declare_part_relation( Part & root_part ,
                              relation_stencil_ptr stencil ,
                              Part & target_part )
    { m_meta_data.declare_part_relation(root_part, stencil, target_part); }

  void set_entity_rank_names(const std::vector<std::string> &in_entity_rank_names)
  {
    m_entity_rank_names = in_entity_rank_names;
    m_meta_data.set_entity_rank_names(in_entity_rank_names);
  }

  EntityRank entity_rank( const std::string &name ) const
  {
    EntityRank my_entity_rank = InvalidEntityRank;

    for (size_t i = 0; i < m_entity_rank_names.size(); ++i)
      if (equal_case(name, m_entity_rank_names[i])) {
        my_entity_rank = i;
      break;
      }
    return my_entity_rank;
  }

  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 in_entity_rank ) const
  {
    ThrowErrorMsgIf( in_entity_rank >= m_entity_rank_names.size(),
        "entity-rank " << in_entity_rank <<
        " out of range. Must be in range 0.." << m_entity_rank_names.size());
    return m_entity_rank_names[in_entity_rank];
  }

  bool is_valid_entity_rank(EntityRank rank) const
  {
    return rank < m_entity_rank_names.size();
  }

  //------------------------------------
  template< class field_type >
  field_type * get_field( const std::string & name ) const
    { return m_meta_data.get_field<field_type>(name); }

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

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

  template< class PointerFieldType , class ReferencedFieldType >
  void declare_field_relation( PointerFieldType & pointer_field ,
                               relation_stencil_ptr stencil ,
                               ReferencedFieldType & referenced_field )
    { return m_meta_data.declare_field_relation( pointer_field, stencil, referenced_field ); }

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

  void commit()
    { m_meta_data.commit(); }

  bool is_commit() const
    { return m_meta_data.is_commit(); }

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

  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 )
    { return m_meta_data.declare_field_base( arg_name, arg_traits, arg_rank, arg_dim_tags, 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)
    { m_meta_data.declare_field_restriction(arg_field, arg_entity_rank, arg_part, arg_stride, arg_init_value); }

  private: // functions

    Part & declare_internal_part( const std::string & p_name, EntityRank rank )
    { return m_meta_data.declare_internal_part(p_name,rank); }

    void internal_set_spatial_dimension_and_ranks(size_t spatial_dimension);

    void internal_declare_known_cell_topology_parts();

  private: // data
    MetaData                      m_meta_data;
    bool                          m_fem_initialized;
    size_t                        m_spatial_dimension;
    EntityRank                    m_side_rank;
    EntityRank                    m_element_rank;
    std::vector< std::string >    m_entity_rank_names;
    CellTopologyPartEntityRankMap m_cellTopologyPartEntityRankMap;
    PartCellTopologyVector        m_partCellTopologyVector;
};

bool is_cell_topology_root_part(const Part & part);

void set_cell_topology( Part &part, const fem::CellTopology cell_topology);

template<class Topology>
inline void set_cell_topology(Part & part)
{
  stk_classic::mesh::fem::set_cell_topology(part, fem::CellTopology(shards::getCellTopologyData<Topology>()));
}


CellTopology get_cell_topology(const Bucket &bucket);


inline CellTopology get_cell_topology(const Entity &entity) {
  return get_cell_topology(entity.bucket());
}

inline
bool FEMMetaData::check_rank(EntityRank rank) const
{
  return m_meta_data.check_rank(rank);
}


std::vector<std::string> entity_rank_names(size_t spatial_dimension);

} // namespace fem
} // namespace mesh
} // namespace stk_classic

#endif //  stk_mesh_FEMMetaData_hpp