attribute.h

Go to the documentation of this file.

#ifndef MIDAS_ATTRIBUTE_H
#define MIDAS_ATTRIBUTE_H

#include "alias.h"
#include "substructs.h"

#include "gelib.h"
#include "librw.h"
#include "mathlib.h"


namespace midaspace {

// ********************************************************************************************
// *** *** *** ***                       CLASS ATTRIBUTE                        *** *** *** ***
// ********************************************************************************************
class Attribute : public ProblemSubject
{
 protected:
  long  sifid;        // sifel local id [SIFEL]
  char *linerec;      // line record of characteristics in string
  
 public:
  Attribute (const Problem *pd, long gid) : ProblemSubject (gid, pd) { sifid = -1;  linerec = NULL; }
  virtual ~Attribute() { deallocateCheck(linerec, false); }
  
  virtual classID give_classid() const { return classAttribute; }
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true) { SP_scan_line_alloc(str, linerec);  return true; }
  
  long give_sifid (void) const { return sifid; }
  
  void scan_linerec (const char *str);
  void print_linerec (FILE *stream, bool pure) const;
  virtual void print_row (FILE *stream, femFileFormat fff, long did) const { fprintf(stream, "%s\n", linerec); }
};


// ********************************************************************************************
// *** *** *** ***                   CLASS LOAD TIME FUNCTION                   *** *** *** ***
// ********************************************************************************************
class LoadTimeFunction : public Attribute
{
 public:
  LoadTimeFunction (const Problem *pd, long i) : Attribute (pd, i) { }
  virtual ~LoadTimeFunction() { }
  
  virtual void checkConsistency (void) const
  {
    Attribute :: checkConsistency();
    
    if (this->give_ID() == 0) {
      const char *str = linerec;
      if ( ! SP_scan_expected_word (str, "ConstantFunction", CASE)  ||
       ! SP_scan_expected_word (str, "1"               , CASE)  ||
       ! SP_scan_expected_word (str, "f(t)"            , CASE)  ||
       ! SP_scan_expected_word (str, "1.0"             , CASE) )
    _errorr ("The first LTF is not constant 1 1.0");
    }
  }
  
  void initialize_first (void)
  {
    linerec = new char[28];
    sprintf (linerec, "ConstantFunction 1 f(t) 1.0");
  }
};


// ********************************************************************************************
// *** *** *** ***                    CLASS PROBLEMANALYSIS                     *** *** *** ***
// ********************************************************************************************
class ProblemAnalysis : public Attribute
{
 protected:
  PAGroup group;          // group of problem == mechanics x transport
  PAType  type;           // global type of problem analysis
  PAType  loctype;        // local  type of problem analysis
  
  long nsteps;            // number of steps
  long nroots;            // number of eigenvalues
  double tolerance;       // tolerance
  
  AdaptivityParameters *adpa; // adaptivity parameters
  
  int transpmatter, mediumname;                       // 
  double scaleofmed1, scaleofmed2;                    // 
  int compder1[3], compder2[3];                       // compute 1.derivative (strain/gradients), 2.derivative (stress/flux)
  int compoth1[3], compoth2[3];                       // compute other                            boundary/eqother (reactions/...)
  int gravity;                                        // gravity in transport problem
  int stoch, homog, renumb;                           // stochastic, homogenization, renumbering [SIFEL]
  int timecontrtype, nit, tfunct;
  double start_time, end_time, timef;                 //
  
  StiffMatrixType stiffmattype;                       // type of storage of stiffness matrix
  LinearSolverType linsoltype;                        // type of solver of system of linear equations
  
  
 public:
  ProblemAnalysis (const Problem *pd) : Attribute (pd, 0) {
    group = PAG_mechanics;
    type = loctype = PAT_static_linear;
    nsteps = 1;
    nroots = 1;
    tolerance = 1.0e-6;
    adpa = NULL;
    
    transpmatter = mediumname = 1;  scaleofmed1 = scaleofmed2 = 1.0;
    compder1[0] = compder2[0] = compoth1[0] = compoth2[0] = 0;
    stoch = homog = renumb = 0;
    stiffmattype = SMT_tangent;
    linsoltype = LST_ldl;
  }
  virtual ~ProblemAnalysis() { delete adpa; }
  
  virtual classID give_classid() const { return classProblemAnalysis; }
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true);
  ;       bool initialize_from (FILE *stream,     femFileFormat fff);
  //virtual void initialize (void);
  
  // // *** GET ***
  PAGroup give_group  (void) const { return group; }
  PAType  give_type   (void) const { return type; }
  PAType  give_loctype(void) const { return ( (type == PAT_OOFEM) ? loctype : type); }
  long    give_nsteps (void) const { return nsteps; }
  
  // *** SET ***
  // void set_type3d (void) { type = CST_3d; }
  // void set_lcs (LCSdirection dir, LCStype typ, long num) { if (lcs) _errorr("e");  lcs = new LocalCoordSystem(dir, typ, num); }
  
  // docasne
  void set_stability (void) { type = PAT_stability_linear; }
  
  void print_row_OOFEM (FILE *stream) const;
  void print_block_SIFEL (FILE *stream) const;
};


// ********************************************************************************************
// *** *** *** ***                      CLASS CROSSSECTION                      *** *** *** ***
// ********************************************************************************************
class CrossSection : public Attribute
{
 protected:
  // type == CST_OOFEM && loctype == CST_LayeredCS  - u OOFEMrec zjistim, ze to je typu CST_LayeredCS; pokud rozparsuju cely record, tak se type zmeni na prislusny CST_2d nebo CST_Beam ...
  // type == CST_Truss | CST_2d | CST_3d ...
  // type == CST_Beam  &&  loctype == CST_Rectangle ...
  CrossSectType type;    // global type of cross section
  CrossSectType loctype; // local  type of cross section
  
  // rozmery
  double width, height;  // dimension in direction of axis y and z
  double thickness;      // thickness
  bool   tube;           // 
  //
  double bsc;            // beam shear coefficient
  bool   cable;          // 
  
  // spocitatelne veliciny
  double area;           // area
  double Iy, Iz, Ik;     // 
  
  // zadani
  LCS_beam *lcs;         // reference node, for [Li]BeamXd elements for OOFEM
  
  // layers
  int nlayers;           //
  GPA<const Material> mats;
  
  
 public:
  CrossSection (const Problem *pd, long i) : Attribute (pd, i) {
    type = loctype = CST_Void;
    width = height = thickness = area = Iy = Iz = Ik = bsc =  -1.0;
    tube = cable = false;  lcs = NULL;  nlayers = 0;
  }
  virtual ~CrossSection() { delete lcs; }
  
  virtual classID give_classid() const { return classCrossSection; }
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true);
  virtual void initialize (void);
  
  // *** GET ***
  CrossSectType           give_type      (void) const { return type; }
  //CrossSectType           give_loctype   (void) const { return loctype; }
  CrossSectType   give_loctype_or_type   (void) const { return ( loctype ? loctype : type ); }
  const LCS_beam* give_lcs       (void) const { return lcs; }
  double          give_area      (void) const { return area; }
  double          give_width     (void) const { return width; }
  double          give_height    (void) const { return height; }
  double          give_thickness (void) const { return thickness; }
  double          give_Iy        (void) const { return Iy; }
  double          give_Iz        (void) const { return Iz; }
  int             give_nlayers   (void) const { return nlayers; }
  const Material* give_mat       (int i) const { return mats[i]; }
  
  // *** SET ***
  void set_type3d (void) { type = CST_3d; }
  void set_lcs (LCSdirection dir, LCStype typ, long num) { if (lcs) _errorr("e");  lcs = new LCS_beam(dir, typ, num); }
  
  void add_areaYyYz (double w, double h);
  
  virtual void print_row (FILE *stream, femFileFormat fff, long did) const;
};


// ********************************************************************************************
// *** *** *** ***                        CLASS MATERIAL                        *** *** *** ***
// ********************************************************************************************
class Material : public Attribute
{
 protected:
  MaterialType type;    // global type of material
  MaterialType loctype; // local  type of material
  double density;       // density
  double E;             // Young's modulus
  double ny;            // Poisson's ratio
  double tAlpha;        // 
  double Ry;            // plasticity
  double IHM;           // isotropicHardening
  double Capac;         // capacity
  double Conduct;       // conductivity
  
 public:
  Material (const Problem *pd, long i) : Attribute (pd, i) {
    type = loctype = MAT_Void;
    density = E = ny = tAlpha = Ry = IHM = 0.0;
  }
  virtual ~Material() { }
  
  virtual classID give_classid() const { return classMaterial; }
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true);
  virtual void initialize (void) {
    Attribute :: initialize();
    if (type == MAT_RIGID && !Pd->give_PDBO(PDBO_RIGIDmatToRAN))  _errorr("Don't you want to use -P_RigidBodyToRigidArm parameter? I am sure you do!"); // musis naimplementovat rigidni material == s velikym E
  }
  
  // *** GET ***
  MaterialType give_type    (void) const { return type; }
  MaterialType give_loctype (void) const { return ( (type == MAT_OOFEM  ||  type == MAT_SIFEL) ? loctype : type); }
  double       give_Ry      (void) const { return Ry; }
  bool isOOFEMplast (void) const { return (loctype == MAT_j2mat); }
  
  virtual void print_row (FILE *stream, femFileFormat fff, long did) const;
};


// ********************************************************************************************
// *** *** *** ***                   CLASS BoundaryCondition                    *** *** *** ***
// ********************************************************************************************
class BoundaryCond : public Attribute
{
 protected:
  BCType type;          // global type of boundary condition
  BCType loctype;       // local  type of boundary condition
  int ncomp;            // number of components
  double *components;   // main values
  long ltf;             // load time function [OOFEM]
  bool constant;        // constant over the whole element
  DOFsPerNode dpn;      // dofs per node
  const BoundaryCond* bcbr;  // same bc with different dpn; different DOFs are zero
  
 public:
  BoundaryCond (const Problem *pd, long i) : Attribute (pd, i) {
    type = loctype = BC_Void;
    ncomp = 0;   components = NULL; // new double[n];
    ltf=1;
    constant = true;
    dpn = DPN_Void;
    bcbr = NULL;
  }
  virtual ~BoundaryCond() { delete [] components; }
  bool is_identical_with (BoundaryCond *val) const {
    if (type     != val->type    ||
    loctype  != val->loctype ||
    ncomp    != val->ncomp   ||
    ltf      != val->ltf     ||
    constant != val->constant ||
    dpn      != val->dpn    )  return false;
    
    for (int i=0; i<ncomp; i++)
      if (! isZero (1.0e-5*components[i], components[i] - val->components[i]))
    return false;
    
    return true;
  }
  void copy_bcbr (const BoundaryCond* bc, DOFsPerNode dpn_old, DOFsPerNode dpn_new)
  {
    ((BoundaryCond*)bc)->set_bcbr(this);
    this->set_bcbr(bc);
    
    type     = bc->type;
    loctype  = bc->loctype;
    ltf      = bc->ltf;
    constant = bc->constant;
    
    if (dpn_old != DPN_DxyzRxyz || dpn_new != DPN_DxyzR___) errol;
    
    dpn      = dpn_new;
    ncomp    = 3;
    components = new double[3];
    components[0] = bc->components[0];
    components[1] = bc->components[1];
    components[2] = bc->components[2];
    
    if (bc->components[3] != 0.0 || bc->components[4] != 0.0 || bc->components[5] != 0.0) errol;
  }
  
  virtual classID give_classid() const { return classBoundaryCond; }
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true);
  //virtual void finitialize (void);
  virtual void checkConsistency (void) const;
  
  void initialize_BC_NL_SIFEL(FILE *stream);
  
  // *** SET ***
  void setadd_loctype_sifif (BCType loct, int locid);
  void set_bcbr (const BoundaryCond* bc) { bcbr = bc; }
  // *** GET ***
  BCType give_type     (void)  const { return type; }
  BCType give_loctype  (void)  const { return ( (type == BC_OOFEM  ||  type == BC_SIFEL) ? loctype : type); }
  int    give_ncomp    (void)  const { return ncomp; }
  double give_component(int i) const { return components[i]; }
  DOFsPerNode give_dpn (void)  const { return  ( dpn ? dpn : Pd->give_DOFspnod() ); }
  const BoundaryCond* give_bcbr(void) const { return bcbr; }
  void check_dpn (const DOFsPerNode eldpn) const {
    if (this->give_dpn() == DPN_DxyzRxyz && eldpn == DPN_DxyzR___ && (components[3]+components[4]+components[5]) == 0.0 )
      ;
    else errol;
  }
  
  void initialize_the_first_BC (void);
  
  bool is_the_first_BC (void);
  bool scan_components (FILE *stream, int ncmp) { ncomp = ncmp;  return FP_scan_array (stream, ncomp, components); }
  
  virtual void print_row (FILE *stream, femFileFormat fff, long did) const;
  void print_components_oo (FILE *stream) const;
  void print_components (FILE *stream) const;
};



// ********************************************************************************************
// *** *** *** ***                         CLASS Assign                         *** *** *** ***
// ********************************************************************************************
enum ASGType {
  ASG_non ,     // none
  ASG_prop ,    // property of component (element or node)
  ASG_id ,      // id       of component (element or node)
  ASG_coord ,   // node coord
  ASG_faceprop  // property of surface (of element)
};
// ********************************************************************************************
// *** *** *** ***                         CLASS Assign                         *** *** *** ***
// ********************************************************************************************
class Assign : public GeometrySubject
{
 public:
  Assign (const Problem *pd, long gid) : GeometrySubject (gid, pd) { }
  virtual ~Assign() { }
  
  virtual void initialize (void);
};

// ********************************************************************************************
// *** *** *** ***                      CLASS AssignFix                         *** *** *** ***
// ********************************************************************************************
class AssignFix : public Assign
{
 protected:
  long elemid;             // element id
  ASGType type;            // type of assignment
  bool node;               // type of fixed entity, true == node, false == element
  //
  long ncn;                // count of control numbers
  long *icn;               // control numbers integer
  
 public:
  AssignFix (const Problem *pd, long gid) : Assign (pd, gid) {
    elemid = 0;   type = ASG_non;
    ncn = 0;  icn = NULL;
  }
  virtual ~AssignFix() { delete [] icn; }
  
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true);
  virtual void initialize (void);
  
  //virtual void print_row (FILE *stream, femFileFormat fff, long did) const { _errorr ("empty"); }
};


// ********************************************************************************************
// *** *** *** ***                       CLASS AssignBC                         *** *** *** ***
// ********************************************************************************************
class AssignBC : public Assign
{
  // long id               // id of BC, which should be assigned
 protected:
  const BoundaryCond *bc;  // pointer to boundary condition
  ASGType type;            // type of assignment
  //
  long ncn;                // count of control numbers
  long *icn;               // control numbers integer
  double *fcn;             // control numbers float
  
 public:
  AssignBC (const Problem *pd, long gid) : Assign (pd, gid) {
    bc = NULL;  type = ASG_non;
    ncn = 0;    icn = NULL; fcn = NULL;
  }
  virtual ~AssignBC() {  delete [] icn;  delete [] fcn;  }
  
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true);
  virtual void initialize (void);
  
  virtual void print_row (FILE *stream, femFileFormat fff, long did) const { _errorr ("empty"); }
};


// ***************************
// ***   CLASS ABC_NLOAD   ***  // ***  NL - Nodal Loads  ***
// ***************************
class ABC_NLoad : public AssignBC
{
 public:
  ABC_NLoad (const Problem *pd, long gid) : AssignBC (pd, gid) { }
  virtual ~ABC_NLoad() { }
  virtual classID give_classid() const { return classABC_NLoad; }
  
  virtual void initialize (void);
};

// ****************************
// ***   CLASS ABC_CELOAD   ***  // ***  CEL - Constant Edge Loads  ***
// ****************************
class ABC_CELoad : public AssignBC
{
 public:
  ABC_CELoad (const Problem *pd, long gid) : AssignBC (pd, gid) { }
  virtual ~ABC_CELoad() { }
  virtual classID give_classid() const { return classABC_CELoad; }
  
  virtual void initialize (void);
};

// ****************************
// ***   CLASS ABC_CFLOAD   ***  // ***  CSL - Constant Face Loads  ***
// ****************************
class ABC_CFLoad : public AssignBC
{
 public:
  ABC_CFLoad (const Problem *pd, long gid) : AssignBC (pd, gid) { }
  virtual ~ABC_CFLoad() { }
  virtual classID give_classid() const { return classABC_CFLoad; }
  
  virtual void initialize (void);
};

// ****************************
// ***   CLASS ABC_CBLOAD   ***  // ***  CBL - Constant Body Loads  ***
// ****************************
class ABC_CBLoad : public AssignBC
{
 public:
  ABC_CBLoad (const Problem *pd, long gid) : AssignBC (pd, gid) { }
  virtual ~ABC_CBLoad() { }
  virtual classID give_classid() const { return classABC_CBLoad; }
  
  virtual void initialize (void);
};




// ********************************************************************************************
// *** *** *** ***                       CLASS ATTRIBUTES                       *** *** *** ***
// ********************************************************************************************
class Attributes : public GeomCompSubject
{
 protected:
  long prop;           // property / identification number
  
  GPA<const BoundaryCond> loads;   // pointers to loads = boundary conditions [nLoads ; 1]; see help.txt
                                   // load je kumulativni, je pouze na attributech s ownerem
  
  
 public:
  Attributes (const GeometryComponent *owner, long p) : GeomCompSubject (-1, owner) { prop = p; }
  Attributes (const GeometryComponent *owner, const Attributes *src) : GeomCompSubject (-1, owner) {
    prop = src->prop;
    loads.be_copy_of(&src->loads);
  }
  virtual ~Attributes() { }
  
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true) = 0;
  virtual void print_row (FILE *stream, femFileFormat fff, long did) const = 0;
  
  // *** SET ***
  void set_prop (long val) { prop = val; }
  void add_load (const BoundaryCond *val) { if (!GC) errol;  loads.add(val); }
  void add_load (int i);
  
  // *** GET ***
  long give_prop (void) const { return prop; }
  const GPA<const BoundaryCond>* give_loads (void) const { return &loads; }
            const BoundaryCond * give_load (int i) const { return loads[i]; }
  long give_cloads (void) const { return loads(); }
  bool is_loaded (void) const { return loads(); }
  
};


// ********************************************************************************************
// *** *** *** ***                      CLASS CellAttribs                       *** *** *** ***
// ********************************************************************************************
class CellAttribs : public Attributes
{
 public:
  CellAttribs (const Cell *owner, long p)                 : Attributes ((const GeometryComponent *)owner, p) { }
  CellAttribs (const Cell *owner, const CellAttribs *src) : Attributes ((const GeometryComponent *)owner, src) { }
  virtual ~CellAttribs() { }
};


// ********************************************************************************************
// *** *** *** ***                     CLASS FacedgeAttribs                     *** *** *** ***
// ********************************************************************************************
class FacedgeAttribs : public CellAttribs
{
 protected:
  double elemSize;
  long   elemCount;
  
 public:
  FacedgeAttribs (const Facedge *owner, long p)                    : CellAttribs ((const Cell *)owner, p) { elemSize = 0.0; elemCount = 0; }
  FacedgeAttribs (const Facedge *owner, const FacedgeAttribs *src) : CellAttribs ((const Cell *)owner, src) { elemSize = src->elemSize; elemCount = src->elemCount; }
  virtual ~FacedgeAttribs() { }
  
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true) { errol; return false; }
  virtual void print_row (FILE *stream, femFileFormat fff, long did) const { errol; }
  
  // *** SET ***
  void set_elemSize (double val) { elemSize  = val; }
  void set_elemCount  (long val) { elemCount = val; }
  
  //
  void set_new (const FacedgeAttribs *src);
  
  // *** GET ***
  
  double give_elemSize_loc  (void) const { return elemSize;  }
  long   give_elemCount_loc (void) const { return elemCount; }
  
  double give_elemSize  (void) const;
  double give_elemCount (void) const;
  
};

// ********************************************************************************************
// *** *** *** ***                      CLASS EdgeAttribs                       *** *** *** ***
// ********************************************************************************************
class EdgeAttribs : public FacedgeAttribs
{
 public:
  EdgeAttribs (const Edge *owner, long p)                 : FacedgeAttribs ((const Facedge *)owner, p) { }
  EdgeAttribs (const Edge *owner, const EdgeAttribs *src) : FacedgeAttribs ((const Facedge *)owner, src) { }
  virtual ~EdgeAttribs() { }
  
  virtual void checkConsistency (void) const;
  
  const Edge* owner() const { return (Edge*)GC; } // owner    Edge
};

// ********************************************************************************************
// *** *** *** ***                      CLASS FaceAttribs                       *** *** *** ***
// ********************************************************************************************
class FaceAttribs : public FacedgeAttribs
{
 public:
  FaceAttribs (const Face *owner, long p)                 : FacedgeAttribs ((const Facedge *)owner, p) { }
  FaceAttribs (const Face *owner, const FaceAttribs *src) : FacedgeAttribs ((const Facedge *)owner, src) { }
  virtual ~FaceAttribs() { }
  
  virtual void checkConsistency (void) const;
  
  const Face* owner() const { return (Face*)GC; } // owner    Face
};


enum ElAttLevel { EAL_Void, EAL_direct, EAL_property, EAL_geometry, EAL_subdom, EAL_domain };
// ********************************************************************************************
// *** *** *** ***                     CLASS ELEMENTATTRIBS                     *** *** *** ***
// ********************************************************************************************
class ElemAttribs : public CellAttribs
{
  // Tato trida je postavena tak, ze muze byt ve dvou modech.
  // a) owner == null => genatt == NULL - toto je OBECNY elematt, neni vyhradne prirazen zadnemu elementu
  // b) owner != null --                - toto je OSOBNI elematt nejakeho elementu (ownera)
  //                  -- genatt == NULL - k property ownera neni prirazen obecny elematt
  //                  -- genatt != NULL - k property ownera je   prirazen obecny elematt
 protected:
  ElAttLevel EAL;
  
  const Element* owner() const { return (Element*)GC; } // owner    Element
  const ElemAttribs *Patt;                              // superior element attributes according to property  of owner
  const ElemAttribs *Gatt;                              // superior element attributes according to geometry  of owner
  //const ElemAttribs *Satt;                            // superior element attributes according to subdomain of owner
  const ElemAttribs *Datt;                              // superior element attributes according to    domain of owner
  
  // CellGeometry   cg            = owner->give_cellGeom() 
  DOFsPerNode       dpn;          // dofs per node
  SStype            sst;          // special type of stress/strain state of element
  FEApproximation   approx;       // approximation
  static const int  ord = -4;     // degree of polynomial aproximation on Element      zatim jen nepouzivat, je to tady je abych nezapomel nektere veci az to implementovat budu
  FiniteElementType expltype;    // explicit type of FE
  
  IntPointSet IPset;            // set of integration points
  bool *HNmstr;                 // HN master         : NULL nonactivated, false/true
  bool *nlgeo;                  // nonlinear geometry: NULL nonactivated, false/true
  
  const CrossSection *cs;             // pointer to cross section
  const Material     *mat;            // pointer to material
  //
  // Ted je to debilne. Index edge/face je dany pozici v druhe dimenzi, kde je ale pouze jeden ukazatel nenulovy,
  // idyz dany prvek bude mit vice hran/faces zatizenych stejnym CEL/CSL. Je to dany jednodussim allokovanim add_Ebc
  // Ale ted koukam, ze v sifel.in to tak neni...
  //GPA<GPA<const BoundaryCond> > Ebc;  // pointers to edge boundary conditions [nEbc ; ned ; 1]
  //GPA<GPA<const BoundaryCond> > Fbc;  // pointers to face boundary conditions [nFbc ; nfa ; 1]
  //GPA<    const BoundaryCond>   Bbc;  // pointers to body boundary conditions [nBbc ;       1]
  
  LCS_beam *lcs;                    // local coordinate system, for [Li]BeamXd elements for OOFEM
  Dvctr *MatStiffMtrx;              // Explicit Material Stiffness Matrix
  GPA<PointDOFsCondense> *conDOFs;  // length of gpa is number of nodes; conDOFs[0]==NULL - first node has no condensed dof; more details see help.txt
  
  
 public:
  ElemAttribs (const Element *ow, long p, ElAttLevel eal);
  ElemAttribs (const Element *ow, const ElemAttribs* src, char samegeom);
  virtual ~ElemAttribs();
  
  virtual classID give_classid() const = 0;
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true);
  virtual void initialize (void);
  virtual void finitialize (void);
  virtual void checkConsistency (void) const;
  
  void integrate_duplicated_one (const ElemAttribs *slv);
  
  void EALdirectCheck (void) const { if (EAL != EAL_direct)  _errorr("this attribute container has no owner"); }
  
  // *** SET ***
  void set_Patt   (void);
  void set_FETS   (const FiniteElementTypeSet *val);
  void set_dpn    (DOFsPerNode                 val) { dpn    = val; }
  void set_sst    (SStype                      val) { sst    = val; }
  void set_approx (FEApproximation             val) { approx = val; }
  
  //
  void set_cs  (int i)      { cs  = (i==-1) ? NULL : Pd->give_CS (i);  if (i != -1 && cs == NULL) _errorr2("There is no cross-section with ID = %d",i+1); }
  void set_cs_of_type (CrossSectType type, int id)  { cs  = Pd->give_CS_of_type (type, id); }
  void set_mat (int i)      { mat = Pd->give_Mat(i); if (mat==NULL) _errorr2("There is no material with ID = %d",i+1); }
  void set_load  (int i,                  char flag='\0', int indx=-1);
  void set_load  (const BoundaryCond* bc, char flag='\0', int indx=-1);
  void set_HNmstr (bool val){ if (!HNmstr) HNmstr = new bool; *HNmstr = val; }
  void set_nlgeo (bool val) { if (!nlgeo)  nlgeo  = new bool; *nlgeo  = val; }
  void set_MatStiffMtrx(int n, double *src);
  void set_mat_of_type (MaterialType type, int id)  { mat = Pd->give_Mat_of_type (type, id); }
  //void add_Ebc (int indx, const BoundaryCond *val);
  //void add_Fbc (int indx, const BoundaryCond *val);
  //void add_Ebc (GPA<const BoundaryCond> *val) { Ebc.add(val); }
  //void add_Fbc (GPA<const BoundaryCond> *val) { Fbc.add(val); }
  //void add_Bbc (    const BoundaryCond  *val) { Bbc.add(val); }
  void set_lcs (LCSdirection dir, LCStype typ, long num)            { if (lcs) errol;  lcs = new LCS_beam(dir, typ, num);   }
  void set_lcs (LCSdirection dir, LCStype typ, const double *auxDv) { if (lcs) errol;  lcs = new LCS_beam(dir, typ, auxDv); }
  
  
  // *** GET ***
  
  DOFsPerNode             give_dpn_default (void) const;
  SStype                  give_sst_default (void) const;
  
  DOFsPerNode             give_dpn_loc    (void) const { return dpn;    }
  SStype                  give_sst_loc    (void) const { return sst;    }
  FEApproximation         give_approx_loc (void) const { return approx; }
  FiniteElementType       give_expltype_loc (void) const { return expltype; }
  int                     give_ord        (void) const { return ord;    }
  //
  IntPointSet             give_IPset_loc  (void) const { return IPset;  }
  bool*                   give_HNmstr_loc (void) const { return HNmstr; }
  //
  const CrossSection*     give_cs_loc     (void) const { return cs;     }
  const Material*         give_mat_loc    (void) const { return mat;    }
  //
  const LCS_beam*               give_lcs_loc    (void) const { return lcs;     }
  const GPA<PointDOFsCondense>* give_conDOFs    (void) const { return conDOFs; }
  const     PointDOFsCondense * give_conDOFs    (const Point* p) const;
  //const DOFatt*          give_conDOFs_loc  (void) const { return conDOFs;}
  
  FiniteElementTypeSet* give_FETS (FiniteElementTypeSet *set) const;
  DOFsPerNode           give_dpn    (void) const { EALdirectCheck();  return ( this->give_dpn_loc()    ? this->give_dpn_loc()    : ((Patt && Patt->give_dpn_loc()   ) ? Patt->give_dpn_loc()    : ((Gatt && Gatt->give_dpn_loc()   ) ? Gatt->give_dpn_loc()    : (Datt->give_dpn_loc()    ? Datt->give_dpn_loc()    : this->give_dpn_default())))); }
  SStype                give_sst    (void) const { EALdirectCheck();  return ( this->give_sst_loc()    ? this->give_sst_loc()    : ((Patt && Patt->give_sst_loc()   ) ? Patt->give_sst_loc()    : ((Gatt && Gatt->give_sst_loc()   ) ? Gatt->give_sst_loc()    : (Datt->give_sst_loc()    ? Datt->give_sst_loc()    : this->give_sst_default())))); }
  FEApproximation       give_approx (void) const { EALdirectCheck();  return ( this->give_approx_loc() ? this->give_approx_loc() : ((Patt && Patt->give_approx_loc()) ? Patt->give_approx_loc() : ((Gatt && Gatt->give_approx_loc()) ? Gatt->give_approx_loc() : (Datt->give_approx_loc() ? Datt->give_approx_loc() : FEA_default             )))); }
  FiniteElementType     give_expltype (void) const { EALdirectCheck();  return ( this->give_expltype_loc() ? this->give_expltype_loc() : ((Patt && Patt->give_expltype_loc()) ? Patt->give_expltype_loc() : ((Gatt && Gatt->give_expltype_loc()) ? Gatt->give_expltype_loc() : (Datt->give_expltype_loc() ? Datt->give_expltype_loc() : FET_Void             )))); }
  //
  IntPointSet           give_IPset  (void) const { EALdirectCheck();  return ( this->give_IPset_loc()  ? this->give_IPset_loc()  : ((Patt && Patt->give_IPset_loc() ) ? Patt->give_IPset_loc()  : ((Gatt && Gatt->give_IPset_loc() ) ? Gatt->give_IPset_loc()  : (Datt->give_IPset_loc()  ? Datt->give_IPset_loc()  : IPS_Void                )))); }
  bool                  give_HNmstr (void) const { EALdirectCheck();  return ( this->give_HNmstr_loc() ?*this->give_HNmstr_loc() : ((Patt && Patt->give_HNmstr_loc()) ?*Patt->give_HNmstr_loc() : ((Gatt && Gatt->give_HNmstr_loc()) ?*Gatt->give_HNmstr_loc() : (Datt->give_HNmstr_loc() ?*Datt->give_HNmstr_loc() : false                   )))); }
  //
  const CrossSection*   give_cs     (void) const { EALdirectCheck();  return ( this->give_cs_loc()     ? this->give_cs_loc()     : ((Patt && Patt->give_cs_loc()    ) ? Patt->give_cs_loc()     : ((Gatt && Gatt->give_cs_loc()    ) ? Gatt->give_cs_loc()     : (Datt->give_cs_loc()     ? Datt->give_cs_loc()     : NULL                    )))); }
  const Material*       give_mat    (void) const { EALdirectCheck();  return ( this->give_mat_loc()    ? this->give_mat_loc()    : ((Patt && Patt->give_mat_loc()   ) ? Patt->give_mat_loc()    : ((Gatt && Gatt->give_mat_loc()   ) ? Gatt->give_mat_loc()    : (Datt->give_mat_loc()    ? Datt->give_mat_loc()    : NULL                    )))); }
  //
  const LCS_beam*       give_lcs    (void) const { EALdirectCheck();  return ( this->give_lcs_loc()    ? this->give_lcs_loc()    : ((Patt && Patt->give_lcs_loc()   ) ? Patt->give_lcs_loc()    : ((Gatt && Gatt->give_lcs_loc()   ) ? Gatt->give_lcs_loc()    : (Datt->give_lcs_loc()    ? Datt->give_lcs_loc()    : NULL                    )))); }
  //
  const LCS_beam*       give_lcs_global (void) const { return this->give_lcs() ? this->give_lcs() : (this->give_cs() ? this->give_cs()->give_lcs() : NULL); }
  
  //int                 give_cBbc_loc (void) const { return Bbc(); }
  //int                 give_cFbc_loc (void) const { return Fbc.give_num_nonNULL_ptrs2 (); }
  //int                 give_cEbc_loc (void) const { return Ebc.give_num_nonNULL_ptrs2 (); }
  //int                 give_cBbc     (void) const { return this->give_Bbc() ? (*this->give_Bbc())() : 0; }
  //int                 give_cFbc     (void) const { return this->give_Fbc() ? (*this->give_Fbc())() : 0; }
  //int                 give_cEbc     (void) const { return this->give_Ebc() ? (*this->give_Ebc())() : 0; }
  //int                 give_cBbc_sum (void) const { return Bbc() + (Patt ? Patt->give_cBbc_loc() : 0) + (Gatt ? Gatt->give_cBbc_loc() : 0) + Datt->give_cBbc_loc(); }
  //int                 give_cFbc_sum (void) const { return Fbc() + (Patt ? Patt->give_cFbc_loc() : 0) + (Gatt ? Gatt->give_cFbc_loc() : 0) + Datt->give_cFbc_loc(); }
  //int                 give_cEbc_sum (void) const { return Ebc() + (Patt ? Patt->give_cEbc_loc() : 0) + (Gatt ? Gatt->give_cEbc_loc() : 0) + Datt->give_cEbc_loc(); }
  
  //const GPA<    const BoundaryCond  >* give_Bbc_loc (void) const { return Bbc() ? &Bbc : NULL; }
  //const GPA<GPA<const BoundaryCond> >* give_Fbc_loc (void) const { return Fbc() ? &Fbc : NULL; }
  //const GPA<GPA<const BoundaryCond> >* give_Ebc_loc (void) const { return Ebc() ? &Ebc : NULL; }
  
  //const GPA<    const BoundaryCond  >* give_Bbc     (void) const { return Bbc() ? &Bbc : (Patt && Patt->give_cBbc_loc() ? Patt->give_Bbc_loc() : (Gatt && Gatt->give_cBbc_loc() ? Gatt->give_Bbc_loc() : Datt->give_Bbc_loc() )); }
  //const GPA<GPA<const BoundaryCond> >* give_Fbc     (void) const { return Fbc() ? &Fbc : (Patt && Patt->give_cFbc_loc() ? Patt->give_Fbc_loc() : (Gatt && Gatt->give_cFbc_loc() ? Gatt->give_Fbc_loc() : Datt->give_Fbc_loc() )); }
  //const GPA<GPA<const BoundaryCond> >* give_Ebc     (void) const { return Ebc() ? &Ebc : (Patt && Patt->give_cEbc_loc() ? Patt->give_Ebc_loc() : (Gatt && Gatt->give_cEbc_loc() ? Gatt->give_Ebc_loc() : Datt->give_Ebc_loc() )); }
  
  //const ElemAttribs*              give_Bbc_prnt (void) const { return Bbc() ? this : (Patt && Patt->give_cBbc_loc() ? Patt                 : (Gatt && Gatt->give_cBbc_loc() ? Gatt                 : Datt                 )); }
  //const ElemAttribs*              give_Fbc_prnt (void) const { return Fbc() ? this : (Patt && Patt->give_cFbc_loc() ? Patt                 : (Gatt && Gatt->give_cFbc_loc() ? Gatt                 : Datt                 )); }
  //const ElemAttribs*              give_Ebc_prnt (void) const { return Ebc() ? this : (Patt && Patt->give_cEbc_loc() ? Patt                 : (Gatt && Gatt->give_cEbc_loc() ? Gatt                 : Datt                 )); }
  
  //const BoundaryCond** give_Bbc     (void) const { return (     Bbc ?   Bbc   :         ((Patt && Patt-> give_Bbc_loc()  ) ? Patt-> give_Bbc_loc()   : ((Gatt && Gatt-> give_Bbc_loc()  ) ? Gatt-> give_Bbc_loc()   : Datt-> give_Bbc_loc()  ))); }
  //const BoundaryCond** give_Fbc     (void) const { return (     Fbc ?   Fbc   :         ((Patt && Patt-> give_Fbc_loc()  ) ? Patt-> give_Fbc_loc()   : ((Gatt && Gatt-> give_Fbc_loc()  ) ? Gatt-> give_Fbc_loc()   : Datt-> give_Fbc_loc()  ))); }
  //bool                give_nlgeo (void) const { return (  nlgeo            ? *nlgeo  : (genatt ? genatt->give_nlgeo()  : false)); }
  //const DOFatt*     give_conDOFs  (void) const { return ( conDOFs ?  conDOFs:         ((Patt && Patt->give_conDOFs_loc()) ? Patt->give_conDOFs_loc(): ((Gatt && Gatt->give_conDOFs_loc()) ? Gatt->give_conDOFs_loc(): Datt->give_conDOFs_loc()))); }
  //bool has_lcs(void) { return lcs || ( (cs && cs->give_lcs()) ? true : false ); }
  //bool is_loaded (void) const { return ( this->give_Bbc() || this->give_Fbc() || this->give_Ebc() ); }
  
  void set_fullhinge_at (int point);
  bool has_fullhinge_ends (void) const;
  void switch_dpn_Line (void);
  
  long give_mat_ID (void) { const Material* m = this->give_mat(); return m ? m->give_ID() : -1; }
  
  // *** PRINT ***
  void print_Bbc_SIFEL (FILE *stream) const;
  void print_Fbc_SIFEL (FILE *stream) const;
  void print_Ebc_SIFEL (FILE *stream) const;
};

// ********************************************************************************************
// *** *** *** ***                    CLASS FELEMENTATTRIBS                     *** *** *** ***
// ********************************************************************************************
class FElemAttribs : public ElemAttribs
{
 private:
  const FElement* f_owner() const { return (FElement*)GC; } // owner FElement
  
 public:
  FElemAttribs (const Element *ow, long p, ElAttLevel eal, const Problem *pd=NULL);
  FElemAttribs (const Element *ow, const FElemAttribs *src, char samegeom);
  FElemAttribs (const Element *ow, const GelemAttribs *src, char samegeom);
  virtual ~FElemAttribs();
  
  virtual classID give_classid() const { return classFEelemAttribs; }
  
  virtual void initialize (void);
  
 protected:
  
  virtual void print_row (FILE *stream, femFileFormat fff, long did) const;
};

// ********************************************************************************************
// *** *** *** ***                    CLASS GELEMENTATTRIBS                     *** *** *** ***
// ********************************************************************************************
class GelemAttribs : public ElemAttribs
{
 private:
  PointDOFsBCPM *dofbc;  // DOF boundary conditions - contain ndofs, BC array, DofIDMask array
  bool virt;             // if yes, owner is virtual geometry element only, it will not be meshed; only for assign of dofbc to edge
  
 public:
  GelemAttribs (const Element *ow, long p, ElAttLevel eal) : ElemAttribs (ow, p, eal) { dofbc = NULL; virt = false; }
  GelemAttribs (const Element *ow, const GelemAttribs *src, ElAttLevel eal) : ElemAttribs (ow, src, eal) {
    dofbc = NULL;
    if (src->dofbc) errol;
    if (src->lcs)   errol;
  }
  virtual ~GelemAttribs() { delete dofbc; delete lcs; }
  
  virtual classID give_classid() const { return classGelemAttribs; }
  virtual void checkConsistency (void) const;
  
  //*  *** SET ***
  void set_dofbc_with_ID (int i) {
    dofbc = Pd->give_PV(i);
    if (dofbc == NULL) _errorr2("There is no PV with ID = %d", i+1);
    if (!GC) errol; // docasne
    dofbc = new PointDOFsBCPM((const PointDOFsBCPM*)dofbc, GC);
  }
  void set_nDOFs_BC (int nd, int *bc);
  void set_nDOFs_BC (int nd, long *bc);
  //void set_nDOFs_BC (const PointDOFsBCPM *src);
  void set_virtual  (bool val) { virt = val; }
  // *** GET ***
  const PointDOFsBCPM* give_dofbc   (void) const { return dofbc; }
  bool                 give_virtual (void) const { return virt; }
  
  bool is_supported (void) const {
    const PointDOFsBCPM * dbc = this->give_dofbc(); 
    return dbc ? dbc->is_supported() : false;
  }
  
  virtual void print_row (FILE *stream, femFileFormat fff, long did) const { errol; }
};



// ********************************************************************************************
// *** *** *** ***                      CLASS POINTATTRIBS                      *** *** *** ***
// ********************************************************************************************
class PointAttribs : public Attributes
{
  // Tato trida je postavena tak, ze muze byt ve dvou modech.
  // a) owner == null => genatt == NULL - toto je OBECNY pointatt, neni vyhradne prirazen zadnemu uzlu
  // b) owner != null --                - toto je OSOBNI pointatt nejakeho uzlu (ownera)
  //                  -- genatt == NULL - k property ownera neni prirazen obecny pointatt
  //                  -- genatt != NULL - k property ownera je   prirazen obecny pointatt
 protected:
  const Point* owner() const { return (Point*)GC; }   // owner    Point
  const PointAttribs *genatt;                         // superior point attributes according to property of owner
  
  int hinge;                    // hinge for all connected elements; see help.txt
  
  PointDOFsBCPM *dofbc;                // prescribed values = DOF boundary conditions - contain ndofs, BC array, DofIDMask array
  
  const CrossSection *cs;       // pointer  to cross section
  
  LCS_pure *lcs;
  
 public:
  PointAttribs (const Point *ow, long p, const Problem *pd=NULL, const PointAttribs *gena=NULL);
  PointAttribs (const Point *ow, const Attributes *src);
  virtual ~PointAttribs();
  
  virtual classID give_classid() const { return classPointAttribs; }
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true);
  virtual void initialize (void);
  virtual void finitialize (void);
  virtual void checkConsistency (void) const;
  
  //void EALdirectCheck (void) const { if (EAL != EAL_direct)  _errorr("this attribute container has no owner"); }
  
  // *** SET ***
  void set_dofbc_with_ID (int i) {
    dofbc = Pd->give_PV(i);
    if (dofbc == NULL) _errorr2("There is no PV with ID = %d", i+1);
    if (!GC) errol; // docasne
    dofbc = new PointDOFsBCPM((const PointDOFsBCPM*)dofbc, GC);
  }
  void set_nDOFs_BC (int nd, int *bc);
  void set_nDOFs_BC (int nd, long *bc);
  void set_nDOFs_BC (const PointDOFsBCPM *src);
  void set_hinge (int val) { hinge = val; }
  void set_cs_of_type  (CrossSectType type, int id)  { cs  = Pd->give_CS_of_type (type, id); }
  void set_dofbc (const char *str, femFileFormat ff=FFF_Void) {
    if (ff == FFF_SIFEL) {
      dofbc->rescan_att(str);
      dofbc->BC_att_SIFEL_NODEBC_revert();
    }
  }
  void set_dofbc_copy_of (const PointDOFsBCPM *src) {
    dofbc = new PointDOFsBCPM(src, GC);
  }
  void reset_dofbc_support_all_rot_dofs(void);
  
  // *** GET ***
  int                  give_nDOFs (void) const { return (dofbc    ? dofbc->give_ndofs() : (genatt ? genatt->give_nDOFs() : Pd->give_global_nDOFs())); }
  const PointDOFsBCPM* give_DOFbc (void) const { return (dofbc    ? dofbc               : (genatt ? genatt->give_DOFbc() : NULL                   )); }
  const CrossSection*  give_cs    (void) const { return (cs       ? cs                  : (genatt ? genatt->give_cs()    : NULL                   )); }
  int                  give_hinge (void) const { return (hinge>=0 ? hinge               : (genatt ? genatt->give_hinge() : false                  )); }
  //
  //const BoundaryCond* give_bc       (int i) const { EALdirectCheck();  return (bc ? bc : (genatt ? genatt->give_bc_local() : NULL)); }
  const int* give_dofBCmask (void) const { return ( (give_DOFbc() && give_DOFbc()->give_mask()) ? give_DOFbc()->give_mask() : Pd->give_DOFbc_mask()); }
  
  bool is_supported (void) const {
    const PointDOFsBCPM * dbc = this->give_DOFbc();
    return dbc ? dbc->is_supported() : false;
  }

  void assemble_full_constrained (Lvctr *aa) const {
    const PointDOFsBCPM * dbc = this->give_DOFbc();
    if (dbc)  dbc->assemble_full_constrained (aa);
    else {
      aa->resize_ignore_vals(6);
      aa->fillYourselfBy (-1);
    }
  }
  
  void setup_full_alloc_DOFvals (Dvctr *answer, const Dvctr *values) const;
  
  void checkEqualityWith (const PointAttribs *slave) const;
  
  // *** READ ***
  void read_bc (FILE *stream, femFileFormat fff);
  
  // *** PRINT ***
  bool print_prescribed_values    (FILE *stream, femFileFormat fff) const;
  void print_supported_BC_to_line (FILE *stream, femFileFormat fff) const;
  void print_DofIDMask_OOFEM      (FILE *stream                   ) const;
  void print_bc                   (FILE *stream, femFileFormat fff) const;
  virtual void print_row (FILE *stream, femFileFormat fff, long did) const;
};


// ********************************************************************************************
// *** *** *** ***                       CLASS RANAttribs                       *** *** *** ***
// ********************************************************************************************
class RANAttribs : public PointAttribs
{
 protected:                       // ***  RAN - Rigid Arm Nodes  ***
  long         AUX_msprop;        // property of RAN master; if != -1, have to find master
  long         AUX_mslid;         // local ID of RAN master; if != -1, have to find master
  const Node  *master;            // pointer to RAN master
  PointDOFsRANHN *doftype;
  
 public:
  RANAttribs (const Point *ow, long p, const Problem *pd=NULL, const PointAttribs *gena=NULL);
  RANAttribs (const Point *ow, const PointAttribs *src) : PointAttribs (ow, src) {
    if (src->give_classid() == classPointAttribs) {
      AUX_msprop = AUX_mslid = -1;
      master = NULL;
      doftype = NULL;
    }
    else errol;
  }
  virtual ~RANAttribs();
  
  virtual classID give_classid() const { return classRANAttribs; }
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true);
  virtual void initialize (void);
  virtual void checkConsistency (void) const;
  
  void complete_setup_yourself (const Node *mstr);
  
  void add_master_to_domain (long did);
  
  virtual void print_row (FILE *stream, femFileFormat fff, long did) const;
};


// ********************************************************************************************
// *** *** *** ***                       CLASS HNAttribs                        *** *** *** ***
// ********************************************************************************************
class HNAttribs : public PointAttribs
{
 protected:                       // ***  HN - Hanging Nodes  ***
  int          type;              // type of HN: 0 = noninitialized
  long         cm;                // count of master nodes
  long        *AUX_msprops;       // property of HN masters
  long        *AUX_mslids;        // local ID of HN masters
  const Node **masters;           // pointers to HN masters
  // master mask, !!! v OOFEM na HN mastermask neni ????!!!!
  PointDOFsRANHN *doftype;
  
  double        *contrib;         // contributions of masters
  const Cell *MC;              // pointer to master component (edge/surf/elem...)
  long     dimMC;              // dimmension of master component, 1=edge, 2=face, 3=element
  long     ordMC;              // degree of polynomial aproximation of master component
  PoinT   *nc;                 // natural(triangular) coordinates of hangingnode
  
 public:
  HNAttribs (const Point *ow, long a, const Problem *pd=NULL, const PointAttribs *gena=NULL);
  HNAttribs (const Point *ow, const PointAttribs *src);
  virtual ~HNAttribs();
  
  virtual classID give_classid() const { return classHNAttribs; }
  virtual bool initialize_from (const char *&str, femFileFormat ff, bool all=true);
  virtual void initialize (void);
  virtual void checkConsistency (void) const;
  
  const Cell* give_MC    (void) const { return MC; }
  long        give_dimMC (void) const { return dimMC; }
  
  void initialize_general (long countMN, const Node **mns, const double *cntrb, int n, int *val);
  void initialize_atelemet (const Cell *mc, long dimmc, long ordmc, long countMN, const Node **mns, const PoinT *natcoords);
  
  void add_masters_to_domain (long did);
  void check_masters_at_domain (long did) const;
  void find_hndomain (void);
  
  void print_one_row (FILE *stream, long hid) const;
  virtual void print_row (FILE *stream, femFileFormat fff, long did) const;
};


} // namespace midaspace

#endif // MIDAS_ATTRIBUTE_H