IossBridge.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_io_IossBridge_hpp
#define stk_io_IossBridge_hpp

#include <string>
#include <stk_util/parallel/Parallel.hpp>
#include <stk_mesh/base/Types.hpp>
#include <stk_mesh/fem/CoordinateSystems.hpp>
#include <stk_mesh/fem/FEMMetaData.hpp>

// TODO: remove this and uses of USE_FEMMETADATA once the migration is done (srkenno@sandia.gov)

#define USE_FEMMETADATA
#ifdef USE_FEMMETADATA
#include <stk_mesh/fem/FEMHelpers.hpp>
#endif

#include <stk_mesh/fem/TopologyDimensions.hpp>
#include <Ioss_DBUsage.h>
#include <Ioss_Field.h>
#include <Ioss_SideBlock.h>
#include <Ioss_ElementTopology.h>

namespace Ioss {
class Region;
class GroupingEntity;
class EntityBlock;
class SideSet;
class Field;
class ElementTopology;
}

struct CellTopologyData;

namespace stk_classic {

namespace io {

bool include_entity(const Ioss::GroupingEntity *entity);

void internal_part_processing(Ioss::GroupingEntity *entity, stk_classic::mesh::fem::FEMMetaData &meta);

void internal_part_processing(Ioss::EntityBlock *entity, stk_classic::mesh::fem::FEMMetaData &meta);

void internal_part_processing(Ioss::GroupingEntity *entity, stk_classic::mesh::MetaData &meta);

void internal_part_processing(Ioss::EntityBlock *entity, stk_classic::mesh::MetaData &meta);

template <typename T>
void default_part_processing(const std::vector<T*> &entities,
                             stk_classic::mesh::fem::FEMMetaData &fem_meta)
{
  for(size_t i=0; i < entities.size(); i++) {
    T* entity = entities[i];
    internal_part_processing(entity, fem_meta);
  }
}

template <typename T>
void default_part_processing(const std::vector<T*> &entities, stk_classic::mesh::MetaData &meta,
                             const stk_classic::mesh::EntityRank)
{
  stk_classic::mesh::fem::FEMMetaData &fem_meta = stk_classic::mesh::fem::FEMMetaData::get(meta);
  default_part_processing (entities, fem_meta);
}

void define_output_db( Ioss::Region & io_region,
                       const mesh::BulkData& bulk_data,
                       const Ioss::Region *input_region = NULL,
                       const stk_classic::mesh::Selector *anded_selector = NULL,
                       const bool sort_stk_parts = false);


void write_output_db( Ioss::Region & io_region ,
                      const mesh::BulkData& bulk,
                      const stk_classic::mesh::Selector *anded_selector = NULL);


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

bool is_valid_part_field(const stk_classic::mesh::FieldBase *field,
                         const stk_classic::mesh::EntityRank part_type,
                         const stk_classic::mesh::Part &part,
                         const stk_classic::mesh::Part &universal,
                         const Ioss::Field::RoleType filter_role,
                         const bool add_all = false);

void ioss_add_fields(const stk_classic::mesh::Part &part,
                     const stk_classic::mesh::EntityRank part_type,
                     Ioss::GroupingEntity *entity,
                     const Ioss::Field::RoleType filter_role,
                     const bool add_all = false);

void define_io_fields(Ioss::GroupingEntity *entity,
                      Ioss::Field::RoleType role,
                      stk_classic::mesh::Part &part,
                      stk_classic::mesh::EntityRank part_type);

const CellTopologyData *map_topology_ioss_to_cell(const Ioss::ElementTopology *topology);

std::string map_topology_cell_to_ioss( const CellTopologyData *cell_top,
                                       int spatial_dimension);

void get_entity_list(Ioss::GroupingEntity *io_entity,
                     stk_classic::mesh::EntityRank part_type,
                     const stk_classic::mesh::BulkData &bulk,
                     std::vector<stk_classic::mesh::Entity*> &entities);

void field_data_from_ioss(const stk_classic::mesh::FieldBase *field,
                          std::vector<stk_classic::mesh::Entity*> &entities,
                          Ioss::GroupingEntity *io_entity,
                          const std::string &io_fld_name);

void field_data_to_ioss(const stk_classic::mesh::FieldBase *field,
                        std::vector<stk_classic::mesh::Entity*> &entities,
                        Ioss::GroupingEntity *io_entity,
                        const std::string &io_fld_name,
                        Ioss::Field::RoleType filter_role);


const mesh::Field<double, mesh::ElementNode> *get_distribution_factor_field(const mesh::Part &p);

void set_distribution_factor_field(mesh::Part &p,
                                   const mesh::Field<double, mesh::ElementNode> &df_field);

const Ioss::Field::RoleType* get_field_role(const mesh::FieldBase &f);

void set_field_role(mesh::FieldBase &f, const Ioss::Field::RoleType &role);

bool is_part_io_part(mesh::Part &part);

void put_io_part_attribute( mesh::Part &part, Ioss::GroupingEntity *entity = NULL);

void remove_io_part_attribute(mesh::Part &part);

const Ioss::GroupingEntity *get_associated_ioss_entity(const mesh::Part &part);

size_t db_api_int_size(const Ioss::GroupingEntity *entity);

// To minimize ifdefs for the deprecated code:
bool invalid_rank(mesh::EntityRank rank);
mesh::EntityRank part_primary_entity_rank(const mesh::Part &part);
mesh::EntityRank element_rank(const mesh::MetaData &meta);
mesh::EntityRank side_rank(const mesh::MetaData &meta);
mesh::EntityRank face_rank(const mesh::MetaData &meta);
mesh::EntityRank edge_rank(const mesh::MetaData &meta);
mesh::EntityRank node_rank(const mesh::MetaData &meta);
void set_cell_topology(mesh::Part &part, const CellTopologyData * const cell_topology);
const CellTopologyData *get_cell_topology(const mesh::Part &part);

void initialize_spatial_dimension(mesh::fem::FEMMetaData &fem_meta, size_t spatial_dimension, const std::vector<std::string> &entity_rank_names);

void initialize_spatial_dimension(mesh::MetaData &meta, size_t spatial_dimension, const std::vector<std::string> &entity_rank_names);

void get_io_field_type(const stk_classic::mesh::FieldBase *field,
                       const stk_classic::mesh::FieldRestriction &res,
                       std::pair<std::string, Ioss::Field::BasicType> *result);
}//namespace io
}//namespace stk_classic
#endif