dyna_io.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2025 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner

// 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.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



#ifndef LIBMESH_DYNA_IO_H
#define LIBMESH_DYNA_IO_H

// Local includes
#include "libmesh/libmesh_common.h"
#include "libmesh/mesh_input.h"
#include "libmesh/mesh_output.h"

// C++ includes
#include <algorithm>
#include <cstddef>
#include <map>
#include <vector>

namespace libMesh
{

// Forward declarations
class MeshBase;



class DynaIO : public MeshInput<MeshBase>
{
public:

  explicit
  DynaIO (MeshBase & mesh,
          bool keep_spline_nodes = true);

  virtual void read (const std::string & name) override;

  void add_spline_constraints(DofMap & dof_map,
                              unsigned int sys_num,
                              unsigned int var_num);

#ifdef LIBMESH_ENABLE_DEPRECATED

  void clear_spline_nodes();
#endif // LIBMESH_ENABLE_DEPRECATED

  typedef int32_t dyna_int_type;

  struct ElementDefinition
  {
    ElementDefinition(ElemType type_in,
                      dyna_int_type dyna_type_in,
                      dyna_int_type dim_in,
                      dyna_int_type p_in);

    ElementDefinition(ElemType type_in,
                      dyna_int_type dyna_type_in,
                      dyna_int_type dim_in,
                      dyna_int_type p_in,
                      std::vector<unsigned int> && nodes_in);

    ElemType type;
    dyna_int_type dyna_type;
    dyna_int_type dim;
    dyna_int_type p;
    std::vector<unsigned int> nodes;
  };


  static const ElementDefinition &
  find_elem_definition(dyna_int_type dyna_elem, int dim, int p);

  static const ElementDefinition &
  find_elem_definition(ElemType libmesh_elem, int dim, int p);

private:
  // Keep track of spline node indexing, so as to enable adding
  // constraint rows easily later.
  std::vector<Node *> spline_node_ptrs;
  std::unordered_map<Node *, Elem *> spline_nodeelem_ptrs;

  bool _keep_spline_nodes;

  void read_mesh (std::istream & in);

  static const int max_ints_per_line = 10;

  typedef double dyna_fp_type;

  static const int max_fps_per_line = 5;

  struct ElementMaps
  {
    // Helper function to add a (key, value) pair to both maps
    void add_def(const ElementDefinition & eledef)
    {
      out.emplace(eledef.type, eledef);
      in.emplace(std::make_tuple(eledef.dyna_type, eledef.dim, eledef.p), eledef);
    }

    std::map<ElemType, ElementDefinition> out;

    typedef std::tuple<dyna_int_type, dyna_int_type, dyna_int_type> Key;

    std::map<Key, ElementDefinition> in;
  };

  static ElementMaps _element_maps;

  static ElementMaps build_element_maps();
};


} // namespace libMesh

#endif // LIBMESH_DYNA_IO_H