Пример #1
0
 void testZCoords2D(MeshLib::Mesh const& input, MeshLib::Mesh const& output, double height)
 {
     std::size_t const nNodes (input.getNumberOfNodes());
     for (std::size_t i=0; i<nNodes; ++i)
     {
         ASSERT_EQ((*input.getNode(i))[2], (*output.getNode(i))[2]);
         ASSERT_EQ((*input.getNode(i))[2] + height, (*output.getNode(nNodes+i))[2]);
     }
 }
Пример #2
0
// Project to parallels of YZ plane
TEST_F(ProjectionTest, ProjectToYZ)
{
    MathLib::Vector3 normal (1,0,0);
    std::size_t const n_nodes (_mesh->getNumberOfNodes());
    for (std::size_t p=0; p<10; p++)
    {
        MathLib::Point3d origin (std::array<double,3>{{static_cast<double>(p),0,0}});
        MeshLib::Mesh* result = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
        for (std::size_t i=0; i<n_nodes; i++)
            ASSERT_NEAR(static_cast<double>(p), (*result->getNode(i))[0], std::numeric_limits<double>::epsilon());
        delete result;
    }
}
Пример #3
0
std::vector<double> generateNodeValueDistribution(
	const NumLib::ISpatialFunction &func,
	const MeshLib::Mesh &msh,
	const std::vector<std::size_t> &vec_node_ids)
{
	// evaluate a given function with nodal coordinates
	std::vector<double> vec_values(vec_node_ids.size());
	std::transform(vec_node_ids.begin(), vec_node_ids.end(), vec_values.begin(),
		[&func, &msh](std::size_t node_id)
		{
			return func(*msh.getNode(node_id));
		});
	return vec_values;
}
Пример #4
0
// Length of normal does not matter (it's normalised within the method)
TEST_F(ProjectionTest, NormalLength)
{
    MathLib::Point3d origin (std::array<double,3>{{0,0,0}});
    MathLib::Vector3 normal (0,0,1);
    std::size_t const n_nodes (_mesh->getNumberOfNodes());
    MeshLib::Mesh* result = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
    for (std::size_t p=2; p<10; p++)
    {
        normal[2] = static_cast<double>(p);
        MeshLib::Mesh* result_p = MeshLib::projectMeshOntoPlane(*_mesh, origin, normal);
        for (std::size_t i=0; i<n_nodes; i++)
            ASSERT_EQ((*result->getNode(i))[2], (*result_p->getNode(i))[2]);
        delete result_p;
    }
    delete result;
}
Пример #5
0
MeshLib::Mesh createMeshFromSelectedNodes(
    MeshLib::Mesh const& mesh, std::vector<std::size_t> const& selected_nodes)
{
    // Deep copy of selected nodes from the mesh.
    std::vector<MeshLib::Node*> some_nodes;
    std::transform(begin(selected_nodes), end(selected_nodes),
                   back_inserter(some_nodes),
                   [&mesh](std::size_t const node_id) {
                       return new MeshLib::Node(*mesh.getNode(node_id));
                   });

    // The resulting mesh without elements containing the selected nodes.
    MeshLib::Mesh result("boundary_mesh", some_nodes, {});
    addPropertyToMesh(result, "bulk_node_ids", MeshLib::MeshItemType::Node, 1,
                      selected_nodes);
    return result;
}
Пример #6
0
TEST(MeshLib, Duplicate)
{
	MeshLib::Mesh* mesh (MeshLib::MeshGenerator::generateRegularQuadMesh(10, 5, 1));

	std::vector<MeshLib::Node*> new_nodes (MeshLib::copyNodeVector(mesh->getNodes()));
	std::vector<MeshLib::Element*> new_elements (MeshLib::copyElementVector(mesh->getElements(), new_nodes));

	MeshLib::Mesh new_mesh ("new", new_nodes, new_elements);

	ASSERT_EQ (mesh->getNElements(), new_mesh.getNElements());
	ASSERT_EQ (mesh->getNNodes(), new_mesh.getNNodes());

	std::vector<std::size_t> del_idx(1,1);
	MeshLib::removeMeshNodes(*mesh, del_idx);

	ASSERT_EQ (mesh->getNElements(), new_mesh.getNElements()-2);
	ASSERT_EQ (mesh->getNNodes(), new_mesh.getNNodes()-2);

	ASSERT_DOUBLE_EQ (4.0, MathLib::sqrDist(*mesh->getNode(0), *new_mesh.getNode(0)));
	ASSERT_DOUBLE_EQ (0.0, MathLib::sqrDist(*mesh->getNode(0), *new_mesh.getNode(2)));

	ASSERT_DOUBLE_EQ (4.0, MathLib::sqrDist(*mesh->getElement(0)->getNode(0), *new_mesh.getElement(0)->getNode(0)));
	ASSERT_DOUBLE_EQ (0.0, MathLib::sqrDist(*mesh->getElement(0)->getNode(0), *new_mesh.getElement(2)->getNode(0)));
}