## 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 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.

- 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‘s meshes and boundary conditions can be read straightforwardly in Veamy to solve problems using the VEM.

## Author

Catalina Alvarez – B.Sc., M.Sc., Department of Computer Science, 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.

- Download the source code and unpack it.
- In the root directory of Veamy, create a
**build/**folder. - 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**) - Inside the
**build/**folder, type and execute in the terminal:`cmake ..`

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

`make`

- 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:

- 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");`

- 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.
- 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);`

- 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);`

- Create a Veamer instance and initialize the numerical problem:
`VeamyLinearElasticityDiscretization* problem = new VeamyLinearElasticityDiscretization(conditions); Veamer veamer(problem); veamer.initProblem(mesh);`

- Compute the displacements:
`Eigen::VectorXd displacements = veamer.simulate(mesh);`

- If required, print the nodal displacements to a text file:
`veamer.writeDisplacements("displacements.txt", displacements);`

- 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

- 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. - 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:`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");`

- 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:

Ortiz‐Bernardin, A., Alvarez, C., Hitschfeld‐Kahler, N., Russo, A., Silva‐Valenzuela, R., Olate‐Sanzana, E. Numerical Algorithms (2019). https://doi.org/10.1007/s11075‐018‐00651‐0

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 or consult the **Veamy Primer** that is located inside the **docs**/ folder.

## 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:

Ortiz‐Bernardin, A., Alvarez, C., Hitschfeld‐Kahler, N., Russo, A., Silva‐Valenzuela, R., Olate‐Sanzana, E. Numerical Algorithms (2019). https://doi.org/10.1007/s11075‐018‐00651‐0

## Download & Mailing List

>> Latest stable version of Veamy (18-June-2019): **Veamy v3.0 **

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

>> From **Veamy v2.1 **to **Veamy 3.0**:

- New optimized version of Veamy’s polygonal mesh generator Delynoi.
- Optimize several computations in the Veamy library.

>> From **Veamy v2.0** to **Veamy 2.1**:

- Add several test files for testing Feamy, the FEM module of Veamy.
- Fix some bugs.
- Update Veamy Primer: more details are added to sections devoted to using external mesh files (PolyMesher mesh and generic mesh files); Appendix A is added to explain the general structure of the main C++ setup file.

>> From **Veamy v1.1.1** to **Veamy 2.0**:

- Add documentation to the source code.
- Implement VEM for the two-dimensional Poisson problem.
- Implement Feamy, a FEM module that uses three-node triangular finite elements for the solution of the two dimensional linear elastostatic problem.
- Add methods to compute the L2-norm and H1-seminorm of the error.
- Improve the built-in polygonal mesh generator.
- Change to Eigen’s sparse solver for the solution of the system of linear equations.
- Add additional test files.
- New simplified methods to impose essential and Neumann boundary conditions.
- Fix several bugs.

>> 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

Since August 10, 2017

## Recent News

- The Virtual Element Decomposition: A New Paradigm for Developing Nodal Integration Schemes for Meshfree Galerkin Methods
A talk given by A. Ortiz-Bernardin at WONAPDE 2019, January 22, 2019, Concepción, Chile. THE VIRTUAL ELEMENT DECOMPOSITION: A NEW PARADIGM…

Read More » - Accepted Paper: Veamy: an extensible object-oriented C++ library for the virtual element method
Paper Accepted for Publication in Numerical Algorithms Aleandro Ortiz-Bernardin, Catalina Alvarez, Nancy Hitschfeld-Kahler, Alessandro Russo, Rodrigo Silva-Valenzuela, Edgardo Olate-Sanzana, “Veamy: an…

Read More » - Release of VEMLab v2.2.1 (now it runs in Octave!)
VEMLab: a MATLAB library for the virtual element method Release of VEMLab v2.2.1 >> From VEMLab v2.2 to VEMLab v2.2.1:…

Read More »

## Recent Publications

- Impact identification using nonlinear dimensionality reduction and supervised learning
Smart Materials and Structures Volume 28, Issue 11, 1 October 2019, Pages 115005 V. Meruane, C. Espinoza, E. Lopez Droguett,…

Read More » - Veamy: an extensible object-oriented C++ library for the virtual element method
Numerical Algorithms In press. Alejandro Ortiz-Bernardin, Catalina Alvarez, Nancy Hitschfeld-Kahler, Alessandro Russo, Rodrigo Silva-Valenzuela, Edgardo Olate-Sanzana. Abstract This paper summarizes the…

Read More » - On the behaviour of spherical inclusions in a cylinder under tension loads
Ingenius Vol. 19, 2018, pp. 69-78 S. Montero, R. Bustamante, A. Ortiz-Bernardin Abstract In the present paper the behaviour of…

Read More »