point.h

Go to the documentation of this file.

#ifndef MIDAS_POINT_H
#define MIDAS_POINT_H

#include "alias.h"
#include "geomcomp.h"
#include "cell.h"

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


namespace midaspace {

//*  ********************************************************************************************
//*  *** *** *** ***                         CLASS POINT                          *** *** *** ***
//*  ********************************************************************************************
class Point : public GeometryComponent
{
 protected:
  PoinT coords;         // cartesian coordinates of node
  long subdom;          // number of parent subdomain, counting from 0

  // tady je otazka: kdyz je model slozenej jen z jednoho prutu, kterej je rozmeshovanej na dalsi uzly a pruty
  // tak novej uzel bude mit property zdedenou z model prutu, JAKA to bude property? volume nebo edge
  // zatim nejsem rozhodlej
  // tak zatim predpokladam ze to bude volume, tim padem edge by mela byt stejna...
  Lvctr eproperty;      // edge-property
  Lvctr fproperty;      // face-property
  Lvctr vproperty;      // volume-property
  
 public:
  long give_property (void) const;
  long give_property (int dim, long id) const;
  void set_property  (int dim, long val);
  void reset_property  (int dim, long val);
  void add_property  (int dim, long val);
  
  
 protected:
  GPA<const Edge   > superedges;   // array of pointers to superior/owner edges
  GPA<const Face   > superfaces;   // array of pointers to superior/owner faces
  GPA<const Element> superelems;   // array of pointers to superior/owner elements
  
  Point *duplmaster;      // this node has same coords with master
  
  
 public:
  void attributes_allocation (char attflag, const Attributes *masterat);
  DOFsPerNode give_DOFspnod (void) const;
  
  
  //*  *****************************
  //*  ***    GENERAL METHODS    ***
  //*  *****************************
 public:
  Point (const Geometry *owner, long gid, const PoinT *coo, char attflag);
  Point (const Point *src, char attflag);
  virtual ~Point();
  
  virtual classID give_classid() const = 0;
  virtual void initialize (void);
  virtual void finitialize (void);
  virtual void checkConsistency (void) const;
  
 protected:
        PointAttribs *pointAttribs()       { return (PointAttribs*)attributes; }
  const PointAttribs *pointAttribs() const { return (PointAttribs*)attributes; }
  
 public:
  //*  *** SET ***
  void set_subdom (long val) { subdom = val; }
  //*  *** GET ***
  const PoinT* give_coords (void) const { return &coords; }
  double give_coord (int i) const { return coords[i]; }
  long give_subdom (void) const { return subdom; }
        PointAttribs *give_pointAttribs (void)       { return (PointAttribs*)attributes; }
  const PointAttribs *give_pointAttribs (void) const { return (PointAttribs*)attributes; }
  
  
  //*  *** SET ***
  void setadd_superedge (const Edge    *comp, bool uniquecheck) { if (uniquecheck) superedges.add_unique(comp); else superedges.add(comp); }
  void setadd_superface (const Face    *comp, bool uniquecheck) { if (uniquecheck) superfaces.add_unique(comp); else superfaces.add(comp); }
  void setadd_superelem (const Element *comp, bool uniquecheck) { if (uniquecheck) superelems.add_unique(comp); else superelems.add(comp); }
  void remove_superedge (const Edge    *comp)                   {                  superedges.free_ptr(comp);  superedges.shake_down(); }
  void remove_superface (const Face    *comp)                   {                  superfaces.free_ptr(comp);  superfaces.shake_down(); }
  void remove_superelem (const Element *comp)                   {                  superelems.free_ptr(comp);  superelems.shake_down(); }
  void delete_connectivity (void) { superedges.resize_zero();  superfaces.resize_zero();  superelems.resize_zero(); }
  //*  *** GET ***
  long                   give_numsuperedge (void)   const { check_connectivity(); return superedges(); }
  long                   give_numsuperface (void)   const { check_connectivity(); return superfaces(); }
  long                   give_numsuperelem (void)   const { check_connectivity(); return superelems(); }
  const Edge*               give_superedge (long i) const { check_connectivity(); return superedges[i]; }
  const Face*               give_superface (long i) const { check_connectivity(); return superfaces[i]; }
  const Element*            give_superelem (long i) const { check_connectivity(); return superelems[i]; }
  const GPA<const Edge   >* give_superedges (void)  const { check_connectivity(); return &superedges; }
  const GPA<const Face   >* give_superfaces (void)  const { check_connectivity(); return &superfaces; }
  const GPA<const Element>* give_superelems (void)  const { check_connectivity(); return &superelems; }
  const Edge* give_superedge (long nn, const Point **nods) const;
  
 public:
  void setup_duplicity_master (Point *val) { duplmaster = val; }
  bool is_duplicated (void) const { return ( duplmaster ? 1 : 0 ); }
  // Node* give_duplicity_master (void)     { return duplmaster; }
  void make_invisible (Point *master, bool duplcheck);
 protected:
  void integrate_duplicated_point (Point *slave);
 public:
  // invisible superior Cell
  virtual bool invisible_duplicated (char flag='a');
  
  bool is_identical_to (double norm, const PoinT *point) const { return coords.is_identical_to(point, norm*ZERO); }
  
  bool is_on_3d_element (void) const;
  
  //*  *** READ ***
  
  //*  *** PRINT ***
  void print_row_VTK (FILE *stream) const;
  void print_row_VTX (char *str) const;
};


//*  ********************************************************************************************
//*  *** *** *** ***                         CLASS VERTEX                         *** *** *** ***
//*  ********************************************************************************************
class Vertex : public Point
{
 public:
  Vertex (const Geometry *owner, long gid, const PoinT *coo, char attflag='!');
  virtual ~Vertex();
  
  virtual classID give_classid() const { return classVertex; }
  virtual void initialize (void);
  virtual void checkConsistency (void) const { Point :: checkConsistency(); }
  
  virtual bool invisible_duplicated (char flag) { errol; return false; }
  
  //*  *** PRINT ***
  virtual void print_row (FILE *stream, femFileFormat fff, bool endline=true, long did=0) const;
};


//*  ********************************************************************************************
//*  *** *** *** ***                          CLASS NODE                          *** *** *** ***
//*  ********************************************************************************************
class Node : public Point
{
 protected:
  //*  *** PARALLEL ONLY ***
  //  pokud je node sharovanej, tak v cdom je pocet domen na kterych lezi
  //   lid delky NumDomains obsahuje local id pro danou domenu nebo -1 pokud v ni nelezi
  //  pokud neni sharovanej, tak cdom=-dom, kde dom je domena na ktere node lezi
  //   lid je delky 1 a je na v nem lid pro domenu "dom"
  long cdom;             // number domains (-NumDomains;0> & <2;NumDomains>
  long *lid;             // local identification number of node
  //*  *** PARALLEL ONLY ***
  
  const Vertex   *mdl_masterex;
  const Gelement *mdl_masterel;
  const Facedge  *mdl_masteref;
  
  //*  *******************
  //*  ***   RESULTS   ***
  //*  *******************
 private:
  Array1d ***resultsN; // nodes - native for nodes
  
 private:
  Array ****resultsE; // elemns - interpolated from elements/IPs
  
  
 public:
  //*  *** ALLOC ***
  void allocate_resultsN (void);
  void allocate_resultsE (long regid);
  //*  *** SET ***
  void add_resultN (               Xvctr *rslt,             long step, ResultTypesAtNode rt);
  void set_resultN (long s, const double *rslt,             long step, ResultTypesAtNode rt);
  void set_resultN (        const double  rslt,             long step, ResultTypesAtNode rt);
  void add_resultE (               Dvctr *rslt, long regid, long step, ResultTypesAtElem rt);
  void set_resultE (        const  Dmtrx *rslt, long regid, long step, ResultTypesAtElem rt);
  void set_resultE (        const VectoR *rslt, long regid, long step, ResultTypesAtElem rt);
  //*  *** GET ***
  const Dscal* give_resultsN_ds (            long step, ResultTypesAtNode rt) const;
  const Dvctr* give_resultsN_dv (            long step, ResultTypesAtNode rt) const;
  //
  const Dvctr* give_resultsE_dv (long regid, long step, ResultTypesAtElem rt) const;
  const Dmtrx* give_resultsE_dm (long regid, long step, ResultTypesAtElem rt) const;
  //
  //double give_displ (int i, int j) const { return displ[i][j]; }
  void setup_full_alloc_DOFvals_at (Dvctr *d, ResultTypesAtNode rt, long step) const;
  void give_displcmnt_in_all_steps(Dvctr *data, int indx) const;
  
 public:
  Node (const Geometry *owner, long gid, const PoinT *coo, char attflag='n');

  Node (const Vertex *src, char attflag);
  Node (const Node *src, char attflag);
  virtual ~Node();
  
  virtual classID give_classid() const { return classNode; }
  virtual void initialize (void);
  virtual void checkConsistency (void) const;
  
  //
  const Mesh* Msh(void) const { return (Mesh*)Geom; }
  
  virtual void set_model_prop (long val, const Model *model, bool flag=false) {errol;}
  void set_master_component (long prop, const Model *model, int parenttype);
  
  PointAttribs* release_attributes (void) { Attributes *na = this->attributes;  this->attributes = NULL;  return (PointAttribs*)na; }
  void assign_attributes (PointAttribs *na) { if (this->attributes) errol;  this->attributes = na; }
  
  //*  *** GET ***
  bool is_shared (void) const { return ( cdom < 1 ? false : true ); }
  long give_cdom (void) const { return ( cdom < 1 ? 1 : cdom ); }
  long give_domain (void)     const { if (cdom<1) return -cdom; else _errorr ("huhu"); return 0; }
  long give_lid_id (long dom) const { if (Parallel()) return give_lid(dom); else return ID; }
  long give_lid (long dom) const
  {
    if (!Parallel())
      _errorr ("There no lid for non-Parallel analysis");
    if      (cdom>1)     return lid[dom];
    else if (cdom==-dom) return lid[0];
    else return -1;
  }
  const Vertex*            give_mdl_masterex (void) const { return                                     mdl_masterex                                    ; }
  const Gelement*          give_mdl_masterel (void) const { return                                                                        mdl_masterel ; }
  const GeometryComponent* give_mdl_master   (void) const { return (mdl_masterex ? (GeometryComponent*)mdl_masterex : (GeometryComponent*)mdl_masterel); }
  
  virtual const char* give_node_name (void) const { return "Node"; }
  
  const LCS_pure* give_mdl_lcs (void);
  
  void initialize_domli (bool shared, long dom, long li);
  void initialize_BC (int nd, int *bc);
  void initialize_parallel (long nd, long *dom);
  void add_domain (long gid, const char *&str, femFileFormat fff, bool shared, long dom, long li);
  void add_me_to_domain (long did);
  
  // find parent subdomain
  bool find_parent_subdom (long sdid, long *nn, long *level);
  double give_ssstate (Dvctr *data, SStype SST, RVType rvtype, char type, long step);
  
  //*  *** READ ***
  void read_input (const char *&str, femFileFormat fff);
  void read_output_OOFEM (FILE *stream, long step, ResultTypesAtNode rt);
  void read_output_SIFEL (FILE *stream, long step, ResultTypesAtNode rt);
  
  //*  *** PRINT ***
  virtual void print_row (FILE *stream, femFileFormat fff, bool endline=true, long did=0) const;
  //void         print_row_VTK   (FILE *stream) const;
  //void         print_row_VTX   (char *str) const;
};


//*  ********************************************************************************************
//*  *** *** *** ***                      CLASS HANGINGNODE                       *** *** *** ***
//*  ********************************************************************************************
class HangingNode : public Node
{
 public:
  HangingNode (const Mesh *owner, long gid, const PoinT *coo=NULL) : Node (owner, gid, coo, 'h') { }
  HangingNode (const Node *src, bool att_alloc=true) : Node (src, att_alloc ? 'h' : '-') { }
  
  virtual classID give_classid() const { return classHangingNode; }
  virtual void initialize (void);
  virtual void checkConsistency (void) const;
  
  const HNAttribs* give_HNattrb (void) const { return (HNAttribs*)attributes; }
  virtual const char* give_node_name (void) const { return "HangingNode"; }
  
  void initialize_masters_at_domains (void);
  void initialize_hn (const PoinT *cartcoord, const Cell *mc, long dimMC, long ordMC, long countMN, const Node **nodes, const PoinT *natcoord);
  
  //*  *** READ ***
  //virtual void read_OOFEM_input (const char *str);
  
  //*  *** PRINT ***
  void print_one_row_HN (FILE *stream, long hid) const;
};


//*  ********************************************************************************************
//*  *** *** *** ***                      CLASS RIGIDARMNODE                      *** *** *** ***
//*  ********************************************************************************************
class RigidArmNode : public Node
{
 public:
  RigidArmNode (const Mesh *owner, long gid, const PoinT *coo=NULL) : Node (owner, gid, coo, 'r')  {
    //if (this->give_mproperty() > 9999999) _errorr0;
  }
  RigidArmNode (const Node *src, bool att_alloc=true) : Node (src, att_alloc ? 'r' : '-') { }
  
  virtual classID give_classid() const { return classRigidArmNode; }
  virtual void initialize (void);
  virtual void checkConsistency (void) const;
  
  virtual const char* give_node_name (void) const { return "RigidArmNode"; }
  
  //const Node* give_RANmaster (void) const;
  
  //virtual void print_row_OOFEM (FILE *stream, long did, char flag='a') const;
  //long property2;      // second property, pomocna, zadava se jako property*10000+property2
  //long prpos2;  // prpos = position of node in rigidarm node property array Pd->cRANprop
  //*  *** GET ***
  //long give_property2 (void) const { return property2; }
  //int  give_prpos2    (void) const { return prpos2;    }
  
  //bool hasProperty (long prop) { if (prop==property || prop==property2) return true; else return false; }
  //bool hasProperty (long prop) { return (prop==property) ? true : false; }
  
};

} // namespace midaspace

#endif // MIDAS_POINT_H