/*
 * Copyright (c) 2009-2013:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */

/**	\page pageLGIntroduction libGrid
	
	- \ref secLGAbout "About"
	- \ref secLGWhatIsIt "What is libGrid?"
	- \ref secLGFeatures "Main features?"
	- \ref secLGUsage "Usage"

<hr>
\section secLGAbout About
libGrid has been written and is still developed by Sebastian Reiter (Sebastian.Reiter@gcsc.uni-frankfurt.de) at the
<i>Goethe Center for Scientific Computing at the University of Frankfurt, Germany </i>(http://www.g-csc.de).
libGrid is developed as a part of the ug4 framework.
 
Amongst others, the following people contributed to libGrid:<br>
Sebastian Reiter, Martin Stepniewski, Nicolas Tessore

<hr>
\section secLGWhatIsIt What is libGrid?
libGrid is a library for the manipulation of 1, 2 and 3 dimensional grids
written in C++.
It is designed in a flexible way that should allow its usage for all
grid-related algorithms.

<hr>
\section secLGFeatures Main features
libGrid tries to treat grids in a flexible, but at the same time fast and efficient way.
This goal is achieved by separation of topology and data.<br>
While the elements of a grid are stored in linked lists,
the associated data is stored in separate arrays.
This not only improves cache-hits considerably but also allows to add (and remove)
data to the elements of the grid at runtime.
To avoid performance problems, data is not added to elements one by one, but to all
elements of the same type (Vertices / Edges / Faces / Volumes) at once.<br>
Data management is fully automated. The access to data is simple, typesafe and fast.

libGrid supports both normal and hierarchical grids.
\sa ug::Grid, ug::MultiGrid

A grid in libGrid can consist of vertices, edges, faces and volumes.
Besides others, the following important concrete types are supported:
	- Vertex
	- Edge
	- Triangle, Quadrilateral
	- Tetrahedron, Hexahedron, Prism, Pyramid

\sa lib_grid_geometric_objects

New types can be added without much hassle.
Those types can be combined as desired. A grid could for example consist of some
Vertices that are connected by Triangles plus a single edge.
However, since it is sometimes desireable that missing edges (or faces) are created
automatically if a new face or volume is added, grids feature options
through which such behaviours can be turned on and off.

Automated access to the neighbourhood of elements is another feature of libGrid.
Neighbours of an element can be collected on the fly, or are optionally stored
for each element. This allows the user to choose between better runtime or
lower memory consumption.
This again can be changed at runtime, which allows algorithms to enable or disable
features as required.

Since libGrid heavily uses template-programming, efficient algorithms can be implemented
with a minimal amount of code. However, while thorough knowledge of template-programming
is beneficial for writing intelligent and efficient code,
only a very basic understanding is required to start programming with libGrid.

LibGrid also features a mechanism to register observers at a grid. Those observers
are then notified if changes to the grids topology are made.
Combined with the possibility to dynamically add data to a grid at runtime, those
observers are a powerful tool to create stable, robust and modular code. 
\sa ug::Selector, \sa ug::SubsetHandler, \sa ug::MGSubsetHandler


<hr>
\section secLGUsage Usage
An introduction to the most important ideas behind libGrid and a short overview of the coding-style
can be found here:

\subpage pageLGOverview "Overview"

*/
