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

Features:

Free and open source C++ library that implements the virtual element method. The current release of this library allows the solution of 2D linear elastostatic problems.

  • Includes its own mesher based on the computation of the constrained Voronoi diagram. The meshes can be created in arbitrary 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).
  • 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 meshes and boundary conditions can be read straightforwardly in Veamy to solve 2D linear elastostatic problems.

Author

Catalina Alvarez – Master’s Student, Department of Computer Science, Universidad de Chile / B.Sc. Student, Department of Mechanical Engineering, Universidad de Chile.

Supervisors

Nancy Hitschfeld-Kahler – Associate Professor, Department of Computer Science, Universidad de Chile.

Alejandro Ortiz-Bernardin – Assistant Professor, Department of Mechanical Engineering, Universidad de Chile.

Collaborators

Alessandro Russo – Professor, Department of Mathematics and Applications, Università degli Studi di Milano-Bicocca.

Rodrigo Silva-Valenzuela – Master’s student, Department of Mechanical Engineering, Universidad de Chile.

Edgardo Olate-Sanzana – Master’s student, Department of Mechanical Engineering, 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)

    by the name of your main C++ file (in this case, mytest.cpp)

  4. Inside the build/ folder, type and execute in the terminal:
    cmake .. 

    to create the makefiles. And to compile the program type and execute:

    make 
  5. 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);
    TriangleMeshGenerator generator (region.getSeedPoints(), region);
    PolygonalMesh mesh = generator.getMesh();
  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 a boundary conditions container and fill it as desired:
    EssentialConstraints e; NaturalConstraints n;
    PointSegment leftSide (Point(0,0), Point(0,1));
    Constraint leftConstraint (leftSide, mesh.getPoints(), Constraint::Direction::Total, new Constant(0));
    PointSegment rightSide (Point(1,0), Point(1,1));
    Constraint rightConstraint (rightSide, mesh.getPoints(), Constraint::Direction::Horizontal, new Constant(1000));
    e.addConstraint(leftConstraint, mesh.getPoints());
    n.addConstraint(rightConstraint, mesh.getPoints());
    ConstraintsContainer container;
    container.addConstraints(e, mesh);
    container.addConstraints(n, mesh);
  4. Create the problem conditions container, assigning the domain material properties, the body forces if needed, and
    the boundary conditions:

    Material* material = new MaterialPlaneStrain(1e7, 0.3);
    ProblemConditions conditions(container, material);
  5. Create a Veamer instance and initialize the numerical problem:
    Veamer veamer;
    veamer.initProblem(mesh, conditions);
  6. Compute the displacements:
    Eigen::VectorXd displacements = veamer.simulate(mesh);
  7. If required, print the nodal displacements to a text file:
    veamer.writeDisplacements(fileName, displacements);
  8. The results can be plotted using the Matlab function plotPolyMeshDisplacements (located in folder /lib/visualization/ ):
    [points,polygons,displacements] = plotPolyMeshDisplacements('mesh.txt','displacements.txt','$u_x^h$','$u_y^h$','$||u^h||$');

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

Using PolyMesher

  1. Use the Matlab function PolyMesher2Veamy.m included in the polymesher/ folder and use it to generate a Veamy-format file, whose
    default name is “polymesher2veamy.txt”, from PolyMesher.
  2. Use 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:

    Veamer v;
    Material* material = new MaterialPlaneStress(1e7, 0.3);
    PolygonalMesh mesh = v.initProblemFromFile("polymesher2veamy.txt", material); 
  3. Proceed exactly as shown from step 6 forward, as boundary conditions are already defined.

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

Veamy’s paper example tests

All the examples that accompany the paper:

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”

can be found in test/ folder located in the root directory of Veamy. To run these example files just follow the instructions given in Running a Veamy program section of this manual.

Acknowledgements

Veamy depends on three external open source libraries, whose code is included in the repository.

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]

Download & Mailing List

>>  Latest stable version of Veamy (5-September-2017):  Veamy v1.1.1 

>>  Download:     Source code (zip)   |    Source code (tar.gz)    |      Veamy Primer v1.1 (PDF manual)

>>  From Veamy 1.0 to Veamy v1.1.1:

  • Add documentation.
  • Add method to include custom precision for printing output data.
  • Add plane stress material formulation.
  • Update installation instructions.
  • Include more tests and mesh examples.
  • Fix several bugs.

Browse the source code on GitHub

Get involved: subscribe to Veamy’s Users Mailing List

web statistic
web statistic
Since August 10, 2017

Recent News

All news

Recent Publications

All publications