Tqdcfr.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.
 *
 */
 
/*
 * Tim's Quick 'N Dirty Cub File Reader (Tqdcfr)
 *
 */
 
#ifndef TQDCFR
#define TQDCFR
 
#include "moab/Forward.hpp"
#include "moab/ReaderIface.hpp"
#include "MBTagConventions.hpp"
#include "moab/Range.hpp"
 
#include <cstdio>
#include <string>
#include <vector>
#include <map>
 
namespace moab
{
 
class ReadUtilIface;
class FEModelHeader;
class GeomHeader;
class GroupHeader;
class BlockHeader;
class NodesetHeader;
class SidesetHeader;
 
class Tqdcfr : public ReaderIface
{
 public:
 void FSEEK( unsigned offset ); // set cubFile offset to specified value
 void FREADI( unsigned num_ents ); // read integers into uint_buf
 void FREADD( unsigned num_ents ); // read doubles into dbl_buf
 void FREADC( unsigned num_ents ); // read characters into char_buf
 void FREADIA( unsigned num_ents, unsigned int* array ); // read integers
 void FREADDA( unsigned num_ents, double* array ); // read doubles
 void FREADCA( unsigned num_ents, char* arrat ); // read bytes
 void CONVERT_TO_INTS( unsigned int num_ents ); // convert uint_buf to int_buf in-place
 
 // class for holding the file table of contents
 class FileTOC
 {
 public:
 unsigned int fileEndian, fileSchema, numModels, modelTableOffset, modelMetaDataOffset, activeFEModel;
 
 FileTOC();
 void print();
 };
 
 //
 class FEModelHeader
 {
 public:
 unsigned int feEndian, feSchema, feCompressFlag, feLength;
 
 class ArrayInfo
 {
 public:
 unsigned numEntities, tableOffset, metaDataOffset;
 
 ArrayInfo();
 
 void print();
 void init( const std::vector< unsigned int >& uint_buf_in );
 };
 
 ArrayInfo geomArray, nodeArray, elementArray, groupArray, blockArray, nodesetArray, sidesetArray;
 
 void init( const unsigned int offset, Tqdcfr* instance );
 
 void print();
 };
 
 class MetaDataContainer
 {
 public:
 unsigned int mdSchema, compressFlag;
 
 class MetaDataEntry
 {
 public:
 unsigned int mdOwner, mdDataType, mdIntValue;
 std::string mdName, mdStringValue;
 std::vector< unsigned int > mdIntArrayValue;
 double mdDblValue;
 std::vector< double > mdDblArrayValue;
 
 MetaDataEntry();
 
 void print();
 };
 
 void print();
 
 int get_md_entry( const unsigned int owner, const std::string& name );
 
 std::vector< MetaDataEntry > metadataEntries;
 MetaDataContainer();
 };
 
 class GeomHeader
 {
 public:
 unsigned int geomID, nodeCt, nodeOffset, elemCt, elemOffset, elemTypeCt, elemLength;
 
 int maxDim;
 
 EntityHandle setHandle;
 
 void print();
 
 static ErrorCode read_info_header( const unsigned int model_offset,
 const FEModelHeader::ArrayInfo& info,
 Tqdcfr* instance,
 GeomHeader*& entity_headers );
 
 GeomHeader();
 };
 
 class GroupHeader
 {
 public:
 unsigned int grpID, grpType, memCt, memOffset, memTypeCt, grpLength;
 
 EntityHandle setHandle;
 
 void print();
 
 static ErrorCode read_info_header( const unsigned int model_offset,
 const FEModelHeader::ArrayInfo& info,
 Tqdcfr* instance,
 GroupHeader*& entity_headers );
 
 GroupHeader();
 };
 
 class BlockHeader
 {
 public:
 unsigned int blockID, blockElemType, memCt, memOffset, memTypeCt, attribOrder, blockCol, blockMixElemType,
 blockPyrType, blockMat, blockLength, blockDim;
 
 EntityHandle setHandle;
 
 EntityType blockEntityType;
 
 int hasMidNodes[4];
 
 void print();
 
 static ErrorCode read_info_header( const double data_version,
 const unsigned int model_offset,
 const FEModelHeader::ArrayInfo& info,
 Tqdcfr* instance,
 BlockHeader*& block_headers );
 
 BlockHeader();
 };
 
 class NodesetHeader
 {
 public:
 unsigned int nsID, memCt, memOffset, memTypeCt, pointSym, nsCol, nsLength;
 
 EntityHandle setHandle;
 
 void print();
 
 static ErrorCode read_info_header( const unsigned int model_offset,
 const FEModelHeader::ArrayInfo& info,
 Tqdcfr* instance,
 NodesetHeader*& entity_headers );
 
 NodesetHeader();
 };
 
 class SidesetHeader
 {
 public:
 unsigned int ssID, memCt, memOffset, memTypeCt, numDF, ssCol, useShell, ssLength;
 
 EntityHandle setHandle;
 
 void print();
 
 static ErrorCode read_info_header( const unsigned int model_offset,
 const FEModelHeader::ArrayInfo& info,
 Tqdcfr* instance,
 SidesetHeader*& entity_headers );
 
 SidesetHeader();
 };
 
 // class to hold model entry data for various kinds of models
 // (acis, free mesh, etc.)
 class ModelEntry
 {
 public:
 ModelEntry();
 
 ~ModelEntry();
 
 unsigned int modelHandle, modelOffset, modelLength, modelType, modelOwner, modelPad;
 
 FEModelHeader feModelHeader;
 GeomHeader* feGeomH;
 GroupHeader* feGroupH;
 BlockHeader* feBlockH;
 NodesetHeader* feNodeSetH;
 SidesetHeader* feSideSetH;
 
 MetaDataContainer geomMD, nodeMD, elementMD, groupMD, blockMD, nodesetMD, sidesetMD;
 
 void print();
 
 void print_geom_headers( const char* prefix, GeomHeader* header, unsigned int num_headers );
 
 void print_group_headers( const char* prefix, GroupHeader* header, const unsigned int num_headers );
 
 void print_block_headers( const char* prefix, BlockHeader* header, const unsigned int num_headers );
 
 void print_nodeset_headers( const char* prefix, NodesetHeader* header, const unsigned int num_headers );
 
 void print_sideset_headers( const char* prefix, SidesetHeader* header, const unsigned int num_headers );
 
 ErrorCode read_header_info( Tqdcfr* instance, const double data_version );
 ErrorCode read_metadata_info( Tqdcfr* tqd );
 };
 
 enum
 {
 aBODY,
 LUMP,
 SHELL,
 FACE,
 LOOP,
 COEDGE,
 aEDGE,
 aVERTEX,
 ATTRIB,
 UNKNOWN
 };
 
 struct AcisRecord
 {
 unsigned int rec_type;
 std::string att_string;
 bool processed;
 int first_attrib;
 int att_prev, att_next, att_ent_num;
 EntityHandle entity;
 };
 
 ~Tqdcfr();
 
 ReadUtilIface* readUtilIface;
 Interface* mdbImpl;
 FILE* cubFile;
 FileTOC fileTOC;
 std::vector< ModelEntry > modelEntries;
 MetaDataContainer modelMetaData;
 long currVHandleOffset;
 Range beforeEnts;
 long currElementIdOffset[MBMAXTYPE];
 Tag globalIdTag, cubIdTag, geomTag, uniqueIdTag, blockTag, nsTag, ssTag, attribVectorTag, entityNameTag,
 categoryTag, hasMidNodesTag;
 std::map< int, EntityHandle > uidSetMap;
 std::map< int, EntityHandle > gidSetMap[6];
 bool swapForEndianness;
 
 std::vector< unsigned int > uint_buf;
 int* int_buf;
 std::vector< double > dbl_buf;
 std::vector< char > char_buf;
 
 static ReaderIface* factory( Interface* );
 
 // read cub file
 ErrorCode load_file( const char* file_name,
 const EntityHandle* file_set,
 const FileOptions& opts,
 const SubsetList* subset_list = 0,
 const Tag* file_id_tag = 0 );
 
 ErrorCode read_tag_values( const char* file_name,
 const char* tag_name,
 const FileOptions& opts,
 std::vector< int >& tag_values_out,
 const SubsetList* subset_list = 0 );
 
 ErrorCode read_nodeset( const unsigned int nsindex, ModelEntry* model, NodesetHeader* nodeseth );
 ErrorCode read_sideset( const unsigned int ssindex,
 const double data_version,
 ModelEntry* model,
 SidesetHeader* sideseth );
 ErrorCode read_block( const unsigned int blindex,
 const double data_version,
 ModelEntry* model,
 BlockHeader* blockh );
 ErrorCode read_group( const unsigned int gr_index, ModelEntry* model, GroupHeader* grouph );
 ErrorCode read_nodes( const unsigned int gindex, ModelEntry* model, GeomHeader* entity );
 ErrorCode read_elements( ModelEntry* model, GeomHeader* entity );
 ErrorCode read_file_header();
 ErrorCode read_model_entries();
 int find_model( const unsigned int model_type );
 ErrorCode read_meta_data( const unsigned int metadata_offset, MetaDataContainer& mc );
 ErrorCode read_md_string( std::string& name );
 
 enum
 {
 mesh,
 acist,
 acisb,
 facet,
 exodusmesh
 };
 EntityType type_from_cub_type( const unsigned int cub_type, const unsigned int nodes_per_elem );
 void check_contiguous( const unsigned int num_ents, int& contig, unsigned int& min_id, unsigned int& max_id );
 
 Tqdcfr( Interface* impl );
 
 ErrorCode create_set( EntityHandle& h, unsigned int flags = MESHSET_SET );
 
 private:
 EntityHandle mFileSet; // set containing read entities.
 
 bool printedSeqWarning; // only print acis sequence #'s warning once
 
 bool printedElemWarning; // only print element #'s warning once
 
 ErrorCode convert_nodesets_sidesets();
 
 ErrorCode read_acis_records( const char* sat_file_name = 0 );
 
 ErrorCode parse_acis_attribs( const unsigned int entity_rec_num, std::vector< AcisRecord >& records );
 ErrorCode interpret_acis_records( std::vector< AcisRecord >& records );
 
 ErrorCode reset_record( AcisRecord& this_record );
 
 ErrorCode process_record( AcisRecord& this_record );
 
 static const char geom_categories[][CATEGORY_TAG_SIZE];
 
 FILE* acisDumpFile;
 
 // map between cub ids and MOAB handles
 std::vector< EntityHandle >* cubMOABVertexMap;
 
 // enum used to identify element/entity type in groups
 enum
 {
 GROUP = 0,
 BODY,
 VOLUME,
 SURFACE,
 CURVE,
 VERTEX,
 HEX,
 TET,
 PYRAMID,
 QUAD,
 TRI,
 EDGE,
 NODE
 };
 static const EntityType group_type_to_mb_type[];
 
 enum
 {
 SPHERE_EXO = 0,
 BAR,
 BAR2,
 BAR3,
 BEAM,
 BEAM2,
 BEAM3,
 TRUSS,
 TRUSS2,
 TRUSS3,
 SPRING,
 TRIthree,
 TRI3,
 TRI6,
 TRI7,
 TRISHELL,
 TRISHELL3,
 TRISHELL6,
 TRISHELL7,
 SHEL,
 SHELL4,
 SHELL8,
 SHELL9,
 QUADfour,
 QUAD4,
 QUAD5,
 QUAD8,
 QUAD9,
 TETRAfour,
 TETRA4,
 TETRA8,
 TETRA10,
 TETRA14,
 PYRAMIDfive,
 PYRAMID5,
 PYRAMID8,
 PYRAMID13,
 PYRAMID18,
 HEXeight,
 HEX8,
 HEX9,
 HEX20,
 HEX27,
 HEXSHELL,
 INVALID_ELEMENT_TYPE
 };
 static const EntityType block_type_to_mb_type[];
 static const int cub_elem_num_verts[];
 static const int cub_elem_num_verts_len;
 
 //! mapping from mesh packet type to moab type
 static const EntityType mp_type_to_mb_type[];
 
 //! get entities with individually-specified types; if is_group is false,
 //! increment each mem_type by 2 since they're CSOEntityType's and not group types
 ErrorCode get_entities( const unsigned int* mem_types,
 int* id_buf,
 const unsigned int id_buf_size,
 const bool is_group,
 std::vector< EntityHandle >& entities );
 
 //! get entities specified by type and ids, append to entities
 ErrorCode get_entities( const unsigned int this_type,
 int* id_buf,
 const unsigned int id_buf_size,
 std::vector< EntityHandle >& entities,
 std::vector< EntityHandle >& excl_entities );
 
 //! get ref entity sets with specified type and ids
 ErrorCode get_ref_entities( const unsigned int this_type,
 int* id_buf,
 const unsigned id_buf_size,
 std::vector< EntityHandle >& entities );
 
 //! get mesh entities with specified type and ids
 ErrorCode get_mesh_entities( const unsigned int this_type,
 int* id_buf,
 const unsigned id_buf_size,
 std::vector< EntityHandle >& entities,
 std::vector< EntityHandle >& excl_entities );
 
 //! process entities in a sideset according to sense flags stored in uint_buf
 //! or char_buf (depending on sense_size)
 ErrorCode process_sideset_10( const int this_type,
 const int num_ents,
 const int sense_size,
 std::vector< EntityHandle >& ss_entities,
 Tqdcfr::SidesetHeader* sideseth );
 
 ErrorCode process_sideset_11( std::vector< EntityHandle >& ss_entities,
 int num_wrts,
 Tqdcfr::SidesetHeader* sideseth );
 
 // put entities into the specfied set, and excluded entities into a
 // std::vector pointed to by the "Exclude_Entities" tag on that set
 ErrorCode put_into_set( EntityHandle set_handle,
 std::vector< EntityHandle >& entities,
 std::vector< EntityHandle >& excl_entities );
 
 // look in metadatacontainer[set_index] for name data; if found, set name (and extra names,
 // if multiple found) on set handle
 ErrorCode get_names( MetaDataContainer& md, unsigned int set_index, EntityHandle seth );
};
 
} // namespace moab
 
#endif