fe::Mesh Class Reference

A class for mesh data. More...

#include <mesh.h>

Collaboration diagram for fe::Mesh:

Public Member Functions
	Mesh (size_t dim=0)
	Constructor.
	Mesh (inp::MeshDeck *deck)
	Constructor.
std::string	printStr (int nt=0, int lvl=0) const
	Returns the string containing printable information about the object.
void	print (int nt=0, int lvl=0) const
	Prints the information about the object.
Accessor methods
size_t	getDimension () const
	Get the dimension of the domain.
size_t	getNumNodes () const
	Get the number of nodes.
size_t	getNumElements () const
	Get the number of elements.
size_t	getNumDofs () const
	Get the number of dofs.
size_t	getElementType () const
	Get the type of element in mesh.
double	getMeshSize () const
	Get the mesh size.
util::Point	getNode (const size_t &i) const
	Get coordinates of node i.
double	getNodalVolume (const size_t &i) const
	Get nodal volume of node i.
const std::vector< util::Point > &	getNodes () const
	Get the nodes data.
std::vector< util::Point > &	getNodes ()
	Get the nodes data.
const std::vector< util::Point > *	getNodesP () const
	Get the pointer to nodes data.
std::vector< util::Point > *	getNodesP ()
	Get the pointer to nodes data.
const std::vector< uint8_t > *	getFixityP () const
	Get the pointer to fixity data.
std::vector< uint8_t > *	getFixityP ()
	Get the pointer to fixity data.
const std::vector< uint8_t > &	getFixity () const
	Get the reference to fixity data.
std::vector< uint8_t > &	getFixity ()
	Get the reference to fixity data.
const std::vector< double > &	getNodalVolumes () const
	Get the nodal volume data.
std::vector< double > &	getNodalVolumes ()
	Get the nodal volume data.
const std::vector< double > *	getNodalVolumesP () const
	Get the pointer to nodal volume data.
std::vector< double > *	getNodalVolumesP ()
	Get the pointer to nodal volume data.
bool	isNodeFree (const size_t &i, const unsigned int &dof) const
	Return true if node is free.
std::vector< size_t >	getElementConnectivity (const size_t &i) const
	Get the connectivity of element.
std::vector< util::Point >	getElementConnectivityNodes (const size_t &i) const
	Get the vertices of element.
const std::vector< size_t > &	getElementConnectivities () const
	Get the reference to element-node connectivity data.
std::vector< size_t > &	getElementConnectivities ()
	Get the reference to element-node connectivity data.
const std::vector< size_t > *	getElementConnectivitiesP () const
	Get the pointer to element-node connectivity data.
std::vector< size_t > *	getElementConnectivitiesP ()
	Get the pointer to element-node connectivity data.
const std::pair< std::vector< double >, std::vector< double > > &	getBoundingBox () const
	Get the bounding box of the mesh.
std::pair< std::vector< double >, std::vector< double > > &	getBoundingBox ()
	Get the bounding box of the mesh.
Setter methods
void	setFixity (const size_t &i, const unsigned int &dof, const bool &flag)
	Set the fixity to free (0) or fixed (1)
void	clearElementData ()
	Clear element-node connectivity data.
Utility methods
void	createData (const std::string &filename, bool ref_config=false)
	Reads mesh data from the file and populates other data.
bool	readElementData (const std::string &filename)
	Reads element-node connectivity data from file. This function is meant for cases when mesh was created without element-node connectivity data but later during output, strain/stress were required which needs element-node connectivity data.
void	computeVol ()
	Compute the nodal volume.
void	computeBBox ()
	Compute the bounding box
void	computeMeshSize ()
	Compute the mesh size.

Data Fields
size_t	d_dim
	Dimension of the mesh.
std::string	d_spatialDiscretization
	Tag for spatial discretization type.
std::string	d_filename
	Filename to read mesh data.
bool	d_needEncData
	Flag that indicates whether we need enc data (set by input mesh deck in constructor)
bool	d_encDataPopulated
	Flag that indicates whether element-node connectivity data is read from file.
size_t	d_numDofs
	Number of dofs = (dimension) times (number of nodes)
std::vector< size_t >	d_gMap
	Map from global reduced id to default global id.
std::vector< int >	d_gInvMap
	Map from global id to reduced global id.
std::pair< std::vector< double >, std::vector< double > >	d_bbox
	Bounding box.
double	d_h
	Mesh size.
Mesh data
size_t	d_numNodes
	Number of nodes.
size_t	d_numElems
	Number of elements.
size_t	d_eType
	Element type.
size_t	d_eNumVertex
	Number of vertex per element.
std::vector< util::Point >	d_nodes
	Vector of initial (reference) coordinates of nodes.
std::vector< size_t >	d_enc
	Element-node connectivity data.
std::vector< std::vector< size_t > >	d_nec
	Node-element connectivity data.
std::vector< uint8_t >	d_fix
	Vector of fixity mask of each node.
std::vector< double >	d_vol
	Vector of volume of each node.
Mesh data specific to parallel implementation
size_t	d_nPart
	Number of partitions.
std::string	d_partitionMethod
	Partitioning method. It could be either empty string or "metis_recursive" or "metis_kway".
std::vector< size_t >	d_nodePartition
	Node partition information. For each node i, d_nodePartition[i] specifies the partition number, i.e., the processor that owns the node in MPI application.

Detailed Description

A class for mesh data.

In this class the mesh data such as nodes, element-node connectivity, node-element connectivity are stored. The class also stores fixity mask of nodes which indicates if x-, y-, or z-dof of the node is fixed or free.

We currently only support mesh with only one type of elements, i.e. mesh can not have mix of two types of elements. For example, we can not have mesh with triangle and quadrangle elements together.

This class is used in both finite difference implementation and finite element implementation. For finite difference, we only require nodal volume. If the mesh file contains nodal volume, we skip reading element-node and node-element connectivity, however if mesh file does not have nodal volume data, we read connectivity data and compute the nodal volume.

Definition at line 51 of file mesh.h.

Constructor & Destructor Documentation

Mesh() [1/2]

fe::Mesh::Mesh ( size_t  dim = 0 )

explicit

Constructor.

Parameters

dim	Dimension of the domain

Definition at line 26 of file mesh.cpp.

    : d_numNodes(0), d_numElems(0), d_eType(1), d_eNumVertex(0), d_numDofs(0),
      d_h(0.), d_dim(dim), d_encDataPopulated(false), d_needEncData(false),
      d_nPart(0){}

Mesh() [2/2]

fe::Mesh::Mesh ( inp::MeshDeck *  deck )

explicit

Constructor.

The constructor initializes the data using input deck, performs checks on input data, and reads mesh file and populates the mesh related data. The mesh file of **.csv**, **.vtu (VTK)** and **.msh (Gmsh)** are supported.

Parameters

deck	Input deck which contains user-specified information

Definition at line 31 of file mesh.cpp.

    : d_numNodes(0), d_numElems(0), d_eType(1), d_eNumVertex(0), d_numDofs(0),
      d_h(deck->d_h), d_dim(deck->d_dim),
      d_spatialDiscretization(deck->d_spatialDiscretization),
      d_filename(deck->d_filename), d_encDataPopulated(false),
      d_needEncData(deck->d_populateElementNodeConnectivity),
      d_nPart(0) {
 
  // perform check on input data
  if (d_spatialDiscretization != "finite_difference" and
      d_spatialDiscretization != "weak_finite_element" and
      d_spatialDiscretization != "nodal_finite_element" and
      d_spatialDiscretization != "truss_finite_element") {
    std::cerr << "Error: Spatial discretization type not known. Check input "
                 "data.\n";
    std::cerr << deck->printStr() << "\n";
    exit(1);
  }
 
  if (d_dim < 0 or d_dim > 3) {
    std::cerr << "Error: Check Dimension in input data.\n";
    exit(1);
  }
 
  if (d_filename.empty()) {
    std::cerr << "Error: Filename for mesh data not specified.\n";
    exit(1);
  }
 
  // read mesh data from file
  createData(d_filename);
}

References createData(), d_dim, d_filename, d_spatialDiscretization, and inp::MeshDeck::printStr().

Here is the call graph for this function:

Member Function Documentation

clearElementData()

void fe::Mesh::clearElementData

(

)

Clear element-node connectivity data.

Definition at line 396 of file mesh.cpp.

                              {
  if (!d_enc.empty())
    d_enc.shrink_to_fit();
  d_numElems = 0;
  if (!d_nec.empty())
    d_nec.shrink_to_fit();
}

computeBBox()

void fe::Mesh::computeBBox

(

)

Compute the bounding box

Definition at line 332 of file mesh.cpp.

                         {
  std::vector<double> p1(3,0.);
  std::vector<double> p2(3,0.);
  for (const auto& x : d_nodes) {
    if (util::isLess(x.d_x, p1[0]))
      p1[0] = x.d_x;
    if (util::isLess(x.d_y, p1[1]))
      p1[1] = x.d_y;
    if (util::isLess(x.d_z, p1[2]))
      p1[2] = x.d_z;
    if (util::isLess(p2[0], x.d_x))
      p2[0] = x.d_x;
    if (util::isLess(p2[1], x.d_y))
      p2[1] = x.d_y;
    if (util::isLess(p2[2], x.d_z))
      p2[2] = x.d_z;
  }
 
  d_bbox = std::make_pair(p1, p2);
}

References util::isLess().

Here is the call graph for this function:

computeMeshSize()

void fe::Mesh::computeMeshSize

(

)

Compute the mesh size.

This method searches for minimum distance between any two mesh nodes and stores it as a mesh size.

Definition at line 353 of file mesh.cpp.

                             {
 
  double guess = 0.;
  if (d_nodes.size() < 2) {
    d_h = 0.;
    return;
  }
 
  guess = (d_nodes[0] - d_nodes[1]).length();
  for (size_t i = 0; i < d_nodes.size(); i++)
    for (size_t j = 0; j < d_nodes.size(); j++)
      if (i != j) {
        double val = d_nodes[i].dist(d_nodes[j]);
 
        if (util::isLess(val, 1.0E-12)) {
 
          std::cout << "Check nodes are too close = "
                    << util::io::printStr<util::Point>({d_nodes[i],
                                                         d_nodes[j]})
                    << "\n";
          std::cout << "Distance = " << val << ", guess = " << guess << "\n";
        }
        if (util::isLess(val, guess))
          guess = val;
      }
 
  d_h = guess;
}

References util::isLess().

Here is the call graph for this function:

computeVol()

void fe::Mesh::computeVol

(

)

Compute the nodal volume.

This method requires element-node connectivity data to compute the nodal volumes. Formula for volume of a node \( i\) is given by

\[ V_i = \sum_{e \in \mathbf{N}_i} \int_{T_e} N_i(x) dx, \]

where \(\mathbf{N}_i\) is a list of elements which have node \( i\) as its vertex, \( T_e\) is the element domain, \( N_i\) is the shape function of the node \( i\) in element e.

Definition at line 250 of file mesh.cpp.

                        {
 
  // initialize quadrature data
  fe::BaseElem *quads;
  if (d_eType == util::vtk_type_triangle)
    quads = new fe::TriElem(2);
  else if (d_eType == util::vtk_type_quad)
    quads = new fe::QuadElem(2);
  else if (d_eType == util::vtk_type_tetra)
    quads = new fe::TetElem(2);
 
  // check if we have valid element-node connectivity data for nodal volume
  // calculations
  if (d_nec.size() != d_numNodes || d_enc.empty()) {
    std::cerr << "Error: Can not compute nodal volume for given finite "
                 "element mesh as the element-node connectivity data is "
                 "invalid."
              << std::endl;
    exit(EXIT_FAILURE);
  }
 
  if (false) {
    print(0, 0);
    std::cout << "\n-------- Node data ----------\n";
    std::cout << util::io::printStr(d_nodes, 0) << "\n";
    std::cout << "\n-------- Element data ----------\n";
    std::cout << util::io::printStr(d_enc, 0) << "\n";
  }
 
  //
  // compute nodal volume
  //
  d_vol.resize(d_numNodes);
  
  tf::Executor executor(util::parallel::getNThreads());
  tf::Taskflow taskflow;
 
  taskflow.for_each_index(
    (std::size_t) 0, this->d_numNodes, (std::size_t) 1, [this, quads](std::size_t i) {
      double v = 0.0;
 
      for (auto e : this->d_nec[i]) {
 
        std::vector<size_t> e_ns = this->getElementConnectivity(e);
 
        // locate global node i in local list of element el
        int loc_i = -1;
        for (size_t l = 0; l < e_ns.size(); l++)
          if (e_ns[l] == i)
            loc_i = l;
 
        if (loc_i == -1) {
          std::cerr << "Error: Check node element connectivity.\n";
          exit(1);
        }
 
        // get quad data
        std::vector<util::Point> e_nodes;
        for (auto k : e_ns)
          e_nodes.emplace_back(this->d_nodes[k]);
 
        // get volume of element
        double vol = quads->elemSize(e_nodes);
        double factor = 1.;
        if (vol < 0.)
          factor = -1.;
 
        std::vector<fe::QuadData> qds = quads->getQuadDatas(e_nodes);
 
        // compute V_e and add it to volume
        for (auto qd : qds)
          v += qd.d_shapes[loc_i] * factor * qd.d_w;
      } // loop over elements
 
      // update
      this->d_vol[i] = v;
    }
  ); // for_each
  
  executor.run(taskflow).get();
}

References fe::BaseElem::elemSize(), util::parallel::getNThreads(), fe::BaseElem::getQuadDatas(), util::io::printStr(), util::vtk_type_quad, util::vtk_type_tetra, and util::vtk_type_triangle.

Here is the call graph for this function:

createData()

void fe::Mesh::createData	(	const std::string &	filename,
		bool	ref_config = false
	)

Reads mesh data from the file and populates other data.

This function calls reader methods in namespace rw::reader to read the mesh file. For finite difference implementation, we support **.csv** mesh file which has nodal coordinates and nodal volumes data.

However, for finite element implementation, we require either **.vtu** or **.msh** file with element-node connectivity data.

Parameters

filename	Name of the mesh file
ref_config	Flag which specifies if we need to subtract the displacement from nodes obtained from vtu file to get reference position of nodes

Definition at line 67 of file mesh.cpp.

                                                                  {
 
  util::io::log("Mesh: Reading element data.\n");
 
  int file_type = -1;
  // find the extension of file and call correct reader
  if (util::io::getExtensionFromFile(filename) == "csv")
    file_type = 0;
  else if (util::io::getExtensionFromFile(filename) == "msh")
    file_type = 1;
  else if (util::io::getExtensionFromFile(filename) == "vtu")
    file_type = 2;
  else {
    std::cerr << "Error: Currently only '.csv', '.msg', and '.vtu' "
                 "files are supported for reading mesh.\n";
    exit(EXIT_FAILURE);
  }
 
  if (d_spatialDiscretization != "finite_difference" and file_type == 0) {
 
    std::cerr << "Error: For discretization = " << d_spatialDiscretization
              << " .vtu or .msh mesh file is required.\n";
    exit(1);
  }
 
  //
  bool is_fd = false;
  if (d_spatialDiscretization == "finite_difference")
    is_fd = true;
 
  // read node and elements
  if (file_type == 0)
    rw::reader::readCsvFile(filename, d_dim, &d_nodes, &d_vol);
  else if (file_type == 1) {
    rw::reader::readMshFile(filename, d_dim, &d_nodes, d_eType, d_numElems,
                            &d_enc, &d_nec, &d_vol, false);
    d_encDataPopulated = true;
  }
  else if (file_type == 2) {
    //
    // old reading of mesh
    //
    // rw::reader::readVtuFile(filename, d_dim, &d_nodes, d_eType, d_numElems,
    //                         &d_enc, &d_nec, &d_vol, false);
 
    //
    // new reading of mesh
    // We read the data from file one by one depending on what data we need
    //
 
    // read node
    rw::reader::readVtuFileNodes(filename, d_dim, &d_nodes, ref_config);
 
    // read volume if required
    bool found_volume_data = false;
    if (is_fd) {
      found_volume_data =
          rw::reader::readVtuFilePointData(filename, "Node_Volume", &d_vol);
 
      // try another tag for nodal volume
      if (!found_volume_data)
        found_volume_data =
            rw::reader::readVtuFilePointData(filename, "Volume", &d_vol);
    }
 
    // read element data (only if this is fe simulation or if we need
    // element-node connectivity data for nodal volume calculation)
    if (!is_fd || !found_volume_data) {
      rw::reader::readVtuFileCells(filename, d_dim, d_eType, d_numElems, &d_enc,
                                   &d_nec);
      d_encDataPopulated = true;
    }
 
    // check if file has fixity data
    rw::reader::readVtuFilePointData(filename, "Fixity", &d_fix);
  }
 
  // compute data from mesh data
  d_numNodes = d_nodes.size();
  d_eNumVertex = util::vtk_map_element_to_num_nodes[d_eType];
  d_numDofs = d_numNodes * d_dim;
 
  //
  // assign default values to fixity
  //
  if (d_fix.size() != d_numNodes)
    d_fix = std::vector<uint8_t>(d_nodes.size(), uint8_t(0));
 
  //
  // compute nodal volume if required
  //
  bool compute_vol = false;
  if (is_fd and d_vol.empty()) compute_vol = true;
 
  // if this is weak finite element simulation then check from policy if
  // volume is to be computed
  if (d_spatialDiscretization == "weak_finite_element")
    compute_vol = false;
 
  if (compute_vol) {
    util::io::log("Mesh: Computing nodal volume.\n");
    computeVol();
  }
 
  //
  // compute bounding box
  //
  computeBBox();
 
  // check if we need to compute mesh size
  //if (deck->d_computeMeshSize)
  computeMeshSize();
 
  // check nodal volume
  size_t counter = 0;
  for (const auto &v : d_vol) {
 
    if (v < 0.01 * std::pow(d_h, d_dim)) {
 
      std::cerr << "Error: Check nodal volume " << v
                << " is less than " <<  0.01 * std::pow(d_h, d_dim)
                << ", Node = " << counter
                << " at position = " << d_nodes[counter].printStr() << "\n"
                << "mesh filename = " << filename << "\n"
                << printStr() << "\n";
 
      exit(1);
    }
 
    counter++;
  }
 
  if (d_needEncData and (!d_encDataPopulated or d_enc.empty()))
    readElementData(d_filename);
}

References util::io::getExtensionFromFile(), util::io::log(), rw::reader::readCsvFile(), rw::reader::readMshFile(), rw::reader::readVtuFileCells(), rw::reader::readVtuFileNodes(), rw::reader::readVtuFilePointData(), and util::vtk_map_element_to_num_nodes.

Referenced by Mesh().

Here is the call graph for this function:

Here is the caller graph for this function:

getBoundingBox() [1/2]

std::pair< std::vector< double >, std::vector< double > > & fe::Mesh::getBoundingBox ( )

inline

Get the bounding box of the mesh.

Returns

box Bounding box

Definition at line 265 of file mesh.h.

                                                                  {
    return d_bbox;
  };

References d_bbox.

getBoundingBox() [2/2]

const std::pair< std::vector< double >, std::vector< double > > & fe::Mesh::getBoundingBox ( ) const

inline

Get the bounding box of the mesh.

Returns

box Bounding box

Definition at line 259 of file mesh.h.

        {
    return d_bbox;
  };

References d_bbox.

getDimension()

size_t fe::Mesh::getDimension ( ) const

inline

Get the dimension of the domain.

Returns

N Dimension

Definition at line 82 of file mesh.h.

{ return d_dim; };

References d_dim.

Referenced by fe::getMaxShearStressAndLoc(), and fe::getStrainStress().

Here is the caller graph for this function:

getElementConnectivities() [1/2]

std::vector< size_t > & fe::Mesh::getElementConnectivities ( )

inline

Get the reference to element-node connectivity data.

Returns

reference Reference

Definition at line 238 of file mesh.h.

                                                {
    return d_enc;
  };

References d_enc.

getElementConnectivities() [2/2]

const std::vector< size_t > & fe::Mesh::getElementConnectivities ( ) const

inline

Get the reference to element-node connectivity data.

Returns

reference Reference

Definition at line 233 of file mesh.h.

                                                            {
    return d_enc;
  };

References d_enc.

getElementConnectivitiesP() [1/2]

std::vector< size_t > * fe::Mesh::getElementConnectivitiesP ( )

inline

Get the pointer to element-node connectivity data.

Returns

pointer Pointer

Definition at line 251 of file mesh.h.

                                                 {
    return &d_enc;
  };

References d_enc.

getElementConnectivitiesP() [2/2]

const std::vector< size_t > * fe::Mesh::getElementConnectivitiesP ( ) const

inline

Get the pointer to element-node connectivity data.

Returns

pointer Pointer

Definition at line 246 of file mesh.h.

                                                             {
    return &d_enc;
  };

References d_enc.

getElementConnectivity()

std::vector< size_t > fe::Mesh::getElementConnectivity ( const size_t &  i ) const

inline

Get the connectivity of element.

Since we store connectivity in a single vector, we use fe::Mesh::d_eNumVertex to get the connectivity of element. Given element e, the connectivity of e begins from location \( i_0 = e*d\_eNumVertex + 0 \) upto \(i_{n-1} = e*d\_eNumVertex + d\_eNumVertex - 1\).

So the connectivity of e is d_enc[ \(i_0\)], d_enc[ \( i_1 \)], ..., d_end[ \(i_{n-1}\)]

Parameters

i	Id of an element

Returns

vector Vector of nodal ids

Definition at line 210 of file mesh.h.

                                                                  {
    return std::vector<size_t>(d_enc.begin() + d_eNumVertex * i,
                               d_enc.begin() + d_eNumVertex * i + d_eNumVertex);
  };

References d_dim, d_enc, and d_eNumVertex.

Referenced by fe::getCurrentQuadPoints(), fe::getMaxShearStressAndLoc(), and fe::getStrainStress().

Here is the caller graph for this function:

getElementConnectivityNodes()

std::vector< util::Point > fe::Mesh::getElementConnectivityNodes ( const size_t &  i ) const

inline

Get the vertices of element.

Parameters

i	Id of an element

Returns

vector Vector of vertices

Definition at line 221 of file mesh.h.

                                                                        {
    std::vector<util::Point> nds;
    for (size_t k = 0; k < d_eNumVertex; k++)
      nds.emplace_back(d_nodes[d_enc[d_eNumVertex * i + k]]);
    return nds;
  };

References d_dim, d_enc, d_eNumVertex, and d_nodes.

getElementType()

size_t fe::Mesh::getElementType ( ) const

inline

Get the type of element in mesh.

Returns

type Element type (using VTK convention)

Definition at line 106 of file mesh.h.

{ return d_eType; };

References d_eType.

Referenced by fe::getCurrentQuadPoints(), fe::getMaxShearStressAndLoc(), and fe::getStrainStress().

Here is the caller graph for this function:

getFixity() [1/2]

std::vector< uint8_t > & fe::Mesh::getFixity ( )

inline

Get the reference to fixity data.

Returns

reference Reference to fixity data

Definition at line 162 of file mesh.h.

{ return d_fix; };

References d_fix.

getFixity() [2/2]

const std::vector< uint8_t > & fe::Mesh::getFixity ( ) const

inline

Get the reference to fixity data.

Returns

reference Reference to fixity data

Definition at line 159 of file mesh.h.

{ return d_fix; };

References d_fix.

getFixityP() [1/2]

std::vector< uint8_t > * fe::Mesh::getFixityP ( )

inline

Get the pointer to fixity data.

Returns

pointer Pointer to fixity data

Definition at line 153 of file mesh.h.

{ return &d_fix; };

References d_fix.

getFixityP() [2/2]

const std::vector< uint8_t > * fe::Mesh::getFixityP ( ) const

inline

Get the pointer to fixity data.

Returns

pointer Pointer to fixity data

Definition at line 150 of file mesh.h.

{ return &d_fix; };

References d_fix.

getMeshSize()

double fe::Mesh::getMeshSize ( ) const

inline

Get the mesh size.

Returns

h Mesh size

Definition at line 112 of file mesh.h.

{ return d_h; };

References d_h.

getNodalVolume()

double fe::Mesh::getNodalVolume ( const size_t &  i ) const

inline

Get nodal volume of node i.

Parameters

i	Id of the node

Returns

vol Volume

Definition at line 126 of file mesh.h.

{ return d_vol[i]; };

References d_dim, and d_vol.

getNodalVolumes() [1/2]

std::vector< double > & fe::Mesh::getNodalVolumes ( )

inline

Get the nodal volume data.

Returns

Vector Vector of nodal volume

Definition at line 171 of file mesh.h.

{ return d_vol; };

References d_vol.

getNodalVolumes() [2/2]

const std::vector< double > & fe::Mesh::getNodalVolumes ( ) const

inline

Get the nodal volume data.

Returns

Vector Vector of nodal volume

Definition at line 168 of file mesh.h.

{ return d_vol; };

References d_vol.

getNodalVolumesP() [1/2]

std::vector< double > * fe::Mesh::getNodalVolumesP ( )

inline

Get the pointer to nodal volume data.

Returns

pointer Pointer to nodal volume data

Definition at line 180 of file mesh.h.

{ return &d_vol; };

References d_vol.

getNodalVolumesP() [2/2]

const std::vector< double > * fe::Mesh::getNodalVolumesP ( ) const

inline

Get the pointer to nodal volume data.

Returns

pointer Pointer to nodal volume data

Definition at line 177 of file mesh.h.

{ return &d_vol; };

References d_vol.

getNode()

util::Point fe::Mesh::getNode ( const size_t &  i ) const

inline

Get coordinates of node i.

Parameters

i	Id of the node

Returns

coords Coordinates

Definition at line 119 of file mesh.h.

{ return d_nodes[i]; };

References d_dim, and d_nodes.

getNodes() [1/2]

std::vector< util::Point > & fe::Mesh::getNodes ( )

inline

Get the nodes data.

Returns

nodes Nodes data

Definition at line 135 of file mesh.h.

{ return d_nodes; };

References d_nodes.

getNodes() [2/2]

const std::vector< util::Point > & fe::Mesh::getNodes ( ) const

inline

Get the nodes data.

Returns

nodes Nodes data

Definition at line 132 of file mesh.h.

{ return d_nodes; };

References d_nodes.

getNodesP() [1/2]

std::vector< util::Point > * fe::Mesh::getNodesP ( )

inline

Get the pointer to nodes data.

Returns

pointer Pointer to nodes data

Definition at line 144 of file mesh.h.

{ return &d_nodes; };

References d_nodes.

getNodesP() [2/2]

const std::vector< util::Point > * fe::Mesh::getNodesP ( ) const

inline

Get the pointer to nodes data.

Returns

pointer Pointer to nodes data

Definition at line 141 of file mesh.h.

{ return &d_nodes; };

References d_nodes.

getNumDofs()

size_t fe::Mesh::getNumDofs ( ) const

inline

Get the number of dofs.

Returns

N Number of dofs

Definition at line 100 of file mesh.h.

{ return d_numDofs; };

References d_numDofs.

getNumElements()

size_t fe::Mesh::getNumElements ( ) const

inline

Get the number of elements.

Returns

N Number of elements

Definition at line 94 of file mesh.h.

{ return d_enc.size()/d_eNumVertex; };

References d_enc, and d_eNumVertex.

Referenced by fe::getCurrentQuadPoints(), fe::getMaxShearStressAndLoc(), and fe::getStrainStress().

Here is the caller graph for this function:

getNumNodes()

size_t fe::Mesh::getNumNodes ( ) const

inline

Get the number of nodes.

Returns

N number of nodes

Definition at line 88 of file mesh.h.

{ return d_numNodes; };

References d_numNodes.

Referenced by fe::getCurrentQuadPoints(), fe::getMaxShearStressAndLoc(), and fe::getStrainStress().

Here is the caller graph for this function:

isNodeFree()

bool fe::Mesh::isNodeFree ( const size_t &  i, const unsigned int &  dof  ) const

inline

Return true if node is free.

Parameters

i	Id of node
dof	Dof to check for

Returns

bool True if dof is free else false

Definition at line 188 of file mesh.h.

                                                                  {
 
    // below checks if d_fix has 1st bit (if dof=0), 2nd bit (if dof=1), 3rd
    // bit (if dof=2) is set to 1 or 0. If set to 1, then it means it is fixed,
    // and therefore it returns false
    return !(d_fix[i] >> dof & 1UL);
  };

References d_dim, and d_fix.

print()

void fe::Mesh::print ( int  nt = 0, int  lvl = 0  ) const

inline

Prints the information about the object.

Parameters

nt	Number of tabs to append before printing
lvl	Information level (higher means more information)

Definition at line 306 of file mesh.h.

{ std::cout << printStr(nt, lvl); };

References d_dim, and printStr().

Here is the call graph for this function:

printStr()

std::string fe::Mesh::printStr	(	int	nt = 0,
		int	lvl = 0
	)		const

Returns the string containing printable information about the object.

Parameters

nt	Number of tabs to append before printing
lvl	Information level (higher means more information)

Returns

string String containing printable information about the object

Definition at line 404 of file mesh.cpp.

                                                {
 
  auto tabS = util::io::getTabS(nt);
  std::ostringstream oss;
  oss << tabS << "------- Mesh --------" << std::endl << std::endl;
  oss << tabS << "Dimension = " << d_dim << std::endl;
  oss << tabS << "Spatial discretization type = " << d_spatialDiscretization << std::endl;
  oss << tabS << "Mesh size = " << d_h << std::endl;
  oss << tabS << "Num nodes = " << d_numNodes << std::endl;
  oss << tabS << "Num elements = " << d_numElems << std::endl;
  oss << tabS << "Element type = " << d_eType << std::endl;
  oss << tabS << "Num nodes per element = " << d_eNumVertex << std::endl;
  oss << tabS << "Num nodal vol = " << d_vol.size() << std::endl;
  oss << tabS << "Bounding box: " << std::endl;
  oss << util::io::printBoxStr(d_bbox, nt + 1);
  oss << tabS << std::endl;
 
  return oss.str();
}

References util::io::getTabS(), and util::io::printBoxStr().

Referenced by print().

Here is the call graph for this function:

Here is the caller graph for this function:

readElementData()

bool fe::Mesh::readElementData

(

const std::string &

filename

)

Reads element-node connectivity data from file. This function is meant for cases when mesh was created without element-node connectivity data but later during output, strain/stress were required which needs element-node connectivity data.

File must be either **.vtu** or **.msh** file and must have element-node connectivity data.

Parameters

filename

Name of the mesh file

Definition at line 203 of file mesh.cpp.

                                                      {
 
  if (d_encDataPopulated and !d_enc.empty()) {
    util::io::log("Mesh: Element data is populated already.\n");
    return false;
  }
 
  util::io::log("Mesh: Reading element-node connectivity data.\n");
 
  int file_type = -1;
  // find the extension of file and call correct reader
  if (util::io::getExtensionFromFile(filename) == "csv")
    file_type = 0;
  else if (util::io::getExtensionFromFile(filename) == "msh")
    file_type = 1;
  else if (util::io::getExtensionFromFile(filename) == "vtu")
    file_type = 2;
  else {
    std::cerr << "Error: Currently only '.csv', '.msg', and '.vtu' "
                 "files are supported for reading mesh.\n";
    exit(EXIT_FAILURE);
  }
 
  if (file_type == 0) {
    std::cerr << "Error: readElementData() requires file to be either "
                 ".vtu or .msh mesh file.\n";
    exit(EXIT_FAILURE);
  }
 
  if (file_type == 1) {
    rw::reader::readMshFileCells(filename, d_dim, d_eType, d_numElems,
                                       &d_enc,
                                       &d_nec);
    d_encDataPopulated = true;
    return true;
  }
  else if (file_type == 2) {
    rw::reader::readVtuFileCells(filename, d_dim, d_eType, d_numElems,
                                 &d_enc,
                                 &d_nec);
    d_encDataPopulated = true;
    return true;
  }
 
  return false;
}

References util::io::getExtensionFromFile(), util::io::log(), rw::reader::readMshFileCells(), and rw::reader::readVtuFileCells().

Here is the call graph for this function:

setFixity()

void fe::Mesh::setFixity	(	const size_t &	i,
		const unsigned int &	dof,
		const bool &	flag
	)

Set the fixity to free (0) or fixed (1)

Parameters

i	Id of node
dof	Dof which is affected
flag	Set fixity to fixed if true or free

Definition at line 385 of file mesh.cpp.

                                           {
 
  // to set i^th bit as true of integer a,
  // a |= 1UL << (i % 8)
 
  // to set i^th bit as false of integer a,
  // a &= ~(1UL << (i % 8))
 
  flag ? (d_fix[i] |= 1UL << dof) : (d_fix[i] &= ~(1UL << dof));
}

Field Documentation

d_bbox

std::pair<std::vector<double>, std::vector<double> > fe::Mesh::d_bbox

Bounding box.

Definition at line 513 of file mesh.h.

Referenced by fe::createUniformMesh(), getBoundingBox(), and getBoundingBox().

d_dim

size_t fe::Mesh::d_dim

Dimension of the mesh.

Definition at line 468 of file mesh.h.

Referenced by model::DEMModel::createParticles(), fe::createUniformMesh(), getDimension(), getElementConnectivity(), getElementConnectivityNodes(), getNodalVolume(), getNode(), isNodeFree(), Mesh(), and print().

d_enc

std::vector<size_t> fe::Mesh::d_enc

Element-node connectivity data.

Structure: First d_eNumVertex data gives the connectivity of first element, and next d_eNumVertex data gives the connectivity of second element and so on and so fourth.

Definition at line 415 of file mesh.h.

Referenced by fe::createUniformMesh(), getElementConnectivities(), getElementConnectivities(), getElementConnectivitiesP(), getElementConnectivitiesP(), getElementConnectivity(), getElementConnectivityNodes(), and getNumElements().

d_encDataPopulated

bool fe::Mesh::d_encDataPopulated

Flag that indicates whether element-node connectivity data is read from file.

Definition at line 487 of file mesh.h.

d_eNumVertex

size_t fe::Mesh::d_eNumVertex

Number of vertex per element.

This information is useful in getting the connectivity for a given element. We assume that the mesh has only one type of elements and based on that assumption we store the element-node connectivity in a single vector.

The value for different elements are

• Line element: 2,
• Triangle element: 3,
• Quadrilateral element: 4,
• Tetrahedral element: 4

Definition at line 404 of file mesh.h.

Referenced by fe::createUniformMesh(), fe::getCurrentQuadPoints(), getElementConnectivity(), getElementConnectivityNodes(), fe::getMaxShearStressAndLoc(), getNumElements(), and fe::getStrainStress().

d_eType

size_t fe::Mesh::d_eType

Element type.

We follow VTK convention to identify the elements:

• Line element = 3,
• Triangle element = 5,
• Pixel element = 8,
• Quadrilateral element = 9,
• Tetrahedral element = 10

Definition at line 389 of file mesh.h.

Referenced by fe::createUniformMesh(), and getElementType().

d_filename

std::string fe::Mesh::d_filename

Filename to read mesh data.

Definition at line 481 of file mesh.h.

Referenced by Mesh().

d_fix

std::vector<uint8_t> fe::Mesh::d_fix

Vector of fixity mask of each node.

First bit represents x-dof, second represents y-dof, and third represents z-dof. 0 represents free dof and 1 represents fixed dof.

We store data in uint8_t type which can hold 8 bit. At present we only use first 3 bits.

Definition at line 431 of file mesh.h.

Referenced by fe::createUniformMesh(), getFixity(), getFixity(), getFixityP(), getFixityP(), and isNodeFree().

d_gInvMap

std::vector<int> fe::Mesh::d_gInvMap

Map from global id to reduced global id.

This is a inverse of d_gMap

Definition at line 510 of file mesh.h.

d_gMap

std::vector<size_t> fe::Mesh::d_gMap

Map from global reduced id to default global id.

We assign number to each free dof where number ranges from 0 to total number of free dofs. This is referred to set of global reduced id. This new set of ids are subset of set of global ids of all dofs, and therefore, "reduced" word is used.

d_gMap provides a map from global reduced id to global id.

Note

Needed only when the discretization is "weak_finite_element" for the assembly of the mass matrix.

Definition at line 504 of file mesh.h.

d_h

double fe::Mesh::d_h

Mesh size.

Definition at line 516 of file mesh.h.

Referenced by fe::createUniformMesh(), and getMeshSize().

d_nec

std::vector<std::vector<size_t> > fe::Mesh::d_nec

Node-element connectivity data.

At present, this data is never populated.

Definition at line 421 of file mesh.h.

d_needEncData

bool fe::Mesh::d_needEncData

Flag that indicates whether we need enc data (set by input mesh deck in constructor)

Definition at line 484 of file mesh.h.

d_nodePartition

std::vector<size_t> fe::Mesh::d_nodePartition

Node partition information. For each node i, d_nodePartition[i] specifies the partition number, i.e., the processor that owns the node in MPI application.

For uniform square mesh, the volume is simply \( h^2 \) in 2-d and \( h^3\) in 3-d, where \( h\) is the mesh size. For general mesh, the volume is computed using the element-node connectivity of the mesh.

Definition at line 463 of file mesh.h.

Referenced by fe::metisGraphPartition().

d_nodes

std::vector<util::Point> fe::Mesh::d_nodes

Vector of initial (reference) coordinates of nodes.

Definition at line 407 of file mesh.h.

Referenced by fe::createUniformMesh(), getElementConnectivityNodes(), getNode(), getNodes(), getNodes(), getNodesP(), and getNodesP().

d_nPart

size_t fe::Mesh::d_nPart

Number of partitions.

Definition at line 449 of file mesh.h.

Referenced by fe::metisGraphPartition().

d_numDofs

size_t fe::Mesh::d_numDofs

Number of dofs = (dimension) times (number of nodes)

Definition at line 490 of file mesh.h.

Referenced by fe::createUniformMesh(), and getNumDofs().

d_numElems

size_t fe::Mesh::d_numElems

Number of elements.

Definition at line 378 of file mesh.h.

Referenced by fe::createUniformMesh().

d_numNodes

size_t fe::Mesh::d_numNodes

Number of nodes.

Definition at line 375 of file mesh.h.

Referenced by fe::createUniformMesh(), and getNumNodes().

d_partitionMethod

std::string fe::Mesh::d_partitionMethod

Partitioning method. It could be either empty string or "metis_recursive" or "metis_kway".

Definition at line 454 of file mesh.h.

Referenced by fe::metisGraphPartition().

d_spatialDiscretization

std::string fe::Mesh::d_spatialDiscretization

Tag for spatial discretization type.

List of valid values are:

• finite_difference
• weak_finite_element
• nodal_finite_element
• truss_finite_element

Definition at line 478 of file mesh.h.

Referenced by Mesh().

d_vol

std::vector<double> fe::Mesh::d_vol

Vector of volume of each node.

For uniform square mesh, the volume is simply \( h^2 \) in 2-d and \( h^3\) in 3-d, where \( h\) is the mesh size. For general mesh, the volume is computed using the element-node connectivity of the mesh.

Definition at line 439 of file mesh.h.

Referenced by fe::createUniformMesh(), getNodalVolume(), getNodalVolumes(), getNodalVolumes(), getNodalVolumesP(), and getNodalVolumesP().

---

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

• /home/user/project/src/fe/mesh.h
• /home/user/project/src/fe/mesh.cpp