https://gitlab.opengeosys.org/ogs/ogs.git
Tip revision: 6eefabc2ac5dd10e67d8b05fe9b00d4ee3edfc0c authored by Christoph Lehmann on 17 February 2016, 12:22:33 UTC
[NL] added a remark
[NL] added a remark
Tip revision: 6eefabc
Mesh.h
/**
* \file
* \author Karsten Rink
* \date 2012-05-02
* \brief Definition of the Mesh class.
*
* \copyright
* Copyright (c) 2012-2016, OpenGeoSys Community (http://www.opengeosys.org)
* Distributed under a Modified BSD License.
* See accompanying file LICENSE.txt or
* http://www.opengeosys.org/project/license
*
*/
#ifndef MESH_H_
#define MESH_H_
#include <cstdlib>
#include <string>
#include <vector>
#include "BaseLib/Counter.h"
#include "MeshEnums.h"
#include "Properties.h"
namespace MeshLib
{
class Node;
class Element;
/**
* A basic mesh.
*/
class Mesh : BaseLib::Counter<Mesh>
{
/* friend functions: */
friend void removeMeshNodes(MeshLib::Mesh &mesh, const std::vector<std::size_t> &nodes);
public:
/// Constructor using a mesh name and an array of nodes and elements
/// @param name Mesh name.
/// @param nodes A vector of mesh nodes. In case nonlinear nodes are involved, one should
/// put them after line ones in the vector and set "n_base_nodes" argument.
/// @param elements An array of mesh elements.
/// @param n_base_nodes The number of base nodes. This is an optional parameter for nonlinear case.
/// If the parameter is set to zero, we consider there are no nonlinear nodes.
Mesh(const std::string &name,
const std::vector<Node*> &nodes,
const std::vector<Element*> &elements,
Properties const& properties = Properties(),
const std::size_t n_base_nodes = 0);
/// Copy constructor
Mesh(const Mesh &mesh);
/// Destructor
virtual ~Mesh();
/// Add a node to the mesh.
void addNode(Node* node);
/// Add an element to the mesh.
void addElement(Element* elem);
/// Returns the dimension of the mesh (determined by the maximum dimension over all elements).
unsigned getDimension() const { return _mesh_dimension; }
/// Get the node with the given index.
const Node* getNode(unsigned idx) const { return _nodes[idx]; }
/// Get the element with the given index.
const Element* getElement(unsigned idx) const { return _elements[idx]; }
/// Get the minimum edge length over all elements of the mesh.
double getMinEdgeLength() const { return _edge_length.first; }
/// Get the maximum edge length over all elements of the mesh.
double getMaxEdgeLength() const { return _edge_length.second; }
/// Get the minimum node distance in the mesh.
/// The value is calculated from element-wise minimum node distances.
double getMinNodeDistance() const { return _node_distance.first; }
/// Get the maximum node distance over all elements of the mesh.
/// The value is calculated from element-wise maximum node distances.
double getMaxNodeDistance() const { return _node_distance.second; }
/// Get the number of elements
std::size_t getNElements() const { return _elements.size(); }
/// Get the number of nodes
std::size_t getNNodes() const { return _nodes.size(); }
/// Get name of the mesh.
const std::string getName() const { return _name; }
/// Get the nodes-vector for the mesh.
std::vector<Node*> const& getNodes() const { return _nodes; }
/// Get the element-vector for the mesh.
std::vector<Element*> const& getElements() const { return _elements; }
/// Resets the IDs of all mesh-elements to their position in the element vector
void resetElementIDs();
/// Resets the IDs of all mesh-nodes to their position in the node vector
void resetNodeIDs();
/// Changes the name of the mesh.
void setName(const std::string &name) { this->_name = name; }
/// Get id of the mesh
std::size_t getID() const {return _id; }
/// Get the number of base nodes
std::size_t getNBaseNodes() const { return _n_base_nodes; }
/// Return true if the given node is a basic one (i.e. linear order node)
bool isBaseNode(std::size_t node_idx) const {return node_idx < _n_base_nodes; }
/// Return true if the mesh has any nonlinear nodes
bool isNonlinear() const { return (getNNodes() != getNBaseNodes()); }
MeshLib::Properties & getProperties() { return _properties; }
MeshLib::Properties const& getProperties() const { return _properties; }
protected:
/// Set the minimum and maximum length over the edges of the mesh.
void calcEdgeLengthRange();
/// Set the minimum and maximum node distances within elements.
void calcNodeDistanceRange();
/**
* Resets the connected elements for the node vector, i.e. removes the old information and
* calls setElementsConnectedToNodes to set the new information.
* \attention This needs to be called if node neighbourhoods are reset.
*/
void resetElementsConnectedToNodes();
/// Sets the dimension of the mesh.
void setDimension();
/// Fills in the neighbor-information for nodes (i.e. which element each node belongs to).
void setElementsConnectedToNodes();
/// Fills in the neighbor-information for elements.
/// Note: Using this implementation, an element e can only have neighbors that have the same dimensionality as e.
void setElementNeighbors();
void setNodesConnectedByEdges();
/// Computes the element-connectivity of nodes. Two nodes i and j are
/// connected if they are shared by an element.
void setNodesConnectedByElements();
std::size_t const _id;
unsigned _mesh_dimension;
/// The minimal and maximal edge length over all elements in the mesh
std::pair<double, double> _edge_length;
/// The minimal and maximal distance of nodes within an element over all elements in the mesh
std::pair<double, double> _node_distance;
std::string _name;
std::vector<Node*> _nodes;
std::vector<Element*> _elements;
std::size_t _n_base_nodes;
Properties _properties;
}; /* class */
} /* namespace */
#endif /* MESH_H_ */