libMesh::AbaqusIO Class Reference

The AbaqusIO class is a preliminary implementation for reading Abaqus mesh files in ASCII format. More...

#include <abaqus_io.h>

Inheritance diagram for libMesh::AbaqusIO:

Public Member Functions
	AbaqusIO (MeshBase &mesh)
	Constructor.
virtual	~AbaqusIO ()
	Destructor.
virtual void	read (const std::string &name) override
	This method implements reading a mesh from a specified file.
bool	is_parallel_format () const
	Returns true iff this mesh file format and input class are parallelized, so that all processors can read their share of the data at once.

Public Attributes
bool	build_sidesets_from_nodesets
	Default false.

Protected Types
typedef std::map< std::string, std::vector< dof_id_type > >	container_t
	The type of data structure used to store Node and Elemset IDs.
typedef std::map< std::string, std::vector< std::pair< dof_id_type, unsigned > > >	sideset_container_t
	Type of the data structure for storing the (elem ID, side) pairs defining sidesets.

Protected Member Functions
void	read_nodes (std::string nset_name)
	This function parses a block of nodes in the Abaqus file once such a block has been found.
void	read_elements (std::string upper, std::string elset_name)
	This function parses a block of elements in the Abaqus file.
std::string	parse_label (std::string line, std::string label_name) const
	This function parses a label of the form foo=bar from a comma-delimited line of the form ..., foo=bar, ... The input to the function in this case would be foo, the output would be bar.
bool	detect_generated_set (std::string upper) const
void	read_ids (std::string set_name, container_t &container)
	This function reads all the IDs for the current node or element set of the given name, storing them in the passed map using the name as key.
void	generate_ids (std::string set_name, container_t &container)
	This function handles "generated" nset and elset sections.
void	assign_subdomain_ids ()
	This function is called after all the elements have been read and assigns element subdomain IDs.
void	read_sideset (const std::string &sideset_name, const std::string &sideset_type, sideset_container_t &container)
	This function reads a sideset from the input file.
void	assign_boundary_node_ids ()
	This function assigns boundary IDs to node sets based on the alphabetical order in which the sets are labeled in the Abaqus file.
void	assign_sideset_ids ()
	Called at the end of the read() function, assigns any sideset IDs found when reading the file to the BoundaryInfo object.
void	process_and_discard_comments ()
	Any of the various sections can start with some number of lines of comments, which start with "**".
unsigned char	max_elem_dimension_seen ()
bool	string_to_num (const std::string &input, dof_id_type &output) const
	Attempts to convert the input string to a numerical value using strtol.
void	strip_ws (std::string &line) const
	Removes all whitespace characters from "line".
virtual void	extended_parsing (const std::string &)
	Override this callback to implement support for more sections in derived classes.
MeshBase &	mesh ()
void	set_n_partitions (unsigned int n_parts)
	Sets the number of partitions in the mesh.
void	skip_comment_lines (std::istream &in, const char comment_start)
	Reads input from in, skipping all the lines that start with the character comment_start.

Protected Attributes
container_t	_nodeset_ids
	Abaqus writes nodesets and elemsets with labels.
container_t	_elemset_ids
sideset_container_t	_sideset_ids
std::unique_ptr< std::istream >	_in
	Stream object used to interact with the file.
std::set< ElemType >	_elem_types
	A set of the different geometric element types detected when reading the mesh.
bool	_already_seen_part
	This flag gets set to true after the first "*PART" section we see.
std::vector< bool >	elems_of_dimension
	A vector of bools describing what dimension elements have been encountered when reading a mesh.

Private Attributes
MeshBase *	_obj
	A pointer to a non-const object object.
const bool	_is_parallel_format
	Flag specifying whether this format is parallel-capable.

Detailed Description

The AbaqusIO class is a preliminary implementation for reading Abaqus mesh files in ASCII format.

Author

John W. Peterson

Date

2011

Definition at line 41 of file abaqus_io.h.

Member Typedef Documentation

container_t

typedef std::map<std::string, std::vector<dof_id_type> > libMesh::AbaqusIO::container_t

protected

The type of data structure used to store Node and Elemset IDs.

Definition at line 73 of file abaqus_io.h.

sideset_container_t

typedef std::map<std::string, std::vector<std::pair<dof_id_type, unsigned> > > libMesh::AbaqusIO::sideset_container_t

protected

Type of the data structure for storing the (elem ID, side) pairs defining sidesets.

These come from the *Surface sections of the input file.

Definition at line 80 of file abaqus_io.h.

Constructor & Destructor Documentation

AbaqusIO()

libMesh::AbaqusIO::AbaqusIO ( MeshBase &  mesh )

explicit

Constructor.

Takes a writable reference to a mesh object.

Definition at line 214 of file abaqus_io.C.

                                      :
  MeshInput<MeshBase> (mesh_in),
  build_sidesets_from_nodesets(false),
  _already_seen_part(false)
{
}

~AbaqusIO()

libMesh::AbaqusIO::~AbaqusIO ( )

virtualdefault

Destructor.

Member Function Documentation

assign_boundary_node_ids()

void libMesh::AbaqusIO::assign_boundary_node_ids ( )

protected

This function assigns boundary IDs to node sets based on the alphabetical order in which the sets are labeled in the Abaqus file.

We choose the alphabetical ordering simply because Abaqus does not provide a numerical one within the file.

Definition at line 1050 of file abaqus_io.C.

{
  // Get a reference to the mesh we are reading
  MeshBase & the_mesh = MeshInput<MeshBase>::mesh();
 
  // Iterate over the container of nodesets
  container_t::iterator it = _nodeset_ids.begin(), end = _nodeset_ids.end();
  for (boundary_id_type current_id=0; it != end; ++it, ++current_id)
    {
      // Associate current_id with the name we determined earlier
      the_mesh.get_boundary_info().nodeset_name(current_id) = it->first;
 
      // Get a reference to the current vector of nodeset ID values
      std::vector<dof_id_type> & nodeset_ids = it->second;
 
      for (const auto & id : nodeset_ids)
        {
          // Map the id'th element ID (Abaqus 1-based numbering) to LibMesh numbering
          libmesh_error_msg_if(id < 1,
                               "Invalid Abaqus node ID found");
          const dof_id_type libmesh_global_node_id = id-1;
 
          // Get node pointer from the mesh
          Node * node = the_mesh.node_ptr(libmesh_global_node_id);
 
          libmesh_error_msg_if(node == nullptr,
                               "Error! Mesh::node_ptr() returned nullptr!");
 
          // Add this node with the current_id (which is determined by the
          // alphabetical ordering of the map) to the BoundaryInfo object
          the_mesh.get_boundary_info().add_node(node, current_id);
        }
    }
}

References _nodeset_ids, libMesh::BoundaryInfo::add_node(), libMesh::MeshBase::get_boundary_info(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshBase::node_ptr(), and libMesh::BoundaryInfo::nodeset_name().

Referenced by read().

assign_sideset_ids()

void libMesh::AbaqusIO::assign_sideset_ids ( )

protected

Called at the end of the read() function, assigns any sideset IDs found when reading the file to the BoundaryInfo object.

Definition at line 1088 of file abaqus_io.C.

{
  // Get a reference to the mesh we are reading
  MeshBase & the_mesh = MeshInput<MeshBase>::mesh();
 
  // initialize the eletypes map (eletypes is a file-global variable)
  init_eletypes();
 
  // Iterate over the container of sidesets
  {
    sideset_container_t::iterator it = _sideset_ids.begin(), end = _sideset_ids.end();
    for (boundary_id_type current_id=0; it != end; ++it, ++current_id)
      {
        // Associate current_id with the name we determined earlier
        the_mesh.get_boundary_info().sideset_name(current_id) = it->first;
 
        // Get a reference to the current vector of nodeset ID values
        std::vector<std::pair<dof_id_type,unsigned>> & sideset_ids = it->second;
 
        for (const auto & [abaqus_elem_id, abaqus_side_number] : sideset_ids)
          {
            // Map the id'th element ID (Abaqus 1-based numbering) to LibMesh numbering
            libmesh_error_msg_if(abaqus_elem_id < 1,
                                 "Invalid Abaqus element ID found");
            const dof_id_type libmesh_elem_id = abaqus_elem_id-1;
 
            // Get a reference to that element
            Elem & elem = the_mesh.elem_ref(libmesh_elem_id);
 
            // Grab a reference to the element definition for this element type
            const ElementDefinition & eledef = eletypes[elem.type()];
 
            // If the element definition was not found, the call above would have
            // created one with an uninitialized struct.  Check for that here...
            libmesh_error_msg_if(eledef.abaqus_zero_based_side_id_to_libmesh_side_id.size() == 0,
                                 "No Abaqus->LibMesh mapping information for ElemType "
                                 << Utility::enum_to_string(elem.type()) << "!");
 
            // Add this node with the current_id (which is determined by the
            // alphabetical ordering of the map).  Side numbers in Abaqus are 1-based,
            // so we subtract 1 here before passing the abaqus side number to the
            // mapping array
            the_mesh.get_boundary_info().add_side
              (&elem,
               eledef.abaqus_zero_based_side_id_to_libmesh_side_id[abaqus_side_number-1],
               current_id);
          }
      }
  }
 
 
  // Some elsets (if they contain lower-dimensional elements) also
  // define sidesets.  So loop over them and build a searchable data
  // structure we can use to assign sidesets.
  {
    unsigned char max_dim = this->max_elem_dimension_seen();
 
    // multimap from lower-dimensional-element-hash-key to
    // pair(lower-dimensional-element, boundary_id).  The
    // lower-dimensional element is used to verify the results of the
    // hash table search.  The boundary_id will be used to set a
    // boundary ID on a higher-dimensional element.  We use a multimap
    // because the lower-dimensional elements can belong to more than
    // 1 sideset, and multiple lower-dimensional elements can hash to
    // the same value, but this is very rare.
    std::unordered_multimap<dof_id_type, std::pair<Elem *, boundary_id_type>> provide_bcs;
 
    // The elemset_id counter assigns a logical numbering to the
    // _elemset_ids keys.  We are going to use these ids as boundary
    // ids, so elemset_id is of type boundary_id_type.
    container_t::iterator it = _elemset_ids.begin(), end = _elemset_ids.end();
    for (boundary_id_type elemset_id=0; it != end; ++it, ++elemset_id)
      {
        // Grab a reference to the vector of IDs
        std::vector<dof_id_type> & id_vector = it->second;
 
        // Loop over this vector
        for (const auto & id : id_vector)
          {
            // Map the id'th element ID (Abaqus 1-based numbering) to LibMesh numbering
            libmesh_error_msg_if(id < 1,
                                 "Invalid Abaqus element ID found");
            const dof_id_type libmesh_elem_id = id-1;
 
            // Get a reference to that element
            Elem & elem = the_mesh.elem_ref(libmesh_elem_id);
 
            // If the element dimension is equal to the maximum
            // dimension seen, we can break out of this for loop --
            // this elset does not contain sideset information.
            if (elem.dim() == max_dim)
              break;
 
            // If the element dimension is zero, this elset contains
            // NodeElems which AFAIK are not used for sidesets, they
            // are only used to define point masses.
            if (elem.dim() == 0)
              break;
 
            // We can only handle elements that are *exactly*
            // one dimension lower than the max element
            // dimension.  Not sure if "edge" BCs in 3D
            // actually make sense/are required...
            libmesh_error_msg_if(elem.dim()+1 != max_dim,
                                 "ERROR: Expected boundary element of dimension " << max_dim-1 << " but got " << elem.dim());
 
            // Insert the current (key, pair(elem,id)) into the multimap.
            provide_bcs.emplace(elem.key(), std::make_pair(&elem, elemset_id));
 
            // Associate the name of this sideset with the ID we've
            // chosen.  It's not necessary to do this for every
            // element in the set, but it's convenient to do it here
            // since we have all the necessary information...
            the_mesh.get_boundary_info().sideset_name(elemset_id) = it->first;
          }
      }
 
    // Loop over elements and try to assign boundary information
    for (auto & elem : the_mesh.active_element_ptr_range())
      if (elem->dim() == max_dim)
        for (auto sn : elem->side_index_range())
          {
            // This is a max-dimension element that may require BCs.
            // For each of its sides, including internal sides, we'll
            // see if a lower-dimensional element provides boundary
            // information for it.  Note that we have not yet called
            // find_neighbors(), so we can't use elem->neighbor(sn) in
            // this algorithm...
            auto bounds = provide_bcs.equal_range (elem->key(sn));
 
            // Add boundary information for each side in the range.
            for (const auto & pr : as_range(bounds))
              {
                // We'll need to compare the lower dimensional element against the current side.
                std::unique_ptr<Elem> side (elem->build_side_ptr(sn));
 
                // Extract the relevant data. We don't need the key for anything.
                Elem * lower_dim_elem = pr.second.first;
                boundary_id_type bid = pr.second.second;
 
                // This was a hash, so it might not be perfect.  Let's verify...
                if (*lower_dim_elem == *side)
                  the_mesh.get_boundary_info().add_side(elem, sn, bid);
              }
          }
  }
}

References _elemset_ids, _sideset_ids, libMesh::BoundaryInfo::add_side(), libMesh::as_range(), libMesh::Elem::dim(), libMesh::MeshBase::elem_ref(), libMesh::Utility::enum_to_string(), libMesh::MeshBase::get_boundary_info(), libMesh::Elem::key(), max_elem_dimension_seen(), libMesh::MeshInput< MT >::mesh(), libMesh::BoundaryInfo::sideset_name(), and libMesh::Elem::type().

Referenced by read().

assign_subdomain_ids()

void libMesh::AbaqusIO::assign_subdomain_ids ( )

protected

This function is called after all the elements have been read and assigns element subdomain IDs.

The IDs are simply chosen in the order in which the elset labels are stored in the map (roughly alphabetically). To make this easy on people who are planning to use Exodus output, we'll assign different geometric elements to different (but related) subdomains, i.e. assuming there are E elemsets:

Elemset 0, Geometric Type 0: ID 0 Elemset 0, Geometric Type 1: ID 0+E ...

Elemset 0, Geometric Type N: ID 0+N*E

Elemset 1, Geometric Type 0: ID 1 Elemset 1, Geometric Type 1: ID 1+E ... Elemset 1, Geometric Type N: ID 1+N*E etc.

Definition at line 979 of file abaqus_io.C.

{
  // Get a reference to the mesh we are reading
  MeshBase & the_mesh = MeshInput<MeshBase>::mesh();
 
  // The number of elemsets we've found while reading
  std::size_t n_elemsets = _elemset_ids.size();
 
  // Fill in a temporary map with (ElemType, index) pairs based on the _elem_types set.  This
  // will allow us to easily look up this index in the loop below.
  std::map<ElemType, unsigned> elem_types_map;
  {
    unsigned ctr=0;
    for (const auto & type : _elem_types)
      elem_types_map[type] = ctr++;
  }
 
  // Loop over each Elemset and assign subdomain IDs to Mesh elements
  {
    // The maximum element dimension seen while reading the Mesh
    unsigned char max_dim = this->max_elem_dimension_seen();
 
    // The elemset_id counter assigns a logical numbering to the _elemset_ids keys
    container_t::iterator it = _elemset_ids.begin(), end = _elemset_ids.end();
    for (unsigned elemset_id=0; it != end; ++it, ++elemset_id)
      {
        // Grab a reference to the vector of IDs
        std::vector<dof_id_type> & id_vector = it->second;
 
        // Loop over this vector
        for (const auto & id : id_vector)
          {
            // Map the id'th element ID (Abaqus 1-based numbering) to LibMesh numbering
            libmesh_error_msg_if(id < 1,
                                 "Invalid Abaqus element ID found");
            const dof_id_type libmesh_elem_id = id-1;
 
            // Get reference to that element
            Elem & elem = the_mesh.elem_ref(libmesh_elem_id);
 
            // We won't assign subdomain ids to lower-dimensional
            // elements, as they are assumed to represent boundary
            // conditions.  Since lower-dimensional elements can
            // appear in multiple sidesets, it doesn't make sense to
            // assign them a single subdomain id... only the last one
            // assigned would actually "stick".
            if (elem.dim() < max_dim)
              break;
 
            // Compute the proper subdomain ID, based on the formula in the
            // documentation for this function.
            subdomain_id_type computed_id = cast_int<subdomain_id_type>
              (elemset_id + (elem_types_map[elem.type()] * n_elemsets));
 
            // Assign this ID to the element in question
            elem.subdomain_id() = computed_id;
 
            // We will also assign a unique name to the computed_id,
            // which is created by appending the geometric element
            // name to the elset name provided by the user in the
            // Abaqus file.
            std::string computed_name = it->first + "_" + Utility::enum_to_string(elem.type());
            the_mesh.set_subdomain_name(computed_id, computed_name);
          }
      }
  }
}

References _elem_types, _elemset_ids, libMesh::Elem::dim(), libMesh::MeshBase::elem_ref(), libMesh::Utility::enum_to_string(), max_elem_dimension_seen(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshBase::set_subdomain_name(), libMesh::Elem::subdomain_id(), and libMesh::Elem::type().

Referenced by read().

detect_generated_set()

bool libMesh::AbaqusIO::detect_generated_set ( std::string  upper ) const

protected

Returns

true if the input string is a generated elset or nset, false otherwise.

The input string is assumed to already be in all upper case. Generated nsets are assumed to have the following format: *Nset, nset=Set-1, generate

Definition at line 821 of file abaqus_io.C.

{
  // Avoid issues with weird line endings, spaces before commas, etc.
  strip_ws(upper);
 
  // Check each comma-separated value in "upper" to see if it is the generate flag.
  std::string cell;
  std::stringstream line_stream(upper);
  while (std::getline(line_stream, cell, ','))
    if (cell == "GENERATE")
      return true;
 
  return false;
}

References strip_ws().

Referenced by read().

extended_parsing()

virtual void libMesh::AbaqusIO::extended_parsing ( const std::string &  )

inlineprotectedvirtual

Override this callback to implement support for more sections in derived classes.

Definition at line 241 of file abaqus_io.h.

{}

Referenced by read().

generate_ids()

void libMesh::AbaqusIO::generate_ids ( std::string  set_name, container_t &  container  )

protected

This function handles "generated" nset and elset sections.

These are denoted by having the comma-separated "GENERATE" keyword in their definition, e.g. *Nset, nset=Set-1, generate

Definition at line 871 of file abaqus_io.C.

{
  // Grab a reference to a vector that will hold all the IDs
  std::vector<dof_id_type> & id_storage = container[set_name];
 
  // Read until the start of another section is detected, or EOF is
  // encountered.  "generate" sections seem to only have one line,
  // although I suppose it's possible they could have more.
  while (_in->peek() != '*' && _in->peek() != EOF)
    {
      // Read entire comma-separated line into a string
      std::string csv_line;
      std::getline(*_in, csv_line);
 
      // Remove all whitespaces from csv_line.
      strip_ws(csv_line);
 
      // Create a new stringstream object from the string, and stream
      // in the comma-separated values.
      char c;
      dof_id_type start, end, stride;
      std::stringstream line_stream(csv_line);
      line_stream >> start >> c >> end >> c >> stride;
 
      // Generate entries in the id_storage.  Note: each element can
      // only belong to a single Elset (since this corresponds to the
      // subdomain_id) so if an element appears in multiple Elsets,
      // the "last" one (alphabetically, based on set name) in the
      // _elemset_ids map will "win".
      for (dof_id_type current = start; current <= end; current += stride)
        id_storage.push_back(current);
    }
}

References _in, and strip_ws().

Referenced by read().

is_parallel_format()

bool libMesh::MeshInput< MeshBase >::is_parallel_format ( ) const

inlineinherited

Returns true iff this mesh file format and input class are parallelized, so that all processors can read their share of the data at once.

Definition at line 87 of file mesh_input.h.

{ return this->_is_parallel_format; }

max_elem_dimension_seen()

unsigned char libMesh::AbaqusIO::max_elem_dimension_seen ( )

protected

Returns

The maximum geometric element dimension encountered while reading the Mesh.

Only valid after the elements have been read in and the elems_of_dimension array has been populated.

Definition at line 1281 of file abaqus_io.C.

{
  unsigned char max_dim = 0;
 
  unsigned char elem_dimensions_size = cast_int<unsigned char>
    (elems_of_dimension.size());
  // The elems_of_dimension array is 1-based in the UNV reader
  for (unsigned char i=1; i<elem_dimensions_size; ++i)
    if (elems_of_dimension[i])
      max_dim = i;
 
  return max_dim;
}

References libMesh::MeshInput< MeshBase >::elems_of_dimension.

Referenced by assign_sideset_ids(), assign_subdomain_ids(), and read().

mesh()

MeshBase & libMesh::MeshInput< MeshBase >::mesh ( )

inlineprotectedinherited

Returns

The object as a writable reference.

Definition at line 94 of file mesh_input.h.

{
  libmesh_error_msg_if(_obj == nullptr, "ERROR: _obj should not be nullptr!");
  return *_obj;
}

parse_label()

std::string libMesh::AbaqusIO::parse_label ( std::string  line, std::string  label_name  ) const

protected

This function parses a label of the form foo=bar from a comma-delimited line of the form ..., foo=bar, ... The input to the function in this case would be foo, the output would be bar.

Definition at line 776 of file abaqus_io.C.

{
  // Handle files which have weird line endings from e.g. windows.
  // You can check what kind of line endings you have with 'cat -vet'.
  // For example, some files may have two kinds of line endings like:
  //
  // 4997,^I496,^I532,^I487,^I948^M$
  //
  // and we don't want to deal with this when extracting a label, so
  // just remove all the space characters, which should include all
  // kinds of remaining newlines.  (I don't think Abaqus allows
  // whitespace in label names.)
  strip_ws(line);
 
  // Do all string comparisons in upper-case
  std::string
    upper_line(line),
    upper_label_name(label_name);
  std::transform(upper_line.begin(), upper_line.end(), upper_line.begin(), ::toupper);
  std::transform(upper_label_name.begin(), upper_label_name.end(), upper_label_name.begin(), ::toupper);
 
  // Get index of start of "label="
  size_t label_index = upper_line.find(upper_label_name + "=");
 
  if (label_index != std::string::npos)
    {
      // Location of the first comma following "label="
      size_t comma_index = upper_line.find(",", label_index);
 
      // Construct iterators from which to build the sub-string.
      // Note: The +1 while initializing beg is to skip past the "=" which follows the label name
      std::string::iterator
        beg = line.begin() + label_name.size() + 1 + label_index,
        end = (comma_index == std::string::npos) ? line.end() : line.begin() + comma_index;
 
      return std::string(beg, end);
    }
 
  // The label index was not found, return the empty string
  return std::string("");
}

References strip_ws().

Referenced by read().

process_and_discard_comments()

void libMesh::AbaqusIO::process_and_discard_comments ( )

protected

Any of the various sections can start with some number of lines of comments, which start with "**".

This function discards any lines of comments that it finds from the stream, leaving trailing data intact.

Definition at line 1238 of file abaqus_io.C.

{
  std::string dummy;
  while (true)
    {
      // We assume we are at the beginning of a line that may be
      // comments or may be data.  We need to only discard the line if
      // it begins with **, but we must avoid calling std::getline()
      // since there's no way to put that back.
      if (_in->peek() == '*')
        {
          // The first character was a star, so actually read it from the stream.
          _in->get();
 
          // Peek at the next character...
          if (_in->peek() == '*')
            {
              // OK, second character was star also, by definition this
              // line must be a comment!  Read the rest of the line and discard!
              std::getline(*_in, dummy);
            }
          else
            {
              // The second character was _not_ a star, so put back the first star
              // we pulled out so that the line can be parsed correctly by somebody
              // else!
              _in->unget();
 
              // Finally, break out of the while loop, we are done parsing comments
              break;
            }
        }
      else
        {
          // First character was not *, so this line must be data! Break out of the
          // while loop!
          break;
        }
    }
}

References _in.

Referenced by read().

read()

void libMesh::AbaqusIO::read ( const std::string &  name )

overridevirtual

This method implements reading a mesh from a specified file.

Implements libMesh::MeshInput< MeshBase >.

Definition at line 227 of file abaqus_io.C.

{
  // Get a reference to the mesh we are reading
  MeshBase & the_mesh = MeshInput<MeshBase>::mesh();
 
  // Clear any existing mesh data
  the_mesh.clear();
 
  // Open stream for reading
  const bool gzipped_file = Utility::ends_with(fname, ".gz");
 
  if (gzipped_file)
    {
#ifdef LIBMESH_HAVE_GZSTREAM
      auto inf = std::make_unique<igzstream>();
      libmesh_assert(inf);
      inf->open(fname.c_str(), std::ios::in);
      _in = std::move(inf); // class takes ownership as base class pointer
#else
      libmesh_error_msg("ERROR: need gzstream to handle .gz files!!!");
#endif
    }
  else
    {
      auto inf = std::make_unique<std::ifstream>();
      libmesh_assert(inf);
 
      std::string new_name = Utility::unzip_file(fname);
      inf->open(new_name.c_str(), std::ios::in);
      libmesh_assert(inf->good());
      _in = std::move(inf); // class takes ownership as base class pointer
    }
 
  // Initialize the elems_of_dimension array.  We will use this in a
  // "1-based" manner so that elems_of_dimension[d]==true means
  // elements of dimension d have been seen.
  elems_of_dimension.resize(4, false);
 
  // Read file line-by-line... this is based on a set of different
  // test input files.  I have not looked at the full input file
  // specs for Abaqus.
  std::string s;
  while (true)
    {
      // Try to read something.  This may set EOF!
      std::getline(*_in, s);
 
      if (*_in)
        {
          // Process s...
          //
          // There are many sections in Abaqus files, we read some
          // but others are just ignored...  Some sections may occur
          // more than once.  For example for a hybrid grid, you
          // will have multiple *Element sections...
 
          // Some Abaqus files use all upper-case for section names,
          // so we will just convert s to uppercase
          std::string upper(s);
          std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
          // 0.) Look for the "*Part" section
          if (upper.find("*PART") == static_cast<std::string::size_type>(0))
            {
              libmesh_error_msg_if
                (_already_seen_part,
                 "We currently don't support reading Abaqus files with multiple PART sections");
 
              _already_seen_part = true;
            }
 
          // 1.) Look for the "*Nodes" section
          if (upper.find("*NODE") == static_cast<std::string::size_type>(0))
            {
              // Some sections that begin with *NODE are actually
              // unrelated sections which we want to skip.  I
              // have only seen this with a single space, but it would
              // probably be more robust to remove whitespace before
              // making this check.
              bool skip_this_section = false;
              std::vector<std::string> keywords_to_ignore = {"OUTPUT", "PRINT", "FILE", "RESPONSE"};
              for (auto & affix : keywords_to_ignore) {
                std::stringstream keyword;
                keyword << "*NODE " << affix;
                if (upper.find(keyword.str()) == static_cast<std::string::size_type>(0))
                  skip_this_section = true;
              }
              if (skip_this_section)
                continue;
 
              // Some *Node sections also specify an Nset name on the same line.
              // Look for one here.
              std::string nset_name = this->parse_label(s, "nset");
 
              // Process any lines of comments that may be present
              this->process_and_discard_comments();
 
              // Read a block of nodes
              this->read_nodes(nset_name);
            }
 
 
 
          // 2.) Look for the "*Element" section
          else if (upper.find("*ELEMENT,") == static_cast<std::string::size_type>(0))
            {
              // Some sections that begin with *ELEMENT are actually
              // "*ELEMENT OUTPUT" sections which we want to skip.  I
              // have only seen this with a single space, but it would
              // probably be more robust to remove whitespace before
              // making this check.
              bool skip_this_section = false;
              std::vector<std::string> keywords_to_ignore = {"OUTPUT", "MATRIX", "PROPERTIES", "RESPONSE"};
              for (auto & affix : keywords_to_ignore) {
                std::stringstream keyword;
                keyword << "*ELEMENT " << affix;
                if (upper.find(keyword.str()) == static_cast<std::string::size_type>(0))
                  skip_this_section = true;
              }
              if (skip_this_section)
                continue;
 
              // Some *Element sections also specify an Elset name on the same line.
              // Look for one here.
              std::string elset_name = this->parse_label(s, "elset");
 
              // Process any lines of comments that may be present
              this->process_and_discard_comments();
 
              // Read a block of elements
              this->read_elements(upper, elset_name);
            }
 
 
 
          // 3.) Look for a Nodeset section
          else if (upper.find("*NSET") == static_cast<std::string::size_type>(0))
            {
              std::string nset_name = this->parse_label(s, "nset");
 
              // I haven't seen an unnamed nset yet, but let's detect it
              // just in case...
              libmesh_error_msg_if(nset_name == "", "Unnamed nset encountered!");
 
              // Is this a "generated" nset, i.e. one which has three
              // entries corresponding to (first, last, stride)?
              bool is_generated = this->detect_generated_set(upper);
 
              // Process any lines of comments that may be present
              this->process_and_discard_comments();
 
              // Read the IDs, storing them in _nodeset_ids
              if (is_generated)
                this->generate_ids(nset_name, _nodeset_ids);
              else
                this->read_ids(nset_name, _nodeset_ids);
            } // *Nodeset
 
 
 
          // 4.) Look for an Elset section
          else if (upper.find("*ELSET") == static_cast<std::string::size_type>(0))
            {
              std::string elset_name = this->parse_label(s, "elset");
 
              // I haven't seen an unnamed elset yet, but let's detect it
              // just in case...
              libmesh_error_msg_if(elset_name == "", "Unnamed elset encountered!");
 
              // Is this a "generated" elset, i.e. one which has three
              // entries corresponding to (first, last, stride)?
              bool is_generated = this->detect_generated_set(upper);
 
              // Process any lines of comments that may be present
              this->process_and_discard_comments();
 
              // Read the IDs, storing them in _elemset_ids
              if (is_generated)
                this->generate_ids(elset_name, _elemset_ids);
              else
                this->read_ids(elset_name, _elemset_ids);
            } // *Elset
 
 
 
          // 5.) Look for a Surface section.  Need to be a little
          // careful, since there are also "surface interaction"
          // sections we don't want to read here.
          else if (upper.find("*SURFACE,") == static_cast<std::string::size_type>(0))
            {
              // Get the name from the Name=Foo label.  This will be the map key.
              std::string sideset_name = this->parse_label(s, "name");
 
              // Some (all?) surfaces also declare a type, which can
              // help us figure out how they should be parsed, so we
              // pass this to the read_sideset() function.
              std::string sideset_type = this->parse_label(s, "type");
 
              // Process any lines of comments that may be present
              this->process_and_discard_comments();
 
              // Read the sideset IDs
              this->read_sideset(sideset_name, sideset_type, _sideset_ids);
            }
 
          // Derived classes could override this to add support for additional sections
          extended_parsing(upper);
 
          continue;
        } // if (*_in)
 
      // If !file, check to see if EOF was set.  If so, break out
      // of while loop.
      if (_in->eof())
        break;
 
      // If !in and !in.eof(), stream is in a bad state!
      libmesh_error_msg("Stream is bad! Perhaps the file: " << fname << " does not exist?");
    } // while
 
  // Set the Mesh dimension based on the highest dimension element seen.
  the_mesh.set_mesh_dimension(this->max_elem_dimension_seen());
 
  // Set element IDs based on the element sets.
  this->assign_subdomain_ids();
 
  // Assign nodeset values to the BoundaryInfo object
  this->assign_boundary_node_ids();
 
  // Assign sideset values in the BoundaryInfo object
  this->assign_sideset_ids();
 
  // If the Abaqus file contains only nodesets, we can have libmesh
  // generate sidesets from them. This BoundaryInfo function currently
  // *overwrites* existing sidesets in surprising ways, so we don't
  // call it if there are already sidesets present in the original file.
  if (build_sidesets_from_nodesets && the_mesh.get_boundary_info().n_boundary_conds() == 0)
    the_mesh.get_boundary_info().build_side_list_from_node_list();
 
  // Delete lower-dimensional elements from the Mesh.  We assume these
  // were only used for setting BCs, and aren't part of the actual
  // Mesh.
  {
    unsigned char max_dim = this->max_elem_dimension_seen();
 
    for (auto & elem : the_mesh.element_ptr_range())
      if (elem->dim() < max_dim)
        the_mesh.delete_elem(elem);
  }
}

References _already_seen_part, _elemset_ids, _in, _nodeset_ids, _sideset_ids, assign_boundary_node_ids(), assign_sideset_ids(), assign_subdomain_ids(), libMesh::BoundaryInfo::build_side_list_from_node_list(), build_sidesets_from_nodesets, libMesh::MeshBase::clear(), libMesh::MeshBase::delete_elem(), detect_generated_set(), libMesh::MeshInput< MeshBase >::elems_of_dimension, libMesh::Utility::ends_with(), extended_parsing(), generate_ids(), libMesh::MeshBase::get_boundary_info(), libMesh::libmesh_assert(), max_elem_dimension_seen(), libMesh::MeshInput< MT >::mesh(), libMesh::BoundaryInfo::n_boundary_conds(), parse_label(), process_and_discard_comments(), read_elements(), read_ids(), read_nodes(), read_sideset(), libMesh::MeshBase::set_mesh_dimension(), and libMesh::Utility::unzip_file().

Referenced by libMesh::NameBasedIO::read(), and MeshInputTest::testAbaqusRead().

read_elements()

void libMesh::AbaqusIO::read_elements ( std::string  upper, std::string  elset_name  )

protected

This function parses a block of elements in the Abaqus file.

You must pass it an upper-cased version of the string declaring this section, which is typically something like: *ELEMENT, TYPE=CPS3 so that it can determine the type of elements to read.

Definition at line 561 of file abaqus_io.C.

{
  // Get a reference to the mesh we are reading
  MeshBase & the_mesh = MeshInput<MeshBase>::mesh();
 
  // initialize the eletypes map (eletypes is a file-global variable)
  init_eletypes();
 
  ElemType elem_type = INVALID_ELEM;
  unsigned n_nodes_per_elem = 0;
 
  // Within s, we should have "type=XXXX"
  if (upper.find("T3D2") != std::string::npos ||
      upper.find("B31") != std::string::npos)
    {
      elem_type = EDGE2;
      n_nodes_per_elem = 2;
      elems_of_dimension[1] = true;
    }
  else if (upper.find("B32") != std::string::npos)
    {
      elem_type = EDGE3;
      n_nodes_per_elem = 3;
      elems_of_dimension[1] = true;
    }
  else if (upper.find("S3") != std::string::npos ||
           upper.find("CPE3") != std::string::npos ||
           upper.find("2D3") != std::string::npos)
    {
      elem_type = TRI3;
      n_nodes_per_elem = 3;
      elems_of_dimension[2] = true;
    }
  else if (upper.find("CPE4") != std::string::npos ||
           upper.find("S4") != std::string::npos ||
           upper.find("CPEG4") != std::string::npos ||
           upper.find("2D4") != std::string::npos)
    {
      elem_type = QUAD4;
      n_nodes_per_elem = 4;
      elems_of_dimension[2] = true;
    }
  else if (upper.find("CPE6") != std::string::npos ||
           upper.find("S6") != std::string::npos ||
           upper.find("CPEG6") != std::string::npos ||
           upper.find("2D6") != std::string::npos)
    {
      elem_type = TRI6;
      n_nodes_per_elem = 6;
      elems_of_dimension[2] = true;
    }
  else if (upper.find("CPE8") != std::string::npos ||
           upper.find("S8") != std::string::npos ||
           upper.find("CPEG8") != std::string::npos ||
           upper.find("2D8") != std::string::npos)
    {
      elem_type = QUAD8;
      n_nodes_per_elem = 8;
      elems_of_dimension[2] = true;
    }
  else if (upper.find("3D8") != std::string::npos)
    {
      elem_type = HEX8;
      n_nodes_per_elem = 8;
      elems_of_dimension[3] = true;
    }
  else if (upper.find("3D4") != std::string::npos)
    {
      elem_type = TET4;
      n_nodes_per_elem = 4;
      elems_of_dimension[3] = true;
    }
  else if (upper.find("3D20") != std::string::npos)
    {
      elem_type = HEX20;
      n_nodes_per_elem = 20;
      elems_of_dimension[3] = true;
    }
  else if (upper.find("3D27") != std::string::npos)
    {
      elem_type = HEX27;
      n_nodes_per_elem = 27;
      elems_of_dimension[3] = true;
    }
  else if (upper.find("3D6") != std::string::npos)
    {
      elem_type = PRISM6;
      n_nodes_per_elem = 6;
      elems_of_dimension[3] = true;
    }
  else if (upper.find("3D15") != std::string::npos)
    {
      elem_type = PRISM15;
      n_nodes_per_elem = 15;
      elems_of_dimension[3] = true;
    }
  else if (upper.find("3D10") != std::string::npos)
    {
      elem_type = TET10;
      n_nodes_per_elem = 10;
      elems_of_dimension[3] = true;
    }
  else if (upper.find("MASS") != std::string::npos)
    {
      // "MASS" elements are used to indicate point masses in Abaqus
      // models. These are mapped to NODEELEMs in libmesh.
      elem_type = NODEELEM;
      n_nodes_per_elem = 1;
      elems_of_dimension[0] = true;
    }
  else
    libmesh_error_msg("Unrecognized element type: " << upper);
 
  // Insert the elem type we detected into the set of all elem types for this mesh
  _elem_types.insert(elem_type);
 
  // Grab a reference to the element definition for this element type
  const ElementDefinition & eledef = eletypes[elem_type];
 
  // If the element definition was not found, the call above would have
  // created one with an uninitialized struct.  Check for that here...
  libmesh_error_msg_if
    (eledef.abaqus_zero_based_node_id_to_libmesh_node_id.size() == 0,
     "No Abaqus->LibMesh mapping information for ElemType "
     << Utility::enum_to_string(elem_type) << "!");
 
  // We will read elements until the next line begins with *, since that will be the
  // next section.
  while (_in->peek() != '*' && _in->peek() != EOF)
    {
      // Read the element ID, it is the first number on each line.  It is
      // followed by a comma, so read that also.  We will need this ID later
      // when we try to assign subdomain IDs
      dof_id_type abaqus_elem_id = 0;
      char c;
      *_in >> abaqus_elem_id >> c;
 
      // Add an element of the appropriate type to the Mesh, with the
      // abaqus element ID.
      std::unique_ptr<Elem> new_elem = Elem::build(elem_type);
      new_elem->set_id() = abaqus_elem_id-1;
 
      Elem * elem = the_mesh.add_elem(std::move(new_elem));
 
      // The count of the total number of IDs read for the current element.
      unsigned id_count=0;
 
      // Continue reading line-by-line until we have read enough nodes for this element
      while (id_count < n_nodes_per_elem)
        {
          // Read entire line (up to carriage return) of comma-separated values
          std::string csv_line;
          std::getline(*_in, csv_line);
 
          // Create a stream object out of the current line
          std::stringstream line_stream(csv_line);
 
          // Process the comma-separated values
          std::string cell;
          while (std::getline(line_stream, cell, ','))
            {
              dof_id_type abaqus_global_node_id;
              bool success = string_to_num(cell, abaqus_global_node_id);
 
              if (success)
                {
                  // Map the id'th element ID (Abaqus 1-based numbering) to LibMesh numbering
                  libmesh_error_msg_if(abaqus_global_node_id < 1,
                                       "Invalid Abaqus node ID found");
                  const dof_id_type libmesh_global_node_id = abaqus_global_node_id-1;
 
                  // Grab the node pointer from the mesh for this ID
                  Node * node = the_mesh.node_ptr(libmesh_global_node_id);
 
                  // If node_ptr() returns nullptr, it may mean we have not yet read the
                  // *Nodes section, though I assumed that always came before the *Elements section...
                  libmesh_error_msg_if
                    (node == nullptr,
                     "Error!  Mesh::node_ptr() returned nullptr.  Either no node exists with ID "
                     << libmesh_global_node_id
                     << " or perhaps this input file has *Elements defined before *Nodes?");
 
                  // Note: id_count is the zero-based abaqus (elem local) node index.  We therefore map
                  // it to a libmesh elem local node index using the element definition map
                  unsigned libmesh_elem_local_node_id =
                    eledef.abaqus_zero_based_node_id_to_libmesh_node_id[id_count];
 
                  // Set this node pointer within the element.
                  elem->set_node(libmesh_elem_local_node_id, node);
 
                  // Increment the count of IDs read for this element
                  id_count++;
                } // end if (success)
            } // end while getline(',')
        } // end while (id_count)
 
      // Ensure that we read *exactly* as many nodes as we were expecting to, no more.
      libmesh_error_msg_if
        (id_count != n_nodes_per_elem,
         "Error: Needed to read "
         << n_nodes_per_elem
         << " nodes, but read "
         << id_count
         << " instead!");
 
      // If we are recording Elset IDs, add this element to the correct set for later processing.
      // Make sure to add it with the Abaqus ID, not the libmesh one!
      if (elset_name != "")
        _elemset_ids[elset_name].push_back(abaqus_elem_id);
    } // end while (peek)
}

References _elem_types, _elemset_ids, _in, libMesh::MeshBase::add_elem(), libMesh::Elem::build(), libMesh::EDGE2, libMesh::EDGE3, libMesh::MeshInput< MeshBase >::elems_of_dimension, libMesh::Utility::enum_to_string(), libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INVALID_ELEM, libMesh::MeshInput< MT >::mesh(), libMesh::MeshBase::node_ptr(), libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM6, libMesh::QUAD4, libMesh::QUAD8, libMesh::Elem::set_node(), string_to_num(), libMesh::TET10, libMesh::TET4, libMesh::TRI3, and libMesh::TRI6.

Referenced by read().

read_ids()

void libMesh::AbaqusIO::read_ids ( std::string  set_name, container_t &  container  )

protected

This function reads all the IDs for the current node or element set of the given name, storing them in the passed map using the name as key.

Definition at line 838 of file abaqus_io.C.

{
  // Grab a reference to a vector that will hold all the IDs
  std::vector<dof_id_type> & id_storage = container[set_name];
 
  // Read until the start of another section is detected, or EOF is encountered
  while (_in->peek() != '*' && _in->peek() != EOF)
    {
      // Read entire comma-separated line into a string
      std::string csv_line;
      std::getline(*_in, csv_line);
 
      // On that line, use std::getline again to parse each
      // comma-separated entry.
      std::string cell;
      std::stringstream line_stream(csv_line);
      while (std::getline(line_stream, cell, ','))
        {
          dof_id_type id;
          bool success = string_to_num(cell, id);
 
          // Note that lists of comma-separated values in abaqus also
          // *end* with a comma, so the last call to getline on a given
          // line will get an empty string, which we must detect.
          if (success)
            id_storage.push_back(id);
        }
    }
}

References _in, and string_to_num().

Referenced by read().

read_nodes()

void libMesh::AbaqusIO::read_nodes ( std::string  nset_name )

protected

This function parses a block of nodes in the Abaqus file once such a block has been found.

If the *NODE section specifies an NSET name, also pass that to this function.

Definition at line 484 of file abaqus_io.C.

{
  // Get a reference to the mesh we are reading
  MeshBase & the_mesh = MeshInput<MeshBase>::mesh();
 
  // In the input files I have, Abaqus neither tells what
  // the mesh dimension is nor how many nodes it has...
  //
  // The node line format is:
  // id, x, y, z
  // and you do have to parse out the commas.
  // The z-coordinate will only be present for 3D meshes
 
  // Temporary variables for parsing lines of text
  char c;
  std::string line;
 
  // We need to duplicate some of the read_ids code if this *NODE
  // section also defines an NSET.  We'll set up the id_storage
  // pointer and push back IDs into this vector in the loop below...
  std::vector<dof_id_type> * id_storage = nullptr;
  if (nset_name != "")
    id_storage = &(_nodeset_ids[nset_name]);
 
  // We will read nodes until the next line begins with *, since that will be the
  // next section.
  // TODO: Is Abaqus guaranteed to start the line with '*' or can there be leading white space?
  while (_in->peek() != '*' && _in->peek() != EOF)
    {
      // Read an entire line which corresponds to a single point's id
      // and (x,y,z) values.
      std::getline(*_in, line);
 
      // Remove all whitespace characters from the line.  This way we
      // can do the remaining parsing without worrying about tabs,
      // different numbers of spaces, etc.
      strip_ws(line);
 
      // Make a stream out of the modified line so we can stream values
      // from it in the usual way.
      std::stringstream ss(line);
 
      // Values to be read in from file
      dof_id_type abaqus_node_id=0;
      Real x=0, y=0, z=0;
 
      // Note: we assume *at least* 2D points here, should we worry about
      // trying to read 1D Abaqus meshes?
      ss >> abaqus_node_id >> c >> x >> c >> y;
 
      // Peek at the next character.  If it is a comma, then there is another
      // value to read!
      if (ss.peek() == ',')
        ss >> c >> z;
 
      // If this *NODE section defines an NSET, also store the abaqus ID in id_storage
      if (id_storage)
        id_storage->push_back(abaqus_node_id);
 
      // Convert from Abaqus 1-based to libMesh 0-based numbering
      libmesh_error_msg_if(abaqus_node_id < 1,
                           "Invalid Abaqus node ID found");
      const dof_id_type libmesh_node_id = abaqus_node_id-1;
 
      libmesh_error_msg_if(the_mesh.query_node_ptr(libmesh_node_id),
                           "Duplicate Abaqus node ID found");
 
      // Add the point to the mesh using libmesh's numbering,
      // and post-increment the libmesh node counter.
      the_mesh.add_point(Point(x,y,z), libmesh_node_id);
    } // while
}

References _in, _nodeset_ids, libMesh::MeshBase::add_point(), libMesh::MeshInput< MT >::mesh(), libMesh::MeshBase::query_node_ptr(), libMesh::Real, and strip_ws().

Referenced by read().

read_sideset()

void libMesh::AbaqusIO::read_sideset ( const std::string &  sideset_name, const std::string &  sideset_type, sideset_container_t &  container  )

protected

This function reads a sideset from the input file.

This is defined by a "*Surface" section in the file, and then a list of element ID and side IDs for the set.

Definition at line 908 of file abaqus_io.C.

{
  // Grab a reference to a vector that will hold all the IDs
  std::vector<std::pair<dof_id_type, unsigned>> & id_storage = container[sideset_name];
 
  // Variables for storing values read in from file
  unsigned side_id=0;
  char c;
  std::string elem_id_or_set, dummy;
 
  // Read until the start of another section is detected, or EOF is encountered
  while (_in->peek() != '*' && _in->peek() != EOF)
    {
      // Read first string up to and including the comma, which is discarded.
      std::getline(*_in, elem_id_or_set, ',');
 
      // Strip any leading or trailing trailing whitespace from this
      // string, since some Abaqus files may have this.
      strip_ws(elem_id_or_set);
 
      // Handle sidesets of type "NODE"
      if (sideset_type == "NODE")
        {
          // Create a sideset from a nodeset. This is not currently
          // supported, so print a warning and keep going.
          if (_nodeset_ids.count(elem_id_or_set))
            libMesh::out << "Warning: skipped creating a sideset from a "
                         << "nodeset, this is not yet supported."
                         << std::endl;
        }
 
      // Otherwise, we assume it's a sideset of the form: "391, S2" or "Elset_1, S3".
      // If it's not one of these forms, we'll throw an error instead
      // of letting the stream get into a bad state.
      else // sideset_type != "NODE"
        {
          // Read the character "S", followed by the side id. Note: the >> operator
          // eats whitespace until it reaches a valid character, so this should work
          // whether or not there is a space after the previous comma.
          *_in >> c >> side_id;
 
          // Try to convert first string to an integer.
          dof_id_type elem_id;
          bool success = string_to_num(elem_id_or_set, elem_id);
 
          if (success)
            {
              // if the side set is of the form of "391, S2"
              id_storage.emplace_back(elem_id, side_id);
            }
 
          if (!success)
            {
              // if the side set is of the form of "Elset_1, S3"
              const auto & vec = libmesh_map_find(_elemset_ids, elem_id_or_set);
              for (const auto & elem_id_in_elset : vec)
                id_storage.emplace_back(elem_id_in_elset, side_id);
            }
        }
 
      // Successful or not, we extract the remaining characters on the
      // line, including the newline, to (hopefully) go to the next section.
      std::getline(*_in, dummy);
    } // while
}

References _elemset_ids, _in, _nodeset_ids, libMesh::out, side_id, string_to_num(), and strip_ws().

Referenced by read().

set_n_partitions()

void libMesh::MeshInput< MeshBase >::set_n_partitions ( unsigned int  n_parts )

inlineprotectedinherited

Sets the number of partitions in the mesh.

Typically this gets done by the partitioner, but some parallel file formats begin "pre-partitioned".

Definition at line 101 of file mesh_input.h.

{ this->mesh().set_n_partitions() = n_parts; }

skip_comment_lines()

void libMesh::MeshInput< MeshBase >::skip_comment_lines ( std::istream &  in, const char  comment_start  )

protectedinherited

Reads input from in, skipping all the lines that start with the character comment_start.

Definition at line 113 of file mesh_input.h.

{
  char c, line[256];
 
  while (in.get(c), c==comment_start)
    in.getline (line, 255);
 
  // put back first character of
  // first non-comment line
  in.putback (c);
}

string_to_num()

bool libMesh::AbaqusIO::string_to_num ( const std::string &  input, dof_id_type &  output  ) const

protected

Attempts to convert the input string to a numerical value using strtol.

If the conversion fails, 0 will be stored in the output, so you must check the return value, which will be true if the conversion succeeded, and false if it failed for any reason.

Definition at line 1295 of file abaqus_io.C.

{
  char *endptr;
  output = cast_int<dof_id_type>(std::strtol(input.c_str(), &endptr, /*base=*/10));
 
  return (output != 0 || endptr != input.c_str());
}

Referenced by read_elements(), read_ids(), and read_sideset().

strip_ws()

void libMesh::AbaqusIO::strip_ws ( std::string &  line ) const

protected

Removes all whitespace characters from "line".

Simpler than trying to remember the erase-remove-if idiom.

Definition at line 1303 of file abaqus_io.C.

{
  line.erase(std::remove_if(line.begin(), line.end(),
                            [](unsigned char const c)
                            { return std::isspace(c); }),
             line.end());
}

Referenced by detect_generated_set(), generate_ids(), parse_label(), read_nodes(), and read_sideset().

Member Data Documentation

_already_seen_part

bool libMesh::AbaqusIO::_already_seen_part

protected

This flag gets set to true after the first "*PART" section we see.

If it is still true when we see a second PART section, we will print an error message... we don't currently handle input files with multiple parts.

Definition at line 221 of file abaqus_io.h.

Referenced by read().

_elem_types

std::set<ElemType> libMesh::AbaqusIO::_elem_types

protected

A set of the different geometric element types detected when reading the mesh.

Definition at line 213 of file abaqus_io.h.

Referenced by assign_subdomain_ids(), and read_elements().

_elemset_ids

container_t libMesh::AbaqusIO::_elemset_ids

protected

Definition at line 201 of file abaqus_io.h.

Referenced by assign_sideset_ids(), assign_subdomain_ids(), read(), read_elements(), and read_sideset().

_in

std::unique_ptr<std::istream> libMesh::AbaqusIO::_in

protected

Stream object used to interact with the file.

Definition at line 207 of file abaqus_io.h.

Referenced by generate_ids(), process_and_discard_comments(), read(), read_elements(), read_ids(), read_nodes(), and read_sideset().

_is_parallel_format

const bool libMesh::MeshInput< MeshBase >::_is_parallel_format

privateinherited

Flag specifying whether this format is parallel-capable.

If this is false (default) I/O is only permitted when the mesh has been serialized.

Definition at line 130 of file mesh_input.h.

_nodeset_ids

container_t libMesh::AbaqusIO::_nodeset_ids

protected

Abaqus writes nodesets and elemsets with labels.

As we read them in, we'll use these maps to provide a natural ordering for them.

Definition at line 200 of file abaqus_io.h.

Referenced by assign_boundary_node_ids(), read(), read_nodes(), and read_sideset().

_obj

MeshBase * libMesh::MeshInput< MeshBase >::_obj

privateinherited

A pointer to a non-const object object.

This allows us to read the object from file.

Definition at line 123 of file mesh_input.h.

_sideset_ids

sideset_container_t libMesh::AbaqusIO::_sideset_ids

protected

Definition at line 202 of file abaqus_io.h.

Referenced by assign_sideset_ids(), and read().

build_sidesets_from_nodesets

bool libMesh::AbaqusIO::build_sidesets_from_nodesets

Default false.

Set this flag to true if you want libmesh to automatically generate sidesets from Abaqus' nodesets. If the Abaqus file already contains some sidesets, we ignore this flag and don't generate sidesets, because the algorithm to do so currently does not take into account existing sidesets.

Definition at line 67 of file abaqus_io.h.

Referenced by read().

elems_of_dimension

std::vector<bool> libMesh::MeshInput< MeshBase >::elems_of_dimension

protectedinherited

A vector of bools describing what dimension elements have been encountered when reading a mesh.

Definition at line 107 of file mesh_input.h.

---

The documentation for this class was generated from the following files:

• include/mesh/abaqus_io.h
• src/mesh/abaqus_io.C