Veamy: an extensible object-oriented C++ library for the virtual element method
Switch branches/tags
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
docs
lib
matplots
test
veamy
.gitignore
CMakeLists.txt
README.md

README.md

Veamy: an extensible object-oriented C++ library for the virtual element method

This repository contains the code for an open source C++ library that implements the virtual element method. The current release of this library allows the solution of 2D linear elastostatic problems and the 2D Poisson problem. The 2D linear elastostatic problem can also be solved using the standard three-node finite element triangle. For this, a module called Feamy is available within Veamy.

Features:

  • Includes its own mesher based on the computation of the constrained Voronoi diagram. The meshes can be created in arbitrary two-dimensional domains, with or without holes, with procedurally generated points.
  • Meshes can also be read from OFF-style text files (an example can be found in the test folder: see "EquilibriumPatchTestMain.cpp").
  • Allows easy input of boundary conditions by constraining domain segments and nodes.
  • The results of the computation can be either written into a file or used directly.
  • PolyMesher's meshes and boundary conditions can be read straightforwardly in Veamy to solve problems using the VEM.

Author

Catalina Alvarez - B.Sc., M.Sc., Universidad de Chile.

Running a Veamy program

Veamy is currently for Unix-like systems only.
  1. Download the source code and unpack it.
  2. In the root directory of Veamy, create a build/ folder.
  3. Go to test/ folder located in the root directory of Veamy and: (a) add the main C++ file (say, mytest.cpp) containing your test example problem, (b) modify the CMakeLists.txt by changing the file name example.cpp in
    set(SOURCE_FILES example.cpp)
  4. by the name of your main C++ file (in this case, mytest.cpp)
  5. Inside the build/ folder, type and execute in the terminal:
    cmake .. 
    to create the makefiles. And to compile the program type and execute:
    make 
  6. To run your example, go to the build/test/ folder, and in the terminal, type and execute:
    ./Test

Usage example

The complete procedure to compute the displacements using the virtual element method requires:
  1. If using the included mesher: create the domain and the input points, and then call the meshing procedure:
    std::vector points = {Point(0,0), Point(1,0), Point(1,1), Point(0,1)};
    Region region(points); 
    region.generateSeedPoints(PointGenerator(functions::random_double(), functions::random_double()), 10, 10);
    TriangleVoronoiGenerator generator (region.getSeedPoints(), region);
    Mesh<Polygon> mesh = generator.getMesh();
    mesh.printInFile("mesh.txt");
  2. If using an externally generated mesh, for example, from PolyMesher, refer to the next section of this tutorial; for a generic mesh format see "EquilibriumPatchTestMain.cpp" in the test folder.
  3. Create the problem conditions, assigning the domain material properties and the body forces if needed:
    Material* material = new MaterialPlaneStrain(1e7, 0.3);
    LinearElasticityConditions* conditions = new LinearElasticityConditions(material);
  4. Declare and assign boundary conditions:
    PointSegment leftSide (Point(0,0), Point(0,1));
    SegmentConstraint left(leftSide, mesh.getPoints(), new Constant(0));
    conditions->addEssentialConstraint(left, mesh.getPoints(), elasticity_constraints::Direction::Total);
    PointSegment rightSide (Point(1,0), Point(1,1));
    SegmentConstraint right(rightSide, mesh.getPoints(), new Constant(1000));
    conditions->addNaturalConstraint(right, mesh.getPoints(), elasticity_constraints::Direction::Horizontal);
  5. Create a Veamer instance and initialize the numerical problem:
    VeamyLinearElasticityDiscretization* problem = new VeamyLinearElasticityDiscretization(conditions);
    Veamer veamer(problem);
    veamer.initProblem(mesh);
  6. Compute the displacements:
    Eigen::VectorXd displacements = veamer.simulate(mesh);
  7. If required, print the nodal displacements to a text file:
    veamer.writeDisplacements("displacements.txt", displacements);
  8. The results can be plotted using the Matlab function plotPolyMeshDisplacements (located in folder matplots/ ):
    [points,polygons,displacements] = plotPolyMeshDisplacements('mesh.txt','displacements.txt','$$u_x^h$$','$$u_y^h$$','$$||u^h||$$','yes');

This and various additional examples are provided in the test/ folder located in the root directory of Veamy. In addition, thanks to its extensibility, Veamy is capable of solving the two dimensional Poisson problem. Two examples are provided in the test/ folder.

Using the Finite Element Method

Veamy, being an extensible library, includes the possibility of solving the linear elasticity problem using the Finite Element Method in a module named Feamy. Solving the linear elasticity problem using FEM is similar to VEM, with just a few differences:
  • The current finite element implementation only accepts triangular meshes (three-node triangular elements). Triangulations can be generated using the same mesher used for the polygonal mesh generation, as follows:
    std::vector points = {Point(0,0), Point(1,0), Point(1,1), Point(0,1)};
    Region region(points); 
    region.generateSeedPoints(PointGenerator(functions::random_double(), functions::random_double()), 10, 10);
    TriangleDelaunayGenerator generator (region.getSeedPoints(), region);
    Mesh<Triangle> mesh = generator.getConformingDelaunayTriangulation();
  • Both the constraints and problem conditions (body forces and material properties) are set exactly as in Veamy.
  • Create a Feamer instance, an ElementConstructor (which represents the type of elements to be used for the analysis --- in this case, three-node triangular elements), and initialize the numerical problem:
    Feamer feamer;
    feamer.initProblem(mesh, conditions, new Tri3Constructor());
  • Displacements computation and post processing are performed exactly as in Veamy
  • Using PolyMesher

    1. Use the Matlab function PolyMesher2Veamy.m included in the matplots/ folder and use it to generate a Veamy-format file, whose default name is "polymesher2veamy.txt", from PolyMesher.
    2. Use the name of the previously generated file as parameter of the initProblemFromFile method of the Veamer class. It requires the definition of the material properties, and, in the case the problem includes them, a body force pointer:
      Material* material = new MaterialPlaneStress(1e7, 0.3);
      LinearElasticityConditions* conditions = new LinearElasticityConditions(material);
      VeamyLinearElasticityDiscretization* problem = new VeamyLinearElasticityDiscretization(conditions);
      Veamer veamer(problem);
      Mesh mesh = veamer.initProblemFromFile("polymesher2veamy.txt");
    3. Proceed exactly as shown in steps 6 to 8 of "Usage example" section, as boundary conditions are already defined.

    This and various additional examples are provided in the test/ folder located in the root directory of Veamy.

    Acknowledgements

    Veamy depends on two external open source libraries, whose codes are included in this repository, inside lib/ folder. Linear algebra aspects are handled using:

    License

    This project is licensed under the GPL License. This program is free software; it can be redistributed or modified under the terms of the GNU General Public License as published by the Free Software Foundation.

    Citing Veamy

    If you use Veamy in a publication, please include an acknowledgement by citing Veamy as follows:

    A. Ortiz-Bernardin, C. Alvarez, N. Hitschfeld-Kahler, A. Russo, R. Silva, E. Olate-Sanzana. Veamy: an extensible object-oriented C++ library for the virtual element method. arXiv:1708.03438 [cs.MS]