Functions
util::SymMatrix3	strainFromB (const fe::B &B, const std::vector< util::Point > &u)

void	readNodes (const std::string &filename, std::vector< util::Point > &nodes)

size_t	readElements (const std::string &filename, const size_t &elem_type, std::vector< size_t > &elements)

bool	checkRefIntegration (const size_t &n, const size_t &i, const size_t &j, const std::vector< fe::QuadData > &qds, double &I_exact)

bool	checkRefIntegration (const size_t &n, const size_t &i, const size_t &j, const size_t &k, const std::vector< fe::QuadData > &qds, double &I_exact)

Variables
int	debug_id = -1

const double	tol = 1.0E-12

Function Documentation

◆ checkRefIntegration() [1/2]

bool anonymous_namespace{testFeLib.cpp}::checkRefIntegration	(	const size_t &	n,
		const size_t &	i,
		const size_t &	j,
		const size_t &	k,
		const std::vector< fe::QuadData > &	qds,
		double &	I_exact
	)

Definition at line 131 of file testFeLib.cpp.

                                                     {
 
      double I_approx = 0.;
      for (auto qd: qds)
        I_approx += qd.d_w * std::pow(qd.d_p.d_x, i) * std::pow(qd.d_p.d_y, j) *
                    std::pow(qd.d_p.d_z, k);
 
      if (std::abs(I_exact - I_approx) > tol) {
        std::cout << "Error in order = " << n << ". Exact integration = " << I_exact
                  << " and approximate integration = " << I_approx
                  << " of polynomial of order (i = " << i << " + j = " << j
                  << " + k = " << k << ") = " << i + j + k
                  << " over reference element "
                  << "is not matching using quadrature points.\n";
 
        std::cout << "Print " << i << " " << j << " " << k
                  << " debug id = " << debug_id << "\n";
        for (auto qd: qds)
          std::cout << qd.printStr() << "\n";
 
        return false;
      }
 
      return true;
    }

References debug_id, and tol.

◆ checkRefIntegration() [2/2]

bool anonymous_namespace{testFeLib.cpp}::checkRefIntegration	(	const size_t &	n,
		const size_t &	i,
		const size_t &	j,
		const std::vector< fe::QuadData > &	qds,
		double &	I_exact
	)

Definition at line 109 of file testFeLib.cpp.

                                                     {
 
      double I_approx = 0.;
      for (auto qd: qds)
        I_approx += qd.d_w * std::pow(qd.d_p.d_x, i) * std::pow(qd.d_p.d_y, j);
 
      if (std::abs(I_exact - I_approx) > tol) {
        std::cout << "Error in order = " << n << ". Exact integration = " << I_exact
                  << " and approximate integration = " << I_approx
                  << " of polynomial of order (i = " << i << " + j = " << j
                  << ") = " << i + j << " over reference element "
                  << "is not matching using quadrature points.\n";
 
        return false;
      }
 
      return true;
    }

References tol.

Referenced by test::testQuadElem(), test::testTetElem(), and test::testTriElem().

Here is the caller graph for this function:

◆ readElements()

size_t anonymous_namespace{testFeLib.cpp}::readElements	(	const std::string &	filename,
		const size_t &	elem_type,
		std::vector< size_t > &	elements
	)

Definition at line 70 of file testFeLib.cpp.

                                                            {
 
      if (elem_type == util::vtk_type_triangle) {
        io::CSVReader<3> in(filename);
        std::vector<size_t> ids(3, 0);
        while (in.read_row(ids[0], ids[1], ids[2])) {
          for (auto id: ids)
            elements.emplace_back(id);
        }
 
        size_t num_vertex = util::vtk_map_element_to_num_nodes[elem_type];
        return elements.size() / num_vertex;
      } else if (elem_type == util::vtk_type_quad) {
        io::CSVReader<4> in(filename);
        std::vector<size_t> ids(4, 0);
        while (in.read_row(ids[0], ids[1], ids[2], ids[3])) {
          for (auto id: ids)
            elements.emplace_back(id);
        }
 
        size_t num_vertex = util::vtk_map_element_to_num_nodes[elem_type];
        return elements.size() / num_vertex;
      } else if (elem_type == util::vtk_type_tetra) {
        io::CSVReader<4> in(filename);
        std::vector<size_t> ids(4, 0);
        while (in.read_row(ids[0], ids[1], ids[2], ids[3])) {
          for (auto id: ids)
            elements.emplace_back(id);
        }
 
        size_t num_vertex = util::vtk_map_element_to_num_nodes[elem_type];
        return elements.size() / num_vertex;
      } else {
        std::cerr << "Error: readElements() only supports vtk_type_triangle, vtk_type_quad, and vtk_type_tetra elem_type in testing.\n";
        exit(1);
      }
    }

References util::vtk_map_element_to_num_nodes, util::vtk_type_quad, util::vtk_type_tetra, and util::vtk_type_triangle.

Referenced by test::testQuadElem(), test::testTetElem(), and test::testTriElem().

Here is the caller graph for this function:

◆ readNodes()

void anonymous_namespace{testFeLib.cpp}::readNodes	(	const std::string &	filename,
		std::vector< util::Point > &	nodes
	)

Definition at line 60 of file testFeLib.cpp.

                                                       {
 
      // csv reader
      io::CSVReader<3> in(filename);
      double x, y, z;
      while (in.read_row(x, y, z))
        nodes.emplace_back(x, y, z);
    }

Referenced by test::testQuadElem(), test::testTetElem(), and test::testTriElem().

Here is the caller graph for this function:

◆ strainFromB()

util::SymMatrix3 anonymous_namespace{testFeLib.cpp}::strainFromB	(	const fe::B &	B,
		const std::vector< util::Point > &	u
	)

Definition at line 31 of file testFeLib.cpp.

                                                                {
      std::vector<double> uflat(B.nDof());
      const int dim = B.dim();
      for (size_t a = 0; a < u.size(); a++) {
        uflat[dim * static_cast<int>(a)] = u[a][0];
        if (dim > 1)
          uflat[dim * static_cast<int>(a) + 1] = u[a][1];
        if (dim > 2)
          uflat[dim * static_cast<int>(a) + 2] = u[a][2];
      }
      std::vector<double> e(B.nStrain(), 0.);
      for (int i = 0; i < B.nStrain(); i++)
        for (int j = 0; j < B.nDof(); j++)
          e[i] += B(i, j) * uflat[j];
      util::SymMatrix3 s;
      s(0, 0) = e[0];
      if (dim > 1) {
        s(1, 1) = e[1];
        s(0, 1) = (dim == 2) ? e[2] : e[5];
      }
      if (dim > 2) {
        s(2, 2) = e[2];
        s(1, 2) = e[3];
        s(0, 2) = e[4];
      }
      return s;
    }