Geometry.h

浏览该文件的文档。

#ifndef _Geometry_h_
#define _Geometry_h_

#ifndef NULL
#define NULL 0
#endif // NULL

#include <stdarg.h>
#include <dlfcn.h>

#include <cmath>
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <list>
#include <iterator>
#include <algorithm>

#include <base/exceptions.h>

#include "Miscellaneous.h"

template <int DIM> class Point;
class Geometry;
class GeometryBM;
template <int DIM, int DOW> class Mesh;
template <int DIM> class QuadratureInfo;
template <int DIM> class QuadratureInfoAdmin;
template <int DIM> class TemplateGeometry;
template <int DIM, int DOW> class SimplestMesh;

template <int DIM> Point<DIM> midpoint(const Point<DIM>&, const Point<DIM>&);
template <int DIM> double distance(const Point<DIM>&, const Point<DIM>&);
template <int DIM> Point<DIM> barycenter(const std::vector<Point<DIM> >&, const double * = NULL);
template <int DIM> Point<DIM> operator+(const Point<DIM>&, const Point<DIM>&);
template <int DIM> Point<DIM> operator-(const Point<DIM>&, const Point<DIM>&);
template <int DIM> std::istream& operator>>(std::istream&, Point<DIM>&);
template <int DIM> std::ostream& operator<<(std::ostream&, const Point<DIM>&);

std::istream& operator>>(std::istream&, Geometry&);
std::ostream& operator<<(std::ostream&, const Geometry&);
bool is_same(const Geometry&, const Geometry&);

template <int DIM> filtering_istream& operator>>(filtering_istream&, QuadratureInfo<DIM>&);
template <int DIM> std::ostream& operator<<(std::ostream&, const QuadratureInfo<DIM>&);

template <int DIM> filtering_istream& operator>>(filtering_istream&, QuadratureInfoAdmin<DIM>&);
template <int DIM> std::ostream& operator<<(std::ostream&, const QuadratureInfoAdmin<DIM>&);

typedef std::vector<Geometry>::iterator GeometryIterator;

template <int DIM, int DOW> std::istream& operator>>(std::istream&, Mesh<DIM,DOW>&);
template <int DIM, int DOW> std::ostream& operator<<(std::ostream&, const Mesh<DIM,DOW>&);

template <int DIM> filtering_istream& operator>>(filtering_istream&, TemplateGeometry<DIM>&);
template <int DIM> std::ostream& operator<<(std::ostream&, const TemplateGeometry<DIM>&);


template <int DIM>
class Point
{
 public:
  enum { dim = DIM };
 private:
  double x[DIM]; 
 public:
  Point(); 
  Point(const double *); 
  Point(const Point&); 
  Point(double, ...); 
  ~Point(); 
 public:
  Point<DIM>& operator=(const Point<DIM>&); 
  operator const double *() const; 
  operator double *(); 
  const double& operator[](int) const; 
  double& operator[](int); 
  double length() const; 
  Point<DIM>& operator+=(const Point<DIM>&);
  Point<DIM>& operator-=(const Point<DIM>&);
  Point<DIM>& operator*=(const double&);
  Point<DIM>& operator/=(const double&);
 public:
  friend Point<DIM> midpoint<>(const Point<DIM>&, const Point<DIM>&); 
  friend double distance<>(const Point<DIM>&, const Point<DIM>&); 
  friend Point<DIM> barycenter<>(const std::vector<Point<DIM> >&, const double *);
  friend Point<DIM> operator+ <>(const Point<DIM>&, const Point<DIM>&); 
  friend Point<DIM> operator- <>(const Point<DIM>&, const Point<DIM>&); 
  friend std::istream& operator>> <>(std::istream&, Point<DIM>&); 
  friend std::ostream& operator<< <>(std::ostream&, const Point<DIM>&); 
};

class Geometry
{
 private:
  int ind; 
  std::vector<int> vtx; 
  std::vector<int> bnd; 
 public:
  Geometry(); 
  Geometry(const Geometry&); 
  ~Geometry(); 
 public:
  Geometry& operator=(const Geometry&); 
  int index() const;
  int& index();
  int n_vertex() const; 
  int n_boundary() const; 
  const std::vector<int>& vertex() const; 
  std::vector<int>& vertex(); 
  const std::vector<int>& boundary() const; 
  std::vector<int>& boundary(); 
  int vertex(int) const; 
  int& vertex(int); 
  int boundary(int) const; 
  int& boundary(int); 
 public:
  friend bool isSame(const Geometry&, const Geometry&); 
  template <int, int> friend class Mesh; 
  friend std::istream& operator>>(std::istream&, Geometry&); 
  friend std::ostream& operator<<(std::ostream&, const Geometry&); 
};

class GeometryBM : public Geometry
{
 public:
  typedef int bmark_t;
 private:
  bmark_t bm; 
 public:
  GeometryBM(); 
  GeometryBM(const GeometryBM&); 
  ~GeometryBM(); 
 public:
  GeometryBM& operator=(const GeometryBM&); 
  int boundaryMark() const; 
  int& boundaryMark(); 
 public:
  template <int, int> friend class Mesh;
  friend std::istream& operator>>(std::istream&, GeometryBM&); 
  friend std::ostream& operator<<(std::ostream&, const GeometryBM&); 
};

template <int DIM, int DOW=DIM>
  class Mesh
  {
  public:
  enum { dim = DIM, dow = DOW };
  typedef Point<DOW> point_t;
  public:
  typedef GeometryBM::bmark_t bmark_t;
  private:
  typedef Mesh<DIM,DOW> mesh_t;

  std::vector<point_t > pnt; 
  std::vector<std::vector<GeometryBM> > geo; 
  public:
  Mesh(); 
  Mesh(const mesh_t&); 
  virtual ~Mesh(); 
  public:
  mesh_t& operator=(const mesh_t&); 
  unsigned int n_point() const; 
  unsigned int n_geometry(int) const; 
  const std::vector<point_t >& point() const; 
  std::vector<point_t >& point(); 
  const point_t& point(int) const; 
  point_t& point(int); 
  const std::vector<std::vector<GeometryBM> >& geometry() const; 
  std::vector<std::vector<GeometryBM> >& geometry(); 
  const std::vector<GeometryBM>& geometry(int) const; 
  std::vector<GeometryBM>& geometry(int); 
  const GeometryBM& geometry(int, int) const; 
  GeometryBM& geometry(int, int); 
  bmark_t boundaryMark(int, int) const; 
  bmark_t& boundaryMark(int, int); 
  void renumerateElement(); 
  void renumerateElementHSFC(void (*f)(double,double,double,double&,double&,double&)=NULL);
  void readData(const std::string&); 
  void writeData(const std::string&) const; 
  void readData1d(const std::string&); 
  virtual void writeEasyMesh(const std::string&) const {};
  virtual void writeTecplotData(const std::string&) const {};

  DeclException1(ExcMeshData, 
                 char *, 
                 << "Mesh data error: " << arg1);
  public:
  friend std::istream& operator>> <>(std::istream&, mesh_t&); 
  friend std::ostream& operator<< <>(std::ostream&, const mesh_t&); 
  friend filtering_istream& operator>> <>(filtering_istream&, TemplateGeometry<DIM>&);
  friend std::ostream& operator<< <>(std::ostream&, const TemplateGeometry<DIM>&);
  };

template <int DIM>
class QuadratureInfo
{
 public:
  enum { dim = DIM };
 private:
  int alg_acc; 
  std::vector<Point<DIM> > pnt; 
  std::vector<double> wei; 
 public:
  QuadratureInfo(); 
  QuadratureInfo(const QuadratureInfo<DIM>&); 
  ~QuadratureInfo(); 
 public:
  QuadratureInfo<DIM>& operator=(const QuadratureInfo<DIM>&); 
  int n_quadraturePoint() const; 
  int algebricAccuracy() const; 
  int& algebricAccuracy(); 
  const std::vector<Point<DIM> >& quadraturePoint() const; 
  std::vector<Point<DIM> >& quadraturePoint(); 
  const Point<DIM>& quadraturePoint(int) const; 
  Point<DIM>& quadraturePoint(int); 
  const std::vector<double>& weight() const; 
  std::vector<double>& weight(); 
  const double& weight(int) const; 
  double& weight(int); 
 public:
  friend filtering_istream& operator>> <>(filtering_istream&, QuadratureInfo<DIM>&); 
  friend std::ostream& operator<< <>(std::ostream&, const QuadratureInfo<DIM>&); 
};

template <int DIM>
class QuadratureInfoAdmin : public std::vector<QuadratureInfo<DIM> >
{
 public:
  enum { dim = DIM };
 private:
  std::vector<int> acc_tbl; 
 public:
  QuadratureInfoAdmin(); 
  QuadratureInfoAdmin(const QuadratureInfoAdmin<DIM>&); 
  ~QuadratureInfoAdmin(); 
 public:
  QuadratureInfoAdmin<DIM>& operator=(const QuadratureInfoAdmin<DIM>&); 
  const QuadratureInfo<DIM>& find(int) const; 
  QuadratureInfo<DIM>& find(int); 
 public:
  friend filtering_istream& operator>> <>(filtering_istream&, QuadratureInfoAdmin<DIM>&); 
  friend std::ostream& operator<< <>(std::ostream&, const QuadratureInfoAdmin<DIM>&); 
};

template <int DIM>
class TemplateGeometry : public Mesh<DIM,DIM>
{
 public:
  enum { dim = DIM };
 private:
  std::string library_path;
  void * handle; 
  std::string library_name; 
  std::string volume_function_name; 
  double (*volume_function)(const double **); 
  QuadratureInfoAdmin<DIM> quad_info; 
 public:
  TemplateGeometry(); 
  TemplateGeometry(const TemplateGeometry<DIM>&); 
  ~TemplateGeometry(); 
 public:
  TemplateGeometry& operator=(const TemplateGeometry<DIM>&); 
  void loadFunction(); 
  void unloadFunction(); 
  const std::vector<Point<DIM> >& vertexArray() const; 
  const QuadratureInfoAdmin<DIM>& quadratureInfo() const; 
  QuadratureInfoAdmin<DIM>& quadratureInfo(); 
  const QuadratureInfo<DIM>& findQuadratureInfo(int) const; 
  double volume() const; 
  void readData(const std::string&); 
  void writeData(const std::string&) const; 
  DeclException1(ExcTemplateGeometryData, 
                 char *, 
                 << "Template geometry data error: " << arg1);
  DeclException1(ExcFileOpen, char *,
                 << "Can't open library "
                 << arg1);
  DeclException2(ExcLoadFunction, char *, char *,
                 << "Can't load function "
                 << arg1
                 << " from library "
                 << arg2);
        
 public:
  friend filtering_istream& operator>> <>(filtering_istream&, TemplateGeometry<DIM>&); 
  friend std::ostream& operator<< <>(std::ostream&, const TemplateGeometry<DIM>&); 
};

template <int DIM, int DOW=DIM>
  class SimplestMesh
  {
  public:
  enum { dim = DIM, dow = DOW };
  protected:
  struct SimplestGeometry {
  public:
    int template_element; 
    std::vector<int> vertex; 
  };
  std::vector<Point<DOW> > pnt; 
  std::vector<SimplestGeometry> ele; 
  std::vector<TemplateGeometry<DIM> > * tg; 
  public:
  SimplestMesh() {}; 
  virtual ~SimplestMesh() {}; 
  public:
  int n_point() const {return pnt.size();} 
  int n_element() const {return ele.size();} 
  const std::vector<Point<DOW> >& point() const {return pnt;} 
  std::vector<Point<DOW> >& point() {return pnt;} 
  const Point<DOW>& point(int i) const {return pnt[i];} 
  Point<DOW>& point(int i) {return pnt[i];} 
  const std::vector<SimplestGeometry>& element() const {return ele;} 
  std::vector<SimplestGeometry>& element() {return ele;} 
  const SimplestGeometry& element(int i) const {return ele[i];} 
  SimplestGeometry& element(int i) {return ele[i];} 
  const std::vector<int>& elementVertex(int i) const {return ele[i].vertex;} 
  std::vector<int>& elementVertex(int i) {return ele[i].vertex;} 
  int elementVertex(int i, int j) const {return ele[i].vertex[j];} 
  int& elementVertex(int i, int j) {return ele[i].vertex[j];} 
  const std::vector<TemplateGeometry<DIM> >& templateGeometry() const {return *tg;} 
  std::vector<TemplateGeometry<DIM> >& templateGeometry() {return *tg;} 
  const TemplateGeometry<DIM>& templateGeometry(int i) const {return (*tg)[i];} 
  TemplateGeometry<DIM>& templateGeometry(int i) {return (*tg)[i];} 
  void setTemplateGeometry(std::vector<TemplateGeometry<DIM> >& t) {tg = &t;} 
  public:
  virtual void generateMesh(Mesh<DIM,DOW>&); 
  };

#endif //_Geometry_h_