geometry.h

Go to the documentation of this file.

#ifndef MIDAS_GEOMETRY_H
#define MIDAS_GEOMETRY_H

#include "alias.h"
#include "subject.h"

#include "gelib.h"
#include "librw.h"
#include "arrays.h"
#include "gpa.h"


namespace midaspace {

//*  ********************************************************************************************
//*  *** *** *** ***                      CLASS MESHGEOMETRY                      *** *** *** ***
//*  ********************************************************************************************
class Geometry : public ProblemSubject
{
  //  ******************************
  //  /**   @name GENERAL INFO   **/
  //  ******************************
  //  @{
 protected:
  MMprocessing gp;              // geometry processing; primary, secondary or other meshes
  
  //* STATE
  bool nodeprop, elemprop;      // property at all nodes or elems
  
  
 public:
  //*  *** SET ***
  //*  *** GET ***
  MMprocessing    give_gp (void) const { return gp; }
  bool            give_nodeprop (void) const { return nodeprop; }
  bool            give_elemprop (void) const { return elemprop; }
  // @}
  
  
  //  *******************************
  //  /**   @name GEOMETRY DATA   **/
  //  *******************************
  //  @{
 protected:
  long origPjntsNum, origElemsNum;     //
  GPA<Point>   Pjnts;                  // all points on domain
  GPA<Edge>    Edges;                  // all edges on domain
  GPA<Face>    Faces;                  // all faces on domain
  GPA<Element> Elems;                  // all elements on domain
  
 public:
  //*  *** GET ***
  long give_Npts(void) const { return Pjnts(); }
  long give_Neds(void) const { return Edges(); }
  long give_Nfas(void) const { return Faces(); }
  long give_Nels(void) const { return Elems(); }
  const Point*   give_Pjnt(long i) const { return Pjnts[i]; }
  const Edge*    give_Edge(long i) const { return Edges[i]; }
  const Face*    give_Face(long i) const { return Faces[i]; }
  const Element* give_Elem(long i) const { return Elems[i]; }
  const GPA<Point>*   give_Pjnts(void) const { return &Pjnts; }
  const GPA<Edge>*    give_Edges(void) const { return &Edges; }
  const GPA<Face>*    give_Faces(void) const { return &Faces; }
  const GPA<Element>* give_Elems(void) const { return &Elems; }
  
  // 
  const Point* give_Pjnt_with_prop (long prp, bool unique) const;
  
  //*  *** EDIT ***
  void add_another_Pjnt(Point   *comp);
  void add_another_Edge(Edge    *comp);
  void add_another_Face(Face    *comp);
  void add_another_Elem(Element *comp);
  void wdg_another_Elem(Element *comp, long nid);
  
  void replace_Pjnt_by (Point *Pold, Point *Pnew);
  void kill_damned_elems (void);
  void letoff_aa (void);
  // @}
  
  
  //  ********************************
  //  /**   @name GEOMETRY STATS   **/
  //  ********************************
  //  @{
 protected:
  bool connectivity_assembled;    // connectivity stats at ALL components are assembled
  
  long VTKCTcl;  // VTK_LINES
  long VTKCTct;  // VTK_TRIANGLE
  long VTKCTch;  // VTK_HEXAHEDRON
  //
  double aver_elem_circ;   // average element circum
  long   anyBeamElem;      // there is at least one beam/truss element (Beam Class) in this mesh
  //
  bool  boubox_assembled;                     // boundary box of points assembled
  PoinT boubox_min, boubox_max, boubox_diff;  // min and max coordinates, difference
  
  
 public:
  //*  *** SET INFO ***
  void connectivity_allocation   (void);
  void connectivity_assembling   (void);
  void VTKCT_assembling          (long indx=-1);
  void aver_elem_circ_assembling (long indx=-1);
  void anyBeamElem_assembling    (long indx=-1);
  void boubox_assembling         (long indx=-1);
  void geom_stats_assembling (const GeometryComponent *comp);
  
  //*  *** GET INFO ***
  bool connectivity_is_assembled (void) const { return connectivity_assembled; }
  bool VTKCT_is_assembled (void)        const { return (VTKCTcl >= 0); }
  void give_vtk_polydata_counts (long &cl, long &cp) const; // get/compute count of VTK polydata elements
  bool only_vtk_polydata   (void) const;                    // all elements is polydata compatible
  bool only_1d_elements    (void) const;                    // only 1d elements
  double give_aver_elem_circ (void) const;
  long   give_anyBeamElem    (void) const;
  const PoinT* give_boubox_diff (void) const;
  
  VTKdataset giveVTKDS (void);
  VTKPDtopology give_VTKPDtopology_of_elem(long i) const;
  void print_info (void) const;
  void print_geom_info (void) const;
  // @}
  
  
  //  *********************************
  //  /**   @name GENERAL METHODS   **/
  //  *********************************
  //  @{
 public:
  Geometry (long gid, const Problem *p, MMprocessing proc);
  virtual ~Geometry (void);
  
  virtual void initialize (void);
  virtual void finitialize (void);
  virtual void checkConsistency (void) const;
  
  
  //*  *** READ ***
  virtual Point* allocate_point (long gid, const PoinT *coo, char attribs_alloc='n') = 0;
  //virtual Element* allocate_Element (long gid, long oid, long dom, long lid, const GeometryComponent *masterel=NULL) = 0;
  void read_addata_VTK (const char *filename, bool sparse);
  void read_VTK (char DATASET, Stream *stream, bool addata=false, bool sparse=false);
  
  bool isModel(void) const {return ((this->give_classid() == classModel) ? true : false); }
  bool isMesh (void) const {return ((this->give_classid() == classMesh)  ? true : false); }
  
  void assign_NodeLoad_by_point_ID    (const BoundaryCond* bc, long id);
  void assign_NodeLoad_by_point_prop  (const BoundaryCond* bc, long prop);
  void assign_NodeLoad_by_point_coords(const BoundaryCond* bc, const PoinT *coords);
  void assign_BodyLoad_by_elem_ID     (const BoundaryCond* bc, long id);
  void assign_BodyLoad_by_elem_prop   (const BoundaryCond* bc, long prop);
  void assign_EdgeLoad_by_elem_ID     (const BoundaryCond* bc, long id, int indx=-1);
  void assign_EdgeLoad_by_elem_prop   (const BoundaryCond* bc, long prop);
  void assign_FaceLoad_by_elem_ID     (const BoundaryCond* bc, long id, int indx=-1);
  void assign_FaceLoad_by_elem_prop   (const BoundaryCond* bc, long prop);
  void assign_FaceLoad_by_face_prop   (const BoundaryCond* bc, long prop);
  
  
  //
  void join_geom (Geometry *geom);
  
  bool give_3Delement_with_point_inside (const PoinT *coords, const GeometryComponent *&comp, PoinT *nc) const;
  //
  DOFsPerNode give_DOFsPerNode (void);
  // @}
};


//*  ********************************************************************************************
//*  *** *** *** ***                         CLASS MODEL                          *** *** *** ***
//*  ********************************************************************************************
class Model : public Geometry
{
  //  *********************************
  //  /**   @name GENERAL METHODS   **/
  //  *********************************
  //  @{
 public:
  Model (long gid, const Problem *p, MMprocessing mmp);
  virtual ~Model (void);
  virtual classID give_classid() const { return classModel; }
  
  
  //*  *** GET ***
  long give_Nv (void) const { return Pjnts(); }
  const Vertex*   give_Vertex   (long i) const { return ((const Vertex*)  Pjnts[i]); }
  long give_Ng (void) const { return Elems(); }
  const Gelement* give_Gelement (long i) const { return ((const Gelement*)Elems[i]); }
  
  //*  *** READ ***
  void read_model_polylines (const char *path, const char *filename);
  void read_model_MELNIK (void);
  
  void transform_to_mesh     (void);
  void generate_mesh_RFbyHN  (void);
  void generate_mesh_primary (void);
  virtual void print_control (FILE *stream) const { }
  const GeometryComponent* give_masterel (int mydim, int mastertype, long masterID) const;
  
  //*  *** READ ***
  Point* allocate_point (long gid, const PoinT *coo, char attribs_alloc='n');
  //Element* allocate_Element (long gid, long oid, long dom, long lid, const GeometryComponent *masterel=NULL);
  //void findRANofSkewLines (const Beam *b1, const Beam *b2);
  void findRANofSkewLines (void);
  // @}
};



//*  ********************************************************************************************
//*  *** *** *** ***                         CLASS FEMESH                         *** *** *** ***
//*  ********************************************************************************************
class Mesh : public Geometry
{
  //  ******************************
  //  /**   @name GENERAL INFO   **/
  //  ******************************
  //  @{
 private:
  const Model *Master;     // mesh is generated from Master model
  
 public:
  //*  *** SET ***
  void set_Master_model (const Model *M) { Master = M; }
  const Model* give_Master_model(void) const { return Master ? Master : NULL; }
  
  
 protected:
  bool Parallel;
  long NumDomains;                  //
  long *NumNodes, *NumElems;        // parallel
  
  long cSubDomains;                 // count of SubDomains = kusy site ktere nejsou propojene
  long *cNodesInSD;                 // count nodes in subdomains
  
  Solver rslts_solver;              // type of solver
  long   rslts_nsteps;              // number of printed steps
  Lvctr *rslts_step;                // id of step
  Dvctr *rslts_loadlevel;           // reached load level
  double critical_coeff;            // critical load coefficient
  
  bool RTN[cRTN];                   // array with ResultTypesAtNode
  bool RTE[cRTE];                   // array with ResultTypesAtElem
  
  long nRegions;                    // number of adaptivity regions
  
  
 public:
  //*  *** SET ***
  long NumNodes_plus (long i) { return NumNodes[i]++; }
  void set_RTN(ResultTypesAtNode rt, bool val) { RTN[rt] = val; }
  void set_RTE(ResultTypesAtElem rt, bool val) { RTE[rt] = val; }
  
  //*  *** GET ***
  bool give_Parallel      (void) const { return Parallel;   }
  long give_NumDomains    (void) const { return NumDomains; }
  long give_NnAtDom (int did) const { return ( Parallel ? NumNodes[did] : Pjnts() ); }
  long give_NeAtDom (int did) const { return ( Parallel ? NumElems[did] : Elems() ); }
  
  long        give_cSubDomains (void) const { return cSubDomains; }
  const long* give_cNodesInSD  (void) const { return cNodesInSD; }
  
  Solver    give_rslts_solver(void) const { return rslts_solver; }
  //femFileFormat give_rslts_format(void) const { return rslts_format; }
  long      give_rslts_nsteps(void) const { return rslts_nsteps; }
  
  long give_nRegions(void) const { return nRegions; }
  
  
  // vem kod z  void LocalCoordSystem :: initialize (Geometry *geom)
  const Node* give_Node_with_prop (long prp, bool unique) const {
    return (const Node*)this->give_Pjnt_with_prop(prp, unique);
  }
  
  void add_another_Element (FElement *elem, long dom);
  // @}
  
  
  //  ***************************
  //  /**   @name MESH DATA   **/
  //  ***************************
  //  @{
 private:
  Node*     Nodes  (long i) const { return ((Node*)    Pjnts[i]); }
  FElement* FElems (long i) const { return ((FElement*)Elems[i]); }
  
 public:
  //*  *** GET ***
  long give_Nn  (void) const { return Pjnts(); }
  const Node*     give_Node (long i) const { return ((const Node*)Pjnts[i]); }
  const FElement* give_FElem(long i) const { return FElems(i); }
  
  //*  *** EDIT ***
  // KILL ELEMENTS marked by flag "delete" ;  KILL = invisible + delete
  //void kill_damned_elems (void);
  // let off atributes arrays
  //void letoff_aa (void);
  // @}
  
  
  //  ****************************
  //  /**   @name MESH STATS   **/
  //  ****************************
  //  @{
  //  statistiky se musi prepocitat po kazde zmene site neby vynulovat lepe
  
 private:
  GPA<Lvctr>  Lata;
  GPA<Dvctr>  Data;
  GPA<const Dvctr> pLata;
  GPA<const Dvctr> pData;
  // @}
  
  
  //  *********************************
  //  /**   @name GENERAL METHODS   **/
  //  *********************************
  //  @{
 public:
  Mesh (long gid, const Problem *p, long numdom, MMprocessing mmp);
  virtual ~Mesh (void);
  
  virtual classID give_classid() const { return classMesh; }
  virtual void initialize (void);
  virtual void checkConsistency (void) const;
  
  
  //*  *** READ ***
  Point* allocate_point (long gid, const PoinT *coo, char attribs_alloc='n');
  //Element* allocate_Element (long gid, long oid, long dom, long lid, const GeometryComponent *masterel=NULL);
  void read_mesh_ANSYS    (char *path, const char *filename);
  void read_mesh_T3d      (char *path, const char *filename);
  void read_mesh_JKTK     (char *path, const char *filename);
  void read_mesh_OOFEM    (FILE *stream, long nn, long ne);
  void read_mesh_SIFEL    (FILE *stream);
  void read_mesh_UNV      (char *path, const char *filename);
  void read_mesh_VLNA     (char *path, const char *filename);
  void read_mesh_equal_to_model (void);
  
  void read_structural_analysis_output (void);
  void read_output_OOFEM  (void);
  void read_output_SIFEL  (void);
  
  
  void find_slaves (void);
  void cleanup_duplicities (void);
  void check_duplicity_nodes (void);
  
  void mesh_quality (void) const;
  
  void RIGIDmatToRAN(void);
  
  void find_subdomains (void);
  void delete_subdomains_except (long leave);
  
  // vlna
  //void vlna (void);
  //void delete_cmfrs (void);
  
  void sort_polydata (Xvctr *data) const;
  
  //void shake_nodes (void);
  //void shake_elements (void);
  
  //*  ***   print VTK   ***
  void print_VTK_nodes (Stream *stream) const;
  void print_VTK_elems (Stream *stream, VTKdataset ds) const;
  void print_VTK_body  (Stream *stream, VTKdataset ds) const;
  
  
  void print_VTK_PD_scal (bool xml, const char *suff, const char *name, const Xvctr **data);
  void print_VTK_CD_scal (bool xml, const char *suff, const char *name, const Xvctr **data) const;
  void print_VTK (femFileFormat format, const char *suff);
  void print_JKTK (femFileFormat format, const char *suff);
  
  void print_block_nodes (FILE *stream, femFileFormat fff, int did);
  void print_block_supported_dofs (FILE *stream, femFileFormat fff, int did);
  void print_block_elems (FILE *stream, femFileFormat fff, int did);
  void print_block_nodal_load (FILE *stream, femFileFormat fff, int did);
  void print_block_gravity_load_ANSYS (FILE *stream) const;
  
  void resize_Lata (long newsize);
  void resize_Lata_members (long newsize);
  void resize_Data (long newsize);
  void resize_Data_members (long newsize);
  
  void print_control (FILE *conout) const;
  void print_data_ready_vtk (void);
  void print_results  (void);
  void print_cabletensileonly       (bool mft=true);
  void print_characteristics_to_VTK (bool mft=true);
  
  void adaptivity (void);
#ifdef __MEER_MODULE
  void regions_init (void);
#endif
  
  // temp
  double volume_core (void) const;
  // @}
};

} // namespace midaspace

#endif // MIDAS_GEOMETRY_H