compgeom.h

Go to the documentation of this file.

#ifndef MIDAS_COMPGEOM_H
#define MIDAS_COMPGEOM_H

#include "alias.h"

#include "geometry.h"
#include "gelib.h"
#include "gpa.h"


namespace midaspace {

class ComponentGeometry
{
 protected:
  Cell *owner;
  double zero;
  
  bool initialized;          // flag, geom. char. set up
 private:
  PoinT centrcoord;          // coordinates of centroid
 protected:
  LCS_pure *lcs;             // local coordinate system
  double circum;             // radius of circumscribed circle/sphere [polomer opsane kruznice/kulove plochy]
  double lav;                // length / area / volume ; is always > 0.0
  
 public:
  ComponentGeometry (Cell *o, double Z) { initialized = false; owner = o; zero = Z; lcs = NULL; }
  ComponentGeometry (const ComponentGeometry *src) { owner = src->owner;  zero = src->zero;  initialized = false; }
  virtual ~ComponentGeometry() { delete lcs; }
  
  virtual classID give_classid() const { return classComponentGeometry; }
  
  virtual void initialize (void);
  virtual void checkConsistency (void) const { }
  
  virtual int          give_dimension         (void) const = 0;
  virtual int          give_number_of_vertices(void) const = 0;
  virtual CellGeometry give_elemGeom          (void) const = 0;
  
  void initcheck (void) const { if (!initialized) ((ComponentGeometry*)this)->initialize(); }
  void set_owner (Cell *val) { owner = val; }
  const PoinT*    give_centercoords  (void) const { initcheck();  return &centrcoord; }
  double          give_circum        (void) const { initcheck();  return circum; }
  double          give_lav           (void) const { initcheck();  return lav; }
  double          give_GeomWeight1deg(void) const { initcheck();  return lav / this->give_number_of_vertices(); }
  virtual const LCS_pure* give_lcs           (void) { _errorr("not implemented"); return NULL; }
  
  virtual double give_characteristic_size(void) const { errol; return 0.0; }
  
  bool is_point_in_sphere (const PoinT *point) const { initcheck(); return (centrcoord.dist2_to(point) < circum*circum) ? true : false ; }
};

class ComponentGeometry1D : public ComponentGeometry
{
 public:
  ComponentGeometry1D (Cell *o, double Z) : ComponentGeometry(o, Z) { }
  ComponentGeometry1D (const ComponentGeometry1D *src) : ComponentGeometry(src) { }
  virtual ~ComponentGeometry1D() { }
  
  virtual classID give_classid() const { return classComponentGeometry1D; }
  
  virtual void initialize (void);
  
  virtual int          give_dimension         (void) const { return 1; }
  virtual int          give_number_of_vertices(void) const { return 2; };
  virtual CellGeometry give_elemGeom          (void) const { return CG_Line; }
  
  virtual double give_characteristic_size (void) const { initcheck(); return this->lav; }
};

class ComponentGeometry1Dpoly : public ComponentGeometry1D
{
  int nv;            // number of vertices
  
 public:
  ComponentGeometry1Dpoly (Cell *o, double Z);
  ComponentGeometry1Dpoly (const ComponentGeometry1Dpoly *src) : ComponentGeometry1D(src) { nv = src->nv; }
  virtual ~ComponentGeometry1Dpoly() { }
  
  virtual classID give_classid() const { return classComponentGeometry1Dpoly; }
  
  virtual void initialize (void);
  virtual void checkConsistency (void) const;
  
  virtual int          give_number_of_vertices(void) const { return nv; };
  virtual CellGeometry give_elemGeom          (void) const { return CG_PolyLine; }
  
  void reset_nv (void);
  
  
  virtual double give_characteristic_size (void) const { errol; return 0.0; }
};

class ComponentGeometry2D : public ComponentGeometry
{
 protected:
  int nv;             // number of vertices
  VectoR normal;      // normal vector == vector product of first 3 nodes; it is not normalized (it's length != 1.0)
  
 public:
  ComponentGeometry2D (Cell *o, double Z);
  ComponentGeometry2D (const ComponentGeometry2D *src) : ComponentGeometry(src) { nv = src->nv; normal.copy(&src->normal); }
  virtual ~ComponentGeometry2D() { }
  
  virtual classID give_classid() const { return classComponentGeometry2D; }
  
  virtual void initialize (void);
  virtual void checkConsistency (void) const;
  
  virtual int give_dimension         (void) const { return 2; }
  virtual int give_number_of_vertices(void) const { return nv; }
  
  const VectoR* give_normal (void) const { initcheck();  return &normal; }
  
  virtual const LCS_pure* give_lcs (void);
};

class ComponentGeometry2Dtriangle : public ComponentGeometry2D
{
 public:
  ComponentGeometry2Dtriangle (Cell *o, double Z) : ComponentGeometry2D(o, Z) { }
  ComponentGeometry2Dtriangle (const ComponentGeometry2Dtriangle *src) : ComponentGeometry2D(src) { }
  virtual ~ComponentGeometry2Dtriangle() { }
  
  virtual classID give_classid() const { errol; return classComponentGeometry2Dtriangle; }
  
  virtual CellGeometry give_elemGeom    (void) const { return CG_Triangle; }
  
  virtual double give_characteristic_size (void) const { initcheck(); return sqrt(2.0 * this->lav); } // sqrt(2.0 * this->lav / sin(60))
};
class ComponentGeometry2Dquadrangle : public ComponentGeometry2D
{
 public:
  ComponentGeometry2Dquadrangle (Cell *o, double Z) : ComponentGeometry2D(o, Z) { }
  ComponentGeometry2Dquadrangle (const ComponentGeometry2Dquadrangle *src) : ComponentGeometry2D(src) { }
  virtual ~ComponentGeometry2Dquadrangle() { }
  
  virtual classID give_classid() const { return classComponentGeometry2Dquadrangle; }
  
  virtual CellGeometry give_elemGeom    (void) const { return CG_Quadrangle; }
  
  virtual double give_characteristic_size (void) const { initcheck(); return sqrt(this->lav); }
};
class ComponentGeometry2Dpolygon : public ComponentGeometry2D
{
 public:
  ComponentGeometry2Dpolygon (Cell *o, double Z) : ComponentGeometry2D(o, Z) { }
  ComponentGeometry2Dpolygon (const ComponentGeometry2Dpolygon *src) : ComponentGeometry2D(src) { }
  virtual ~ComponentGeometry2Dpolygon() { }
  
  virtual classID give_classid() const { errol; return classComponentGeometry2Dpolygon; }
  
  void set_nv (int n) { nv = n; }
  virtual CellGeometry give_elemGeom    (void) const { return CG_Polygon; }
};

class ComponentGeometry3D : public ComponentGeometry
{
 public:
  ComponentGeometry3D (Cell *o, double Z) : ComponentGeometry(o, Z) { }
  ComponentGeometry3D (const ComponentGeometry3D *src) : ComponentGeometry(src) { }
  virtual ~ComponentGeometry3D() { }
  
  virtual classID give_classid() const { return classComponentGeometry3D; }
  
  virtual int give_dimension() const { return 3; }
};
class ComponentGeometry3Dhexahedron : public ComponentGeometry3D
{
 public:
  ComponentGeometry3Dhexahedron (Cell *o, double Z) : ComponentGeometry3D(o, Z) { }
  ComponentGeometry3Dhexahedron (const ComponentGeometry3Dhexahedron *src) : ComponentGeometry3D(src) { }
  virtual ~ComponentGeometry3Dhexahedron() { }
  
  virtual classID give_classid() const { errol; return classComponentGeometry3Dhexahedron; }
  
  virtual void initialize (void);
  
  virtual int          give_number_of_vertices(void) const { return 8; }
  virtual CellGeometry give_elemGeom          (void) const { return CG_Hexahedron; }
};
class ComponentGeometry3Dtetrahedron : public ComponentGeometry3D
{
 public:
  ComponentGeometry3Dtetrahedron (Cell *o, double Z) : ComponentGeometry3D(o, Z) { }
  ComponentGeometry3Dtetrahedron (const ComponentGeometry3Dtetrahedron *src) : ComponentGeometry3D(src) { }
  virtual ~ComponentGeometry3Dtetrahedron() { }
  
  virtual classID give_classid() const { errol; return classComponentGeometry3Dtetrahedron; }
  
  virtual void initialize (void);
  
  virtual int          give_number_of_vertices(void) const { return 4; }
  virtual CellGeometry give_elemGeom          (void) const { return CG_Tetrahedron; }
};


} // namespace midaspace

#endif // MIDAS_COMPGEOM_H