attribute.cpp

Go to the documentation of this file.

#include "attribute.h"

#include "point.h"
#include "problem.h"

#include "mathlib.h"

#include <math.h>


namespace midaspace {

//*  ********************************************************************************************
//*  *** *** *** ***                       CLASS ATTRIBUTE                        *** *** *** ***
//*  ********************************************************************************************
void Attribute :: scan_linerec (const char *str)
{
  SP_skip_space(str);
  linerec = new char[giveLineLength(str) + 1];
  SP_scan_line (str, linerec);
  SP_cutcomment (linerec);
}

void Attribute :: print_linerec (FILE *stream, bool pure) const
{
  if (pure)  fprintf (stream, "%s", linerec);
  else {
    const char *str = linerec;
    SP_print_word (str, stream);
    SP_print_space (str, stream);
    if (str[0] == 'x')  str++;
    else                _errorr2 ("There is no \"x\" in string \"%s\"", str);
    fprintf (stream, "%ld%s", this->ID + 1, str);
  }
}


//*  ********************************************************************************************
//*  *** *** *** ***                    CLASS PROBLEMANALYSIS                     *** *** *** ***
//*  ********************************************************************************************
bool ProblemAnalysis :: initialize_from (const char *&str, femFileFormat fff, bool all)
{
  if (fff == FFF_MIDAS  ||  fff == FFF_OOFEM) {
    char W[255];
    
    if (fff == FFF_MIDAS) {
      SP_scan_word (str, W);
      if      (strcmp(W, "OOFEMrecord"            ) == 0)   type = PAT_OOFEM;
      else if (strcmp(W, "mechanicsStaticLinAdapt") == 0)   type = PAT_static_linear_adapt;
      else if (strcmp(W, "transportStationary"    ) == 0)   type = PAT_stationary;
      else if (strcmp(W, "mechanicsStaticLin"     ) == 0)   type = PAT_static_linear;
      else if (strcmp(W, "mechanicsStabilityLin"  ) == 0)   type = PAT_stability_linear;
      else    _errorr2 ("Unsupported type of problem analysis \"%s\"", W);
    }
    else type = PAT_OOFEM;
    
    switch (type) {
    case PAT_OOFEM: {
      scan_linerec (str);
      SP_scan_word (str, W);
      loctype = PAType_s2e_OOFEM(W);
      group = PAGroup_t2g (loctype);
      bool scanned = true;
      while (SP_scan_word (str, W)) {
    if      (strcmp(W, "nsteps")   == 0)   SP_scan_number (str, nsteps);
    else    scanned = false;
      }
      if (scanned) type = loctype;
      break;
    }
    case PAT_static_linear_adapt:
      adpa = new AdaptivityParameters();
      adpa->initialize_from(str, fff);
      break;
    case PAT_stability_linear:
      while (SP_scan_word (str, W)) {
    if      (strcmp(W, "nroot") == 0)   SP_scan_number(str, nroots);
    else if (strcmp(W, "rtolv") == 0)   SP_scan_number(str, tolerance);
    else _errorr2 ("Unsupported key word in problem analysis line adaptivity \"%s\"", W);
      }
      break;
    case PAT_static_linear:
      break;
    default: errol;
    }
  }
  else errol;
  
  return true;
}

bool ProblemAnalysis :: initialize_from (FILE *stream, femFileFormat fff)
{
  if (fff == FFF_SIFEL) {
    int auxi;
    long auxl;
    double auxd;
    
    fscanf (stream, "%d", &auxi);  type = PAType_i2e_SIFEL(auxi);  if ((int)type == 0)  _errorr2("Unknown problem type in SIFEL input file %d", auxi);
    group = PAGroup_t2g (loctype);
    
    // transport
    if (group == PAG_transport) {
      // enum transmattert {nomedium=0,onemedium=1,twomediacoup=10,threemediacoup=30,fourmediacoup=40};
      // enum mednamest {heat=1,moisture=2,heat_moisture=10,moisture_salt=20,
      fscanf (stream, "%d %d", &transpmatter, &mediumname);
      if (transpmatter == 1)   fscanf (stream, "%lf"    , &scaleofmed1);
      if (transpmatter == 10)  fscanf (stream, "%lf %lf", &scaleofmed1, &scaleofmed2);
    }
    
    FP_skip_comment(stream);
    
    //
    fscanf (stream, "%d", compder1);  if (compder1[0])  fscanf (stream, "%d %d", compder1+1, compder1+1);
    fscanf (stream, "%d", compder2);  if (compder2[0])  fscanf (stream, "%d %d", compder2+1, compder2+1);
    fscanf (stream, "%d", compoth1);  if (compoth1[0])  fscanf (stream, "%d %d", compoth1+1, compoth1+1);
    fscanf (stream, "%d", compoth2);//  if (compoth2[0])  fscanf (stream, "%d %d", compoth2+1, compoth2+1);  nevim jestli je to spravne zakomentovane, ale zatim to chodi
    
    if (group == PAG_transport) {
      FP_skip_comment(stream);
      fscanf (stream, "%d",          &gravity);
    }
    FP_skip_comment(stream);
    fscanf (stream, "%ld", &auxl);  if (auxl) { adpa = new AdaptivityParameters(auxl);  adpa->initialize_from(stream, fff); }
    FP_skip_comment(stream);
    fscanf (stream, "%d %d %d", &stoch, &homog, &renumb);                                if (stoch || homog || renumb)  errol;
    
    if (type == PAT_nonstationary) {
      FP_skip_comment(stream);
      // enum timecontrtype {fixed=0, adaptive=1, adaptivemin=2, adaptivemax=3};
      fscanf (stream, "%d",  &timecontrtype);  if (timecontrtype)  errol;
      fscanf (stream, "%lf %lf", &start_time, &end_time);
      fscanf (stream, "%d %d",  &nit, &tfunct);        if (nit || tfunct)  errol;    // number of important times; type of funct 0==stat
      fscanf (stream, "%lf", &timef); // time funct
      fscanf (stream, "%lf",  &auxd); // timetypeprint
      fscanf (stream, "%ld",  &auxl);  if (auxl)  errol;  //    // backup controler
      fscanf (stream, "%lf", &auxd); // alpha
      fscanf (stream, "%ld %ld", &auxl, &auxl);  // conductmatstor, capacmatstor
      fscanf (stream, "%ld %ld", &auxl, &auxl);  // typelinsol, diagonalization of capacity matrix
    }
    else {
      fscanf (stream, "%d", &auxi);   stiffmattype = StiffMatrixType_i2e_SIFEL (auxi);     if ((int)stiffmattype == 0) _errorr2("Unknown stiffness matrix type in SIFEL input file %d", auxi);
      fscanf (stream, "%d", &auxi);   linsoltype   = LinearSolverType_i2e_SIFEL (auxi);    if ((int)linsoltype == 0)   _errorr2("Unknown linear solver type in SIFEL input file %d", auxi);
    }
  }
  else errol;
  
  return true;
}

void ProblemAnalysis :: print_row_OOFEM (FILE *stream) const
{
  PAType t = type;
  
  // stability in oofem runs only for 1d elements
  if (t == PAT_stability_linear  &&  !Pd->give_primary_geometry()->only_1d_elements()) {
    t = PAT_static_linear;
    Pd->sodriver()->print_info_message_colour (SODE_row, ETC_D_VIOLET,   "\n");
    Pd->sodriver()->print_info_message_colour (SODE_row, ETC_D_VIOLET,   "    Linear stability was switched to linear static!!!!");
  }
  
  switch (t) {
  case PAT_OOFEM:             fprintf (stream, "%s\n", linerec);                                                break;
  case PAT_stability_linear:  fprintf (stream, "LinearStability nroot %ld rtolv %.6g\n", nroots, tolerance);    break;
  case PAT_static_linear:     fprintf (stream, "LinearStatic nsteps 1\n");    if (nsteps != 1) errol;           break;
  default: errol;
  }
}

void ProblemAnalysis :: print_block_SIFEL (FILE *stream) const
{
  fprintf (stream, "%d\n", PAType_e2i_SIFEL(type));
  // transport
  if (group == PAG_transport) {
    fprintf (stream, "%d %d\n", transpmatter, mediumname);
    if (transpmatter == 1)   fprintf (stream, " %.1lf\n", scaleofmed1);
    if (transpmatter == 10)  fprintf (stream, " %.1lf %.1lf\n", scaleofmed1, scaleofmed2);
  }
  
  fprintf (stream,"%d\n", compder1[0]);  if (compder1[0])  fprintf (stream,"%d %d\n", compder1[1], compder1[2]);
  fprintf (stream,"%d\n", compder2[0]);  if (compder2[0])  fprintf (stream,"%d %d\n", compder2[1], compder2[2]);
  fprintf (stream,"%d\n", compoth1[0]);  if (compoth1[0])  fprintf (stream,"%d %d\n", compoth1[1], compoth1[2]);
  fprintf (stream,"%d\n", compoth2[0]);  if (compoth2[0])  fprintf (stream,"%d %d\n", compoth2[1], compoth2[2]);
  
  // transport
  if (group == PAG_transport)
    fprintf (stream, "%d\n", gravity);
  
  if (adpa)  fprintf (stream,"%d %g %g %g\n",
         (int)adpa->give_eetype(),
              adpa->give_required_error(),
              adpa->give_enlarg(),
              adpa->give_reduct()
              );
  else       fprintf (stream,"%d ", 0);
  
  fprintf (stream,"%d %d %d\n", stoch, homog, renumb);
  fprintf (stream,"%d", StiffMatrixType_e2i_SIFEL(stiffmattype));
  fprintf (stream," %d\n", LinearSolverType_e2i_SIFEL(linsoltype));
}


//*  ********************************************************************************************
//*  *** *** *** ***                      CLASS CROSSSECTION                      *** *** *** ***
//*  ********************************************************************************************
bool CrossSection :: initialize_from (const char *&str, femFileFormat fff, bool all)
{
  char W[255];
  SP_scan_word (str, W);
  if      (strcmp(W, "OOFEMrecord"   ) == 0)   type = CST_OOFEM;
  else if (strcmp(W, "SIFELrecord"   ) == 0)   type = CST_SIFEL;
  else if (strcmp(W, "3Dcs"          ) == 0)   type = CST_3d;
  else if (strcmp(W, "2Dcs"          ) == 0)   type = CST_2d;
  else if (strcmp(W, "TRUSScs"       ) == 0)   type = CST_Truss;
  else if (strcmp(W, "Rectangle"     ) == 0) { type = CST_Beam;  loctype = CST_Rectangle;                     }
  else if (strcmp(W, "Rectangle_tube") == 0) { type = CST_Beam;  loctype = CST_Rectangle_tube;  tube = true;  }
  else if (strcmp(W, "Circle"        ) == 0) { type = CST_Beam;  loctype = CST_Circle;                        }
  else if (strcmp(W, "Circle_tube"   ) == 0) { type = CST_Beam;  loctype = CST_Circle_tube;     tube = true;  }
  else if (strcmp(W, "Circle_cable"  ) == 0) { type = CST_Beam;  loctype = CST_Circle_cable;    cable = true; }
  else if (strcmp(W, "1Dcs_rolled"   ) == 0) { type = CST_Beam;  loctype = CST_1d_rolled;                     }
  else    _errorr2 ("Unsupported name of cross section \"%s\"", W);
  
  switch (type) {
  case CST_OOFEM: {
    scan_linerec (str);
    SP_scan_word (str, W);
    if (strcmp(W, "SimpleCS") == 0) {
      SP_scan_expected_word_exit (str, "x", "\"x\" word is expected after name of material in OOFEMrecord record", CASE);
      
      while (SP_scan_word (str, W)) {
    if      (strcmp(W, "area"          ) == 0)  SP_scan_number (str, area);
    else if (strcmp(W, "thick"         ) == 0)  SP_scan_number (str, width);
    else if (strcmp(W, "width"         ) == 0)  SP_scan_number (str, height);
    else if (strcmp(W, "Iy"            ) == 0)  SP_scan_number (str, Iy);
    else if (strcmp(W, "Iz"            ) == 0)  SP_scan_number (str, Iz);
    else if (strcmp(W, "Ik"            ) == 0)  SP_scan_number (str, Ik);
    else if (strcmp(W, "beamShearCoeff") == 0)  SP_scan_number (str, bsc);
    else loctype = CST_SimpleCS;
      }
      
      if (loctype == CST_Void) {
    if      (area<0 && width <0 && height<0 && Iy<0 && Iz<0 && Ik<0)   type = CST_3d;
    else if (area>0 && width <0 && height<0 && Iy<0 && Iz<0 && Ik<0)   type = CST_Truss;
    else if (area<0 && width >0 && height<0 && Iy<0 && Iz<0 && Ik<0) { type = CST_2d;     thickness = width; }
    else if (area>0 && width >0 && height>0 && Iy>0 && Iz>0 && Ik>0)   type = CST_Beam;
    else errol;
      }
    }
    else if (strcmp(W, "LayeredCS") == 0) {
      loctype = CST_LayeredCS;
      SP_scan_expected_word_exit (str, "x", "\"x\" word is expected after name of material in OOFEMrecord record", CASE);
      
      while (SP_scan_word (str, W)) {
    if      (strcmp(W, "nLayers"       ) == 0)  SP_scan_number (str, nlayers);
    else if (strcmp(W, "LayerMaterials") == 0) {
      SP_scan_expected_number_exit (str, nlayers, "wrong number of LayerMaterials in OOFEMrecord material record");
      mats.resizeup(nlayers);
      int auxi;
      for (int i=0; i<nlayers; i++) {
        SP_scan_number (str, auxi);
        mats.assign(i, Pd->give_Mat(auxi-1));
        if (mats[i] == NULL) _errorr2("There is no material with ID = %d", auxi+1);
      }
    }
      }
    }
    else if (strcmp(W, "FiberedCS") == 0) { loctype = CST_FiberedCS; }
    else errol;
    break;
  }
  case CST_SIFEL:
    int auxi;
    SP_scan_number (str, auxi);   type = CrossSectType_i2e_SIFEL(auxi, Pd->give_analgroup());
    SP_scan_number (str, sifid);  sifid--;
    if (Pd->give_sifCSs(loctype) != sifid)  errol;
    ((Problem*)Pd)->add_sifCSs(loctype);
    scan_linerec (str);
    switch (type) {
    case CST_2d:     SP_scan_number (str, thickness);  break;
    case CST_Truss:  SP_scan_number (str, area);       break;
    default: errol;
    }
    break;
  case CST_3d:
    break;
  case CST_2d:
    SP_scan_expected_word_exit (str, "thickness", "key word thickness expected in 2D cross-section", CASE);
    SP_scan_number (str, thickness);
    if (thickness <= 0.0)  _errorr ("Wrong crosssection attributs - thickness");
    break;
  case CST_Truss:
    SP_scan_expected_word_exit (str, "area", "key word area expected in TRUSS cross-section", CASE);
    SP_scan_number (str, area);
    if (area <= 0.0)  _errorr ("Wrong crosssection attributs - area");
    break;
  case CST_Beam:
    if (loctype == CST_1d_rolled) {
      errol;
      
      
    }
    else {
      while (SP_scan_word (str, W)) {
    if      (strcmp(W, "width")     == 0)   SP_scan_number    (str, width);
    else if (strcmp(W, "height")    == 0)   SP_scan_number    (str, height);
    else if (strcmp(W, "thickness") == 0)   SP_scan_number    (str, thickness);
    else if (strcmp(W, "LCS")       == 0) {
      if (lcs) errol;
      lcs = new LCS_beam();
      lcs->initialize_from (str, FFF_MIDAS);
    }
    else _errorr2 ("Unsupported key word in cross-section line \"%s\"", W);
      }
      
      // lcs
      //if      (lcsDir == 'z')  interchange2 (width, height);
      //else if (lcsDir != 'y')  _errorr2 ("Unsupported direction in lcs \"%c\"", lcsDir);
      
      if (height < 0.0)  height = width;
      if (width  < 0.0)   width = height;
      
      if (width < 0.0 || height < 0.0 || (tube && thickness < 0.0))  _errorr ("Wrong crosssection attributs - width height thickness");
    }
    break;
  default: errol;
  }
  
  this->sifid = Pd->give_sifCSs(this->give_type());  // type, because sifel cs's are grouped by type, not loctype
  ((Problem*)Pd)->add_sifCSs(this->give_type());
  
  return true;
}

void CrossSection :: initialize (void)
{
  Attribute :: initialize();
  
  if (lcs)  lcs->initialize(Pd->give_primary_geometry());
  
  if (type == CST_Beam  &&  loctype != CST_Void) {
    area = Iy = Iz = Ik = 0.0;
    ;         add_areaYyYz ( width              , height              );
    if (tube) add_areaYyYz (-width + 2*thickness, height - 2*thickness);
    
    if (cable) {
      int down = 20;
      Iy /= down;
      Iz /= down;
      Ik /= down;
    }
  }
}

void CrossSection :: add_areaYyYz (double w, double h)
{
  if      (loctype == CST_Rectangle || loctype == CST_Rectangle_tube ) {
    area += w * h;
    Iy   += 1.0 / 12.0 * w * h*h*h;
    Iz   += 1.0 / 12.0 * h * w*w*w;
    Ik    = area*area*area*area/40./(Iy+Iz);   // ???????? +=  or  =
    //if (tube) Ik = Iy + Iz;  ????
    bsc   = 0.84;  // (5 + 5*ny) / (6 + 5*ny);
  }
  else if (loctype == CST_Circle      ||
       loctype == CST_Circle_tube ||
       loctype == CST_Circle_cable ) {
    area += 0.25 * PIconst * w * h;
    Iy   += PIconst / 64.0 * w * h*h*h;
    Iz   += PIconst / 64.0 * h * w*w*w;
    Ik   += Iy + Iz;
    bsc   = 0.92;  // (6 + 12*ny + 6*ny*ny)/(7 + 12*ny + 4*ny*ny);
  }
  else errol;
}


void CrossSection :: print_row (FILE *stream, femFileFormat fff, long did) const
{
  if (fff == FFF_OOFEM) {
    switch (type) {
    case CST_OOFEM:  this->print_linerec (stream, false);  break;
    case CST_3d:     fprintf (stream, "SimpleCS %ld", this->ID+1);                       break;
    case CST_2d:     fprintf (stream, "SimpleCS %ld  thick %.6g", this->ID+1, thickness); break;
    case CST_Truss:  fprintf (stream, "SimpleCS %ld  area %.6g", this->ID+1, area);       break;
    case CST_Beam:
      fprintf (stream, "SimpleCS %ld", this->ID+1);
      fprintf (stream, " area %.6g Iy %.6g Iz %.6g Ik %.6g", area, Iy, Iz, Ik);
      fprintf (stream, " beamShearCoeff %.6g thick %.6g width %.6g", bsc, width, height);
      break;
    default: _errorr ("Unsupported type of cross section ");
    }
  }
  else if (fff == FFF_SIFEL) {
    fprintf (stream, "%ld", this->sifid + 1);
    switch (type) {
    case CST_SIFEL:  this->print_linerec (stream, true);  break;
    case CST_Truss:  fprintf (stream, " %g", area);        break;
    default: _errorr ("Unsupported type of cross section ");
    }
  }
  else if (fff == FFF_ANSYS) {
    fprintf (stream, "\n");
    switch (type) {
    case CST_2d:  fprintf (stream, "SECTYPE, %ld, SHELL\nSECDATA, %.6g\n\n", this->ID+1, thickness); break;
    case CST_Beam:
      fprintf (stream, "SECTYPE, %ld, BEAM", this->ID+1);
      switch (loctype) {
      case CST_Circle_tube:
    if (width != height) _errorr("elipsoid cross-sectio not supported yet");
    fprintf (stream, ", CTUBE\nSECDATA, %.6g, %.6g", width/2.0 - thickness, width/2.0);
    break;
      default: _errorr ("Unsupported loctype of beam cross section");
      }
      break;
    default: _errorr ("Unsupported type of cross section ");
    }
  }
  else errol;
  
  fprintf (stream, "\n");
}


//*  ********************************************************************************************
//*  *** *** *** ***                        CLASS MATERIAL                        *** *** *** ***
//*  ********************************************************************************************
bool Material :: initialize_from (const char *&str, femFileFormat fff, bool all)
{
  char W[255];
  SP_scan_word (str, W);
  if      (strcmp(W, "OOFEMrecord") == 0)  type = MAT_OOFEM;
  else if (strcmp(W, "SIFELrecord") == 0)  type = MAT_SIFEL;
  else if (strcmp(W, "IsoLinEl")    == 0)  type = MAT_IsoLE;
  else if (strcmp(W, "IsoLinHeat")  == 0)  type = MAT_IsoTrans;
  else if (strcmp(W, "RigidBody")   == 0)  type = MAT_RIGID;
  else    _errorr2 ("Unsupported name of material \"%s\"", W);
  
  if (type == MAT_OOFEM) {
    scan_linerec (str);
    SP_scan_word (str, W);
    loctype = MaterialType_s2e_OOFEM(W);
    if (loctype != MAT_Void) {
      bool scanned = true;
      SP_scan_expected_word_exit (str, "x", "\"x\" word is expected after name of material in OOFEMrecord record", CASE);
      while (SP_scan_word (str, W)) {
    if      (strcmp(W, "d")        == 0)   SP_scan_number (str, density);
    else if (strcmp(W, "E")        == 0)   SP_scan_number (str, E);
    else if (strcmp(W, "n")        == 0)   SP_scan_number (str, ny);
    else if (strcmp(W, "tAlpha")   == 0)   SP_scan_number (str, tAlpha);
    else if (strcmp(W, "Ry")       == 0)   SP_scan_number (str, Ry);
    else if (strcmp(W, "IHM")      == 0)   SP_scan_number (str, IHM);
    else    scanned = false;
      }
      if (scanned) type = loctype;
    }
  }
  else if (type == MAT_SIFEL) {
    // type
    int auxi;
    SP_scan_number (str, auxi);
    loctype = MaterialType_i2e_SIFEL(auxi, Pd->give_analgroup());
    if (loctype == MAT_Void)  _errorr2 ("Unsupported type of material, type %d", auxi);
    // sifel id
    SP_scan_number (str, sifid);  sifid--;
    if (Pd->give_sifMats(loctype) != sifid)  errol;
    // record
    scan_linerec (str);
    bool scanned = true;
    switch (loctype) {
    case MAT_IsoLE:  SP_scan_number (str, E);  SP_scan_number (str, ny);  break;
    default: scanned = false;
    }
    if (scanned) type = loctype;
  }
  else {
    while (SP_scan_word (str, W)) {
      if      (strcmp(W, "density")      == 0)   SP_scan_number (str, density);
      else if (strcmp(W, "E")            == 0)   SP_scan_number (str, E);
      else if (strcmp(W, "nu")           == 0)   SP_scan_number (str, ny);
      else if (strcmp(W, "tAlpha")       == 0)   SP_scan_number (str, tAlpha);
      else if (strcmp(W, "Capacity")     == 0)   SP_scan_number (str, Capac);
      else if (strcmp(W, "Conductivity") == 0)   SP_scan_number (str, Conduct);
      else if (strcmp(W, "Ry")           == 0)   SP_scan_number (str, Ry);
      else    _errorr2 ("Unsupported key word in material line \"%s\"", W);
    }
  }
  
  this->sifid = Pd->give_sifMats(this->give_loctype());
  ((Problem*)Pd)->add_sifMats(this->give_loctype());
  
  return true;
}

void Material :: print_row (FILE *stream, femFileFormat fff, long did) const
{
  if (fff == FFF_OOFEM) {
    switch (type) {
    case MAT_OOFEM:
      this->print_linerec (stream, false);
      break;
    case MAT_j2mat:
      fprintf (stream, "j2mat %ld", this->ID + 1);
      //fprintf (stream, "%s %ld", MatTypeOO_e2s(typeOO), this->ID + 1);
      fprintf (stream, "  d %.3g",     density);
      if (E>1000)  fprintf (stream, "  E %.1lf", E);
      else         fprintf (stream, "  E %e",    E);
      fprintf (stream, "  n %.2lf",       ny);
      fprintf (stream, "  tAlpha %lf",  tAlpha);
      fprintf (stream, "  Ry %g",     Ry);
      if (IHM != 0.0)  fprintf (stream, "  IHM %g",    IHM);
      break;
    case MAT_IsoLE:
      fprintf (stream, "IsoLE %ld", this->ID + 1);
      fprintf (stream, "  d %.3g",       density);
      if (E>1000)  fprintf (stream, "  E %.1lf", E);
      else         fprintf (stream, "  E %e",    E);
      fprintf (stream, "  n %.2lf",       ny);
      fprintf (stream, "  tAlpha %lf",  tAlpha);
      break;
    case MAT_RIGID:
      _errorr("rigid material is not implemented");
      break;
    default: _errorr ("Unsupported type of material ");
    }
  }
  else if (fff == FFF_SIFEL) {
    fprintf (stream, "%ld", this->sifid + 1);
    
    switch (this->give_loctype()) {
    case MAT_SIFEL:    this->print_linerec (stream, true);           break;
    case MAT_IsoLE:    fprintf (stream, "  %g %g", E, ny);           break;
    case MAT_IsoTrans: fprintf (stream, "  %g %g", Capac, Conduct);  break;
    default: _errorr ("Unsupported type of material ");
    }
  }
  else if (fff == FFF_ANSYS) {
    fprintf (stream, "\n");
    switch (this->give_loctype()) {
    case MAT_IsoLE:
      ;                   fprintf (stream, "MP, EX,   %ld, %g\n",   this->ID + 1, E);
      ;                   fprintf (stream, "MP, PRXY, %ld, %g\n", this->ID + 1, ny);
      if (density > 0.0)  fprintf (stream, "MP, DENS, %ld, %g\n", this->ID + 1, density);
      break;
    default: _errorr ("Unsupported type of material ");
    }
  }
  else errol;
  
  fprintf (stream, "\n");
}



//*  ********************************************************************************************
//*  *** *** *** ***                   CLASS BoundaryCondition                    *** *** *** ***
//*  ********************************************************************************************
bool BoundaryCond :: initialize_from (const char *&str, femFileFormat fff, bool all)
{
  char W[255];
  SP_scan_word (str, W);
  if      (strcmp(W, "OOFEMrecord")         == 0)  type = BC_OOFEM;
  else if (strcmp(W, "NodalLoad")           == 0)  type = BC_NL;
  else if (strcmp(W, "ConstantEdgeLoad")    == 0)  type = BC_CEL;
  else if (strcmp(W, "ConstantSurfaceLoad") == 0)  type = BC_CFL;
  else if (strcmp(W, "ConstantBodyLoad")    == 0)  type = BC_CBL;
  else if (strcmp(W, "DeadWeight")          == 0)  type = BC_DW;
  else if (strcmp(W, "PrescribedValue")     == 0)  type = BC_PV;
  else    _errorr2 ("Unsupported name of boundary condition \"%s\"", W);
  
  if (type == BC_OOFEM) {
    scan_linerec (str);
    SP_scan_word (str, W);
    loctype = BCType_s2e_OOFEM(W);
    if (loctype != BC_Void) {
      bool scanned = true;
      SP_scan_expected_word_exit (str, "x", "\"x\" word is expected after name of bc in OOFEMrecord record", CASE);
      while (SP_scan_word (str, W)) {
    if      (strcmp(W, "loadTimeFunction") == 0)   SP_scan_number (str, ltf);
    else if (strcmp(W, "prescribedvalue")  == 0) { ncomp = 1; components = new double[ncomp]; SP_scan_number (str, components[0]); }
    else if (strcmp(W, "components")       == 0) { SP_scan_number (str, ncomp);  components = new double[ncomp];  SP_scan_array (str, ncomp, components); }
    else    scanned = false;
      }
      if (scanned) type = loctype;
    }
  }
  else if (type == BC_PV) {
    ncomp = 1;
    components = new double[ncomp];
    SP_scan_number (str, components[0]);
  }
  else {
    scan_linerec (str);
    while (SP_scan_word (str, W)) {
      if      (strcmp(W, "dpn")        == 0) { SP_scan_word (str, W);  dpn      =     DOFsPerNode_s2e(W); }
      else if (strcmp(W, "components") == 0) {
    SP_scan_number (str, ncomp);
    
    if (components) errol;
    if (Pd->give_PDBO(PDBO_P_dw) && type == BC_DW) components = new double[6]; // DOCAS PDBO_P_dw
    else                                           components = new double[ncomp];
    SP_scan_array (str, ncomp, components);
      }
      else if (strcmp(W, "ltf") == 0) {
    SP_scan_number (str, ltf);
      }
      else    errol;
    }
    
    if (Pd->give_PDBO(PDBO_P_dw) && type == BC_DW) {
      ncomp = 6;
      components[3] = components[4] = components[5] = 0.0;
    }
    
    if (type == BC_DW)
      for (int i=0; i<ncomp; i++)
    components[i] *= 9.81;
    
  }
  
  this->sifid = Pd->give_sifBCs(this->give_loctype());
  ((Problem*)Pd)->add_sifBCs(this->give_loctype());
  
  return true;
}
void BoundaryCond :: initialize_BC_NL_SIFEL(FILE *stream)
{
  type = BC_NL;
  ncomp = Pd->give_global_nDOFs();
  components = new double[ncomp];
  this->scan_components (stream, ncomp);
}

void BoundaryCond :: checkConsistency (void) const
{
  Attribute :: checkConsistency();
  
  if (this->give_loctype() != BC_PV && this->give_type() != BC_OOFEM)
    if (this->ncomp != DOFsPerNode2nDOFs(this->give_dpn()))
      _errorr2("Boundary condition %ld: number of components doesnot correspond with dpn", ID+1);
}


void BoundaryCond :: setadd_loctype_sifif (BCType loct, int locid)
{
  type = BC_SIFEL;
  loctype = loct;
  sifid = locid;
  if (Pd->give_sifBCs(loctype) != sifid)  errol;
  ((Problem*)Pd)->add_sifBCs(loctype);
}

void BoundaryCond :: initialize_the_first_BC (void)
{
  type = loctype = BC_PV;
  ncomp = 1;
  components = new double[ncomp];
  components[0] = 0;
  ltf = 1;
}
bool BoundaryCond :: is_the_first_BC (void)
{
  if (type == BC_OOFEM) {
    const char * str = linerec;
    if ( ! SP_scan_expected_word (str, "BoundaryCondition", CASE) )  return false;
    if ( ! SP_scan_expected_word (str, "x"                , CASE) )  return false;
    if ( ! SP_scan_expected_word (str, "loadTimeFunction" , CASE) )  return false;
    if ( ! SP_scan_expected_word (str, "1"                , CASE) )  return false;
    if ( ! SP_scan_expected_word (str, "prescribedvalue"  , CASE) )  return false;
    if ( ! SP_scan_expected_word (str, "0"                , CASE) &&
     ! SP_scan_expected_word (str, "0.0"              , CASE) )  return false;
  }
  else if (type == BC_PV) {
    if ( ! ncomp         == 1   )  return false;
    if ( ! components[0] == 0.0 )  return false;
  }
  else return false;
  
  return true;
}

void BoundaryCond :: print_row (FILE *stream, femFileFormat fff, long did) const
{
  if (fff == FFF_OOFEM) {
    switch (type) {
    case BC_OOFEM:  this->print_linerec (stream, false);   break;
    case BC_PV:     fprintf (stream, "BoundaryCondition   %ld  loadTimeFunction %ld", this->ID + 1, ltf);  fprintf (stream, "  prescribedvalue %g", components[0]);      break;
    case BC_NL:     fprintf (stream, "NodalLoad           %ld  loadTimeFunction %ld", this->ID + 1, ltf);                                                            this->print_components_oo(stream);  break;
    case BC_CEL:    fprintf (stream, "ConstantEdgeLoad    %ld  loadTimeFunction %ld", this->ID + 1, ltf);  fprintf (stream, "  loadType 3  ndofs %d", this->ncomp);  this->print_components_oo(stream);  break;
    case BC_CFL:    fprintf (stream, "ConstantSurfaceLoad %ld  loadTimeFunction %ld", this->ID + 1, ltf);  fprintf (stream, "  loadType 3  ndofs %d", this->ncomp);  this->print_components_oo(stream);  break;
    case BC_DW:     fprintf (stream, "DeadWeight          %ld  loadTimeFunction %ld", this->ID + 1, ltf);  fprintf (stream, "  valtype 2");                          this->print_components_oo(stream);  break;
    default: _errorr2 ("Unsupported type of bc \"%d\"", type);
    }
    fprintf (stream, "\n");
  }
  else if (fff == FFF_SIFEL) {
    if (type != BC_SIFEL)  errol;
    if (loctype != BC_PV)  errol;
    for (int i=0; i<ncomp; i++)
      fprintf (stream, " %lf", components[i]);
    
    fprintf (stream, "\n");
  }
  else errol;
}
void BoundaryCond :: print_components_oo (FILE *stream) const
{
  fprintf (stream, "  components %d", this->ncomp);
  for (int i=0; i<this->ncomp; i++)
    fprintf (stream, " %.6lf", components[i]);
}
void BoundaryCond :: print_components (FILE *stream) const
{
  for (int i=0; i<this->ncomp; i++)
    fprintf (stream, "%14.6e", components[i]);
}


// ********************************************************************************************
// *** *** *** ***                         CLASS Assign                         *** *** *** ***
// ********************************************************************************************
void Assign :: initialize (void)
{
  GeometrySubject :: initialize();
  
  this->set_Geom (Pd->give_primary_geometry());
}

// ********************************************************************************************
// *** *** *** ***                      CLASS AssignFix                         *** *** *** ***
// ********************************************************************************************
bool AssignFix :: initialize_from (const char *&str, femFileFormat ff, bool all)
{
  SP_scan_number(str, elemid);  elemid--;
  //
  char WORD[255];
  
  SP_scan_word (str, WORD);
  if      (strcmp(WORD, "nodes"   ) == 0)  node = true;
  else if (strcmp(WORD, "elements") == 0)  node = false;
  else    _errorr2 ("Unknown type of fixed entity  \"%s\". Only \"nodes\" and \"elements\" supported.", WORD);
  
  SP_scan_word (str, WORD);
  if      (strcmp(WORD, "id"       ) == 0)  {  type = ASG_id;       SP_scan_array_alloc (str, ncn, icn);  }
  else    _errorr2 ("Unknown type of assignment of BC \"%s\"", WORD);
  
  return true;
}
void AssignFix :: initialize (void)
{
  Assign :: initialize();
  
  if (type==ASG_id) {
    const Gelement* gel = dynamic_cast<const Gelement*>(Geom->give_Elem(elemid));
    if (gel == NULL) errol;
    ((Gelement*)gel)->assign_fixed_entities_by_ID (node, ncn, icn);
  }
  else    _errorr ("Unsupported type of assigment");
}


//*  ********************************************************************************************
//*  *** *** *** ***                       CLASS AssignBC                         *** *** *** ***
//*  ********************************************************************************************
bool AssignBC :: initialize_from (const char *&str, femFileFormat ff, bool all)
{
  // bs, check
  bc = Pd->give_BC(ID-1);  if (bc == NULL)  _errorr2("There is no boundary condition with id %ld", ID);
  BCType bct = bc->give_loctype();
  
  switch (this->give_classid()) {
  case classABC_NLoad:  if (bct != BC_NL)  _errorr2 ("In block ASSIGN_NODAL_LOAD assigned to %d: assigned boundary condition is not of type NodalLoad", ID);  break;
  case classABC_CELoad: if (bct != BC_CEL) _errorr2 ("In block ASSIGN_CONST_EDGE_LOAD assigned to %d: assigned boundary condition is not of type Constant Edge Load", ID);  break;
  case classABC_CFLoad: if (bct != BC_CFL) _errorr2 ("In block ASSIGN_CONST_FACE_LOAD assigned to %d: assigned boundary condition is not of type Constant Face Load", ID);  break;
  case classABC_CBLoad: if (bct != BC_CBL && bct != BC_DW) _errorr2 ("In block ASSIGN_CONST_BODY_LOAD assigned to %d: assigned body condition is not of type Constant Body Load", ID);  break;
  default: _errorr0;
  }
  //
  char WORD[255];
  SP_scan_word (str, WORD);
  if      (strcmp(WORD, "id"       ) == 0)  {  type = ASG_id;       SP_scan_array_alloc (str, ncn, icn);  }
  else if (strcmp(WORD, "prop"     ) == 0)  {  type = ASG_prop;     SP_scan_array_alloc (str, ncn, icn);  }
  else if (strcmp(WORD, "coord"    ) == 0)  {  type = ASG_coord;    SP_scan_array_alloc (str, ncn, fcn);  }
  else if (strcmp(WORD, "surfprop" ) == 0)  {  type = ASG_faceprop; SP_scan_array_alloc (str, ncn, icn);  }
  else    _errorr2 ("Unknown type of assignment of BC \"%s\"", WORD);
  
  return true;
}
void AssignBC :: initialize (void)
{
  Assign :: initialize();
}

//*  ***************************
//*  ***   CLASS ABC_NLOAD   ***
//*  ***************************
void ABC_NLoad :: initialize (void)
{
  AssignBC :: initialize();
  
  long i;
  
  if      (type==ASG_id)      { for (i=0; i<ncn; i++)  ((Geometry*)Geom)->assign_NodeLoad_by_point_ID     (bc, icn[i]-1); }
  else if (type==ASG_prop)    { for (i=0; i<ncn; i++)  ((Geometry*)Geom)->assign_NodeLoad_by_point_prop   (bc, icn[i]  ); }
  else if (type==ASG_coord)   { if (ncn%3) _errorr ("error"); PoinT coords;
                                for (i=0; i<ncn; ) {   coords.x = fcn[i++]; coords.y = fcn[i++]; coords.z = fcn[i++];
                                                       ((Geometry*)Geom)->assign_NodeLoad_by_point_coords (bc, &coords); } }
  else    _errorr ("Unsupported type of assigment");
}
//*  ****************************
//*  ***   CLASS ABC_CELOAD   ***  //*  ***  CEL - Constant Edge Loads  ***
//*  ****************************
void ABC_CELoad :: initialize (void)
{
  AssignBC :: initialize();
  
  if (!ncn) return;
  
  ((Geometry*)Geom)->connectivity_assembling ();
  
  long i;
  if      (type==ASG_id)      { for (i=0; i<ncn; i++)  ((Geometry*)Geom)->assign_EdgeLoad_by_elem_ID  (bc, icn[i]-1); }
  else if (type==ASG_prop)    { for (i=0; i<ncn; i++)  ((Geometry*)Geom)->assign_EdgeLoad_by_elem_prop(bc, icn[i]  ); }
  else    _errorr ("Unsupported type of assigment");
}
//*  ****************************
//*  ***   CLASS ABC_CFLOAD   ***  //*  ***  CFL - Constant Face Loads  ***
//*  ****************************
void ABC_CFLoad :: initialize (void)
{
  AssignBC :: initialize();
  
  if (!ncn) return;
  
  ((Geometry*)Geom)->connectivity_assembling ();
  
  long i;
  if      (type==ASG_id)      { for (i=0; i<ncn; i++)  ((Geometry*)Geom)->assign_FaceLoad_by_elem_ID  (bc, icn[i]-1); }
  else if (type==ASG_prop)    { for (i=0; i<ncn; i++)  ((Geometry*)Geom)->assign_FaceLoad_by_elem_prop(bc, icn[i]  ); }
  else if (type==ASG_faceprop){ for (i=0; i<ncn; i++)  ((Geometry*)Geom)->assign_FaceLoad_by_face_prop(bc, icn[i]  ); }
  else    _errorr ("Unsupported type of assigment");
}
//*  ****************************
//*  ***   CLASS ABC_CBLOAD   ***  //*  ***  CBL - Constant Body Loads  ***
//*  ****************************
void ABC_CBLoad :: initialize (void)
{
  AssignBC :: initialize();
  
  long i;
  
  if      (type==ASG_id)      { for (i=0; i<ncn; i++)  ((Geometry*)Geom)->assign_BodyLoad_by_elem_ID  (bc, icn[i]-1); }
  else if (type==ASG_prop)    { for (i=0; i<ncn; i++)  ((Geometry*)Geom)->assign_BodyLoad_by_elem_prop(bc, icn[i]  ); }
  else    _errorr ("Unsupported type of assigment");
}



//*  ********************************************************************************************
//*  *** *** *** ***                       CLASS ATTRIBUTES                       *** *** *** ***
//*  ********************************************************************************************
void Attributes :: add_load (int i)
{
  const BoundaryCond *bcnew = Pd->give_BC(i);  if (bcnew == NULL) _errorr2("There is no boundary condition with ID = %d", i+1);
  this->add_load (bcnew);
}

//*  ********************************************************************************************
//*  *** *** *** ***                     CLASS FacedgeAttribs                     *** *** *** ***
//*  ********************************************************************************************
void FacedgeAttribs :: set_new (const FacedgeAttribs *src)
{
  if (loads()) errol; // DEBUG only
  loads.be_copy_of(&src->loads);
}

double FacedgeAttribs :: give_elemSize  (void) const { return elemSize  > 0.0 ? elemSize  : GC->give_Pd()->give_IN_meshGen_elemSize(); }  // nejde volat primo Pd, zjisti proc je NULL
double FacedgeAttribs :: give_elemCount (void) const { return elemCount > 0   ? elemCount : GC->give_Pd()->give_IN_meshGen_elemCount(); }

//*  ********************************************************************************************
//*  *** *** *** ***                      CLASS EdgeAttribs                       *** *** *** ***
//*  ********************************************************************************************
void EdgeAttribs :: checkConsistency (void) const
{
  FacedgeAttribs :: checkConsistency();
  
  if (loads())
    for (long i=0; i<loads(); i++) {
      if (loads[i]->give_loctype() != BC_CEL)  errol;
      if (loads[i]->give_ncomp()   != DOFsPerNode2nDOFs(owner()->give_main_masterel_uniq()->give_elemAttribs()->give_dpn()))  errol;
    }
}

//*  ********************************************************************************************
//*  *** *** *** ***                      CLASS FaceAttribs                       *** *** *** ***
//*  ********************************************************************************************
void FaceAttribs :: checkConsistency (void) const
{
  FacedgeAttribs :: checkConsistency();
  
  if (loads())
    for (long i=0; i<loads(); i++) {
      if (loads[i]->give_loctype() != BC_CFL)  errol;
      if (loads[i]->give_ncomp()   != DOFsPerNode2nDOFs(owner()->give_main_masterel_uniq()->give_elemAttribs()->give_dpn()))  errol;
    }
}

//*  ********************************************************************************************
//*  *** *** *** ***                     CLASS ELEMENTATTRIBS                     *** *** *** ***
//*  ********************************************************************************************
ElemAttribs :: ElemAttribs (const Element *ow, long p, ElAttLevel eal) : CellAttribs (ow, p)
{
  EAL = eal;
  if (owner()) {
    Patt = (owner()->give_mproperty_cnt() ? Pd->give_ElAt_with_prop(owner()->give_mproperty()) : NULL);
    Gatt = Pd->give_ElAt_with_geom(owner()->give_cellGeom());
    Datt = Pd->give_ElAt_of_domain();
  }
  else  Patt = Gatt = Datt = NULL;
  //
  dpn    = DPN_Void;
  sst    = SST_Void;
  approx = FEA_Void;
  expltype = FET_Void;
  //
  IPset = IPS_Void;
  //
  HNmstr = nlgeo = NULL;
  //
  lcs = NULL;
  MatStiffMtrx = NULL;
  //
  //final_conDOFs = NULL;
  conDOFs = NULL;
  //
  cs = NULL;  mat = NULL;
}
ElemAttribs :: ElemAttribs (const Element *ow, const ElemAttribs *src, char samegeom) : CellAttribs (ow, src)
{
  EAL   = src->EAL;  if (EAL != EAL_direct)  errol;
  Patt  = src->Patt;
  Gatt  = src->Gatt;
  Datt  = src->Datt;
  //
  dpn    = src->dpn;
  sst    = src->sst;
  approx = src->approx;
  expltype = src->expltype;
  //
  IPset   = src->IPset;
  //
  cs    = src->cs;
  mat   = src->mat;
  lcs   = src->lcs;
  //
  //for (int i=0; i<src->Ebc(); i++)  Ebc.add( new GPA<const BoundaryCond>(src->Ebc[i]) );
  //for (int i=0; i<src->Fbc(); i++)  Fbc.add( new GPA<const BoundaryCond>(src->Fbc[i]) );
  //
  if (src->nlgeo)  { nlgeo  = new bool;  nlgeo[0]  = src->nlgeo[0];  } else nlgeo  = NULL;
  if (src->HNmstr) { HNmstr = new bool;  HNmstr[0] = src->HNmstr[0]; } else HNmstr = NULL;
  //
  if (src->MatStiffMtrx) errol; // tady musim zjistit jestli matici copirovat nebo ne
  MatStiffMtrx = NULL;
  
  conDOFs = NULL;
  if (src->conDOFs) {
    if      (samegeom == 's') errol; // tady to natvrdo skopiruju
    else if (samegeom == 'd')
      //conDOFs = new GPA<DOFatt>; // conDOFs se nastavi v miste kde delam subdivision, pokud na to zapomenu, tak v initialize se nahlasi error
      errol; // tohle je tady docasne, az to nahlasi error, tak smaz a odkomentuj predchozi radek, coz by melo vest k chybe v initialize, pak musis udelat conDOFs naplneni v miste deleni
    else if (samegeom == 'm')
      conDOFs = new GPA<PointDOFsCondense>;
    else errol;
  }
}
ElemAttribs :: ~ElemAttribs()
{
  //Fbc.delete_objects();
  // Ebc.delete_objects();
  delete nlgeo;
  delete HNmstr;
  if (MatStiffMtrx) delete MatStiffMtrx;
  //delete final_conDOFs;
  if (conDOFs)
    conDOFs->delete_objects();
  delete conDOFs;
}

bool ElemAttribs :: initialize_from (const char *&str, femFileFormat ff, bool all)
{
  if (ff == FFF_MIDAS  ||  ff == FFF_OOFEM) {
    long auxl, auxl2;
    char WORD[255];
    while (SP_scan_word (str, WORD)) {
      if      (STRCMP(WORD, "crossSect"  ) == 0) { SP_scan_number (str, auxl);  this->set_cs (auxl-1); }
      else if (STRCMP(WORD, "mat"        ) == 0) { SP_scan_number (str, auxl);  this->set_mat(auxl-1); }
      else if (STRCMP(WORD, "nlgeo"      ) == 0) { SP_scan_number (str, auxl);  this->set_nlgeo(auxl); }
      else if (STRCMP(WORD, "MI_HNmaster") == 0) { SP_scan_number (str, auxl);  *HNmstr = auxl;        }
      else if (STRCMP(WORD, "refNode"    ) == 0) {
    lcs = new LCS_beam ();
    lcs->initialize_from (str, ff);
      }
      else if (STRCMP(WORD, "bodyLoads") == 0) {
    //if (EAL != EAL_direct)  _errorr("Non direct bodyLoads forbidden, in ASSIGN_ATTRIBUTES_TO_ELEMENT_PROP");
    SP_scan_expected_number_exit (str, 1, "more then 1 of body loads on element - musis to tady rozsirit");
    SP_scan_number (str, auxl);
    ((Element*)owner())->set_load(auxl-1);
      }
      else if (STRCMP(WORD, "boundaryLoads") == 0) {
    if (EAL != EAL_direct)  _errorr("Non direct boundaryLoads forbidden, in ASSIGN_ATTRIBUTES_TO_ELEMENT_PROP");
    SP_scan_expected_number_exit (str, 2, "more then 1 of boundary loads on element - musis to tady rozsirit");
    SP_scan_number (str, auxl);
    SP_scan_number (str, auxl2);
    ((Element*)owner())->set_load(auxl-1, auxl2-1);
      }

      else if (STRCMP(WORD, "symStiffMtrxOfMat") == 0) {
    if (MatStiffMtrx) errol;
    MatStiffMtrx = new Dvctr;
    SP_scan_Xvctr (str, MatStiffMtrx);
      }
      else if (STRCMP(WORD, "dofsToCondense") == 0) {
    int ndofs, nno, n, i, val, nodid;
    
    ndofs = DOFsPerNode2nDOFs(this->give_dpn());
    nno = owner()->give_nno();
    SP_scan_number (str, n);
    
    if (conDOFs) errol;
    conDOFs = new GPA<PointDOFsCondense>(nno);
    
    for (i=0; i<n; i++) {
      SP_scan_number (str, val); val--;
      nodid = val/ndofs;
      val = val%ndofs;
      if (conDOFs[0][nodid] == NULL)  conDOFs->assign(nodid, new PointDOFsCondense(nodid, owner()));
      conDOFs[0][nodid]->set_att(val, 1);
    }
      }
      // else if (STRCMP(WORD, "fet") == 0) {
      //    SP_scan_word (str, WORD);
      //    FiniteElementTypeSet fets;
      //    FETSet_s2set_OOFEM (WORD, &fets);
      //    this->set_FETS(&fets);
      // }
      else if (ff == FFF_OOFEM) {
        if (STRCMP(WORD, "NIP") == 0) {
          SP_scan_number (str, auxl);
          FiniteElementTypeSet fetset;
      IPset = IPS_inputfile_value_i2e_OOFEM (auxl, this->give_FETS(&fetset));
        }
        else
      _errorr2 ("Unknown OOFEM element key word %s", WORD);
      }
      else if (ff == FFF_MIDAS) {
    if      (STRCMP(WORD, "IPset"   ) == 0) { SP_scan_word (str, WORD);  IPset    =     IntPointSet_s2e(WORD); }
    else if (STRCMP(WORD, "approx"  ) == 0) { SP_scan_word (str, WORD);  approx   = FEApproximation_s2e(WORD); }
    else if (STRCMP(WORD, "dpn"     ) == 0) { SP_scan_word (str, WORD);  dpn      =     DOFsPerNode_s2e(WORD); }
    else if (STRCMP(WORD, "sst"     ) == 0) { SP_scan_word (str, WORD);  sst      =          SStype_s2e(WORD); }
    else if (STRCMP(WORD, "expltype") == 0) { SP_scan_word (str, WORD);  expltype =             FET_s2e(WORD); }
    else _errorr2 ("Unknown MIDAS element key word %s", WORD);
      }
    } // end of while
  }
  else if (ff == FFF_SIFEL) {
    int auxi, id;
    // cross-sect
    SP_scan_number (str, auxi);
    if (auxi) {
      SP_scan_number (str, id);
      this->set_cs_of_type(CrossSectType_i2e_SIFEL(auxi, Pd->give_analgroup()), id-1);
    }
    else {
      if (cs)  errol;
      if (owner()->give_classid() == classBrick)
    cs = (CrossSection*) ((Problem*)Pd)->give_3dCS();
    }
    
    if (Pd->give_analgroup() == PAG_mechanics) {
      SP_scan_number (str, auxi);  if (auxi != 1)  _errorr("more then 1 material per element in SIFEL input file");
    }
    
    SP_scan_number (str, auxi);
    SP_scan_number (str, id);
    this->set_mat_of_type(MaterialType_i2e_SIFEL(auxi, Pd->give_analgroup()), id-1);
  }
  else errol;
  
  return true;
}

void ElemAttribs :: initialize (void)
{
  CellAttribs :: initialize();
  
  if (lcs) lcs->initialize(this->Geom);
}

void ElemAttribs :: finitialize ()
{
}

void ElemAttribs :: checkConsistency (void) const
{
  CellAttribs :: checkConsistency();
  
  if (EAL == EAL_Void)  errol;
  if (EAL == EAL_direct  &&  !owner() )  errol;
  if (EAL != EAL_direct  &&  (owner() || Patt || Gatt || Datt))  errol;
  
  if (owner() && Pd->give_fulldata()) {
    long i;
    bool ok = true;
    
    //* *** MATERIAL ***
    //* assignment of cs
    if (this->give_mat() == NULL) {
      ok = false;
      
      // element ma LayeredCS, nema material primo prirazeny
      if (!ok) { if (this->give_cs() && this->give_cs()->give_loctype_or_type() == CST_LayeredCS)  ok = true; }
      
      // element is virtual, no material
      if (!ok) {
    const GelemAttribs *gelat = dynamic_cast<const GelemAttribs*>(this);
    if (gelat && gelat->give_virtual())  ok = true;
      }
      
      if (ok == false)  _errorr2("There is no material at element %ld",    owner()->give_ID()+1);
    }
    
    //* *** CROSS-SECTION ***
    //* assignment of cs
    if (this->give_cs()  == NULL) {
      ok = false;
      
      // element has MAT_RIGID material, no cs is needed
      if (!ok) { if (this->give_mat() && this->give_mat()->give_type() == MAT_RIGID)  ok = true; }
      
      // element is virtual, no cs
      if (!ok) {
    const GelemAttribs *gelat = dynamic_cast<const GelemAttribs*>(this);
    if (gelat && gelat->give_virtual())  ok = true;
      }
      
      // cs is at nodes
      if (!ok) {
    ok = true;
    for (i=0; i<this->owner()->give_nno(); i++)
      if (this->owner()->give_point(i)->give_pointAttribs()->give_cs() == NULL)
        ok = false;

      }
      
      if (ok == false)  _errorr2("There is no crossection at element %ld or at its nodes", owner()->give_ID()+1);
    }
    else {
      ;;
    }
    
    //* dimension of cross-section
    if (this->give_cs()) {
      switch (this->give_cs()->give_type()) {
      case CST_Truss:          if (owner()->give_dimension() != 1  ||  this->give_dpn() != DPN_DxyzR___)  _errorr2 ("element %ld has incompatible cross-section - truss cs ", owner()->give_ID()+1);  break;
      //case CST_Rectangle:
      //case CST_Rectangle_tube:
      //case CST_Circle:
      //case CST_Circle_tube:
      //case CST_Circle_cable:
      case CST_Beam:           if (owner()->give_dimension() != 1                      )  _errorr2 ("1D cross-section at not 1D element %ld", owner()->give_ID()+1);  break;
      case CST_2d:             if (owner()->give_dimension() != 2                      )  _errorr2 ("2D cross-section at not 2D element %ld", owner()->give_ID()+1);  break;
      case CST_3d:             if (owner()->give_dimension() != 3                      )  _errorr2 ("3D cross-section at not 3D element %ld", owner()->give_ID()+1);  break;
      case CST_OOFEM:  break;
      case CST_SIFEL:  break;
      default: _errorr2("Unknown cross-section type %d", this->give_cs()->give_type());
      }
    }
    
    //* *** LOAD ***
    if (loads())
      for (i=0; i<loads(); i++) {
    if (loads[i]->give_loctype() != BC_CBL && loads[i]->give_loctype() != BC_DW)  errol;
    if (loads[i]->give_dpn() != this->give_dpn())
      loads[i]->check_dpn(this->give_dpn());
    //  errol;
      }
  }
}


void ElemAttribs :: integrate_duplicated_one (const ElemAttribs *slv)
{
  if (prop   != slv->prop  )  _errorr ("Duplicity slave and master differ in ...");
  //
  if (EAL    != slv->EAL   )  _errorr ("Duplicity slave and master differ in ...");
  //
  if (Patt   != slv->Patt  )  _errorr ("Duplicity slave and master differ in ...");
  if (Gatt   != slv->Gatt  )  _errorr ("Duplicity slave and master differ in ...");
  if (Datt   != slv->Datt  )  _errorr ("Duplicity slave and master differ in ...");
  //
  if (dpn    != slv->dpn   )  _errorr ("Duplicity slave and master differ in ...");
  if (sst    != slv->sst   )  _errorr ("Duplicity slave and master differ in ...");
  if (approx != slv->approx)  _errorr ("Duplicity slave and master differ in ...");
  if (expltype != slv->expltype)  _errorr ("Duplicity slave and master differ in ...");
  //
  if (IPset  != slv->IPset )  _errorr ("Duplicity slave and master differ in ...");
  if (cs     != slv->cs    )  _errorr ("Duplicity slave and master differ in ...");
  if (mat    != slv->mat   )  _errorr ("Duplicity slave and master differ in ...");
  if (lcs    != slv->lcs   )  _errorr ("Duplicity slave and master differ in ...");
  
  if (loads() || HNmstr || nlgeo || MatStiffMtrx)  _errorr ("This check is not implemented");
  //if (!same_array_elements_asym(this->nno, this->nodes, slave->nno, slave->nodes, true))  _errorr ("Duplicity slave and master differ in nodes atribut");
}



//*  ***********
//*  *** SET ***
//*  ***********
void ElemAttribs :: set_Patt (void)
{
  Patt = Pd->give_ElAt_with_prop(owner()->give_mproperty());
}

void ElemAttribs :: set_FETS (const FiniteElementTypeSet *set)
{
  if (set->cg != owner()->give_cellGeom()) errol;
  dpn    = set->dpn;
  sst    = set->sst;
  approx = set->approx;
  expltype = set->expltype;
 //int ord;
}

void ElemAttribs :: set_MatStiffMtrx(int n, double *src)
{
  MatStiffMtrx = new Dvctr(n);
  MatStiffMtrx->beCopyOf(src);
}


//*  ***********
//*  *** GET ***  /// DEFAULT
//*  ***********
FiniteElementTypeSet* ElemAttribs :: give_FETS (FiniteElementTypeSet *set) const
{
  set->cg       = this->owner()->give_cellGeom();
  set->dpn      = this->give_dpn();
  set->sst      = this->give_sst();
  set->approx   = this->give_approx();
  set->expltype = this->give_expltype();
  set->ord      = ord;
  
  return set;
}

DOFsPerNode ElemAttribs :: give_dpn_default (void) const { return owner()->give_DOFsPerNode_default(); }
SStype      ElemAttribs :: give_sst_default (void) const { return owner()->give_SSType_default(); }


const PointDOFsCondense* ElemAttribs :: give_conDOFs(const Point* p) const
{
  return conDOFs ? conDOFs[0][owner()->give_point_indx(p)] : NULL;
}



void ElemAttribs :: set_fullhinge_at (int point)
{
  switch (this->give_dpn()) {
  case DPN_DxyzR___: break;
  case DPN_DxyzRxyz:
    if (!conDOFs) conDOFs = new GPA<PointDOFsCondense>(owner()->give_nno());
    
    if (conDOFs[0][point]) errol;
    conDOFs->assign(point, new PointDOFsCondense(point, owner()));
    conDOFs[0][point]->set_full_hinge(false); // cross hinge
    break;
  default: errol;
  }
}

bool ElemAttribs :: has_fullhinge_ends (void) const
{
  if (conDOFs &&
      conDOFs->first()                   &&  conDOFs->last()   &&
      conDOFs->first()->is_full_hinge()  &&  conDOFs->last()->is_full_hinge())
    return true;
  
  return false;
}

void ElemAttribs :: switch_dpn_Line (void)
{
  switch (this->give_dpn()) {
  case DPN_DxyzR___: break;
  case DPN_DxyzRxyz:
    if (this->has_fullhinge_ends()) {
      this->set_dpn(DPN_DxyzR___);
      conDOFs->delete_objects();
      delete conDOFs;
      conDOFs = NULL;
      
      if (loads()) {
    if (loads() != 1)  errol;
    if (loads[0]->give_dpn() != DPN_DxyzRxyz) errol;
    if (loads[0]->give_loctype() != BC_DW) errol;
    loads.assign(0, ((Problem*)Pd)->switch_BC(loads[0], DPN_DxyzRxyz, DPN_DxyzR___));
      }
    }
    break;
  default:  errol;
  }
}

//*  *** PRINT ***

void ElemAttribs :: print_Bbc_SIFEL (FILE *stream) const
{
  if (loads() == 0)  return;
  if (loads()  > 1)  errol; // vice zatizeni zatim nepodporuju
  
  fprintf (stream, "%6ld 1", owner()->give_ID()+1);
  
  loads[0]->print_components (stream);
  fprintf (stream, "\n");
}
void ElemAttribs :: print_Ebc_SIFEL (FILE *stream) const
{
  const GPA<const Edge> *edges = owner()->give_edges();
  long i, nbc = 0;
  for (i=0; i<(*edges)(); i++)  nbc += (*edges)[i]->give_cloads(owner());
  
  if (! nbc)  return;
  
  const GPA<const BoundaryCond>* loades;
  
  fprintf (stream, "%ld ????????????????????????\n", owner()->give_ID()+1);
  
  for (i=0; i<(*edges)(); i++) {
    loades = (*edges)[ECN_convert_i2e (i, 1, this->give_ord(), owner()->give_cellGeom(), FFF_SIFEL)]->give_loads(owner());
    
    if (loades->give_size()  > 1)  errol; // vice zatizeni zatim nepodporuju
    
    if (loades->give_size() == 1) {
      fprintf (stream, " 1");
      (*loades)[0]->print_components(stream);
      fprintf (stream, "\n");
    }
    else
      fprintf (stream, " 0\n");
  }
}
void ElemAttribs :: print_Fbc_SIFEL (FILE *stream) const
{
  const GPA<const Face> *faces = owner()->give_faces();
  long i, nbc = 0;
  for (i=0; i<(*faces)(); i++)  nbc += (*faces)[i]->give_cloads(owner());
  
  if (! nbc)  return;
  
  const GPA<const BoundaryCond>* loades;
  
  fprintf (stream, "%ld ????????????????????????\n", owner()->give_ID()+1);
  
  for (i=0; i<(*faces)(); i++) {
    loades = (*faces)[ECN_convert_i2e (i, 2, this->give_ord(), owner()->give_cellGeom(), FFF_SIFEL)]->give_loads(owner());
    
    if (loades->give_size()  > 1)  errol; // vice zatizeni zatim nepodporuju
    
    if (loades->give_size() == 1) {
      fprintf (stream, " 1");
      (*loades)[0]->print_components(stream);
      fprintf (stream, "\n");
    }
    else
      fprintf (stream, " 0\n");
  }
}



//*  ********************************************************************************************
//*  *** *** *** ***                    CLASS FELEMENTATTRIBS                     *** *** *** ***
//*  ********************************************************************************************
FElemAttribs :: FElemAttribs (const Element *ow, long p, ElAttLevel eal, const Problem *pd) : ElemAttribs (ow, p , eal)
{
  if (ow) {
    if (pd) errol;
    const FElement* fo = dynamic_cast<const FElement*>(GC);
    if (!fo)  errol;
  }
  else {
    if (!pd) errol;
    this->set_Pd(pd);
  }
}
FElemAttribs :: FElemAttribs (const Element *ow, const FElemAttribs *src, char samegeom) : ElemAttribs (ow, src, samegeom)
{
  if (ow) {
    const FElement* fo = dynamic_cast<const FElement*>(GC);
    if (!fo)  errol;
  }
  
  if (src->lcs) {
    if (!f_owner() || !src->f_owner())  errol; // neni dovoleny att bez ownera ale s lcs
    // zatim neni dovoleno kopirovat felem att s lcs
    // neumim rozhodnout, zda se ma lcs kopirovat, zda se ma kopirovat zavislost na mastrovi...
    // tady se musi zavolat copy constructor na lcs lcs = new LocalCoordSyst(src->lcs)
    errol; // docasne
  }
}
FElemAttribs :: FElemAttribs (const Element *ow, const GelemAttribs *src, char samegeom) : ElemAttribs (ow, (const ElemAttribs*)src, samegeom)
{
  if (ow) {
    const FElement* fo = dynamic_cast<const FElement*>(ow);
    if (!fo)  errol;
  }
  else  errol;  // kdyz kopiruju z gelementu, tak bych mel mit vzdycky ownera
}
FElemAttribs :: ~FElemAttribs()
{
  if (lcs) {
    //if (!f_owner)  errol; // neni dovoleny att bez ownera ale s lcs, zatim
    if (f_owner() && f_owner()->give_mdl_masterel())
      lcs = NULL;
    else
      delete lcs;
  }
}

void FElemAttribs :: initialize (void)
{
  ElemAttribs :: initialize();
  
  //if (owner)  this->set_fowner();
  
  // conDOFs se zkopiruje az tady, uz nevim proc se to nedela v ///  CONSTRUCTOR COPY ElemAttribs :: ElemAttribs (
  if (conDOFs && (*conDOFs)() == 0) {
    EALdirectCheck();
    
    conDOFs->resizeup(owner()->give_nno());
    
    const Gelement*               master         = f_owner()->give_mdl_masterel();              if (!master)        errol;
    const GPA<PointDOFsCondense>* masterconDOFs  = master->give_gelemAttribs()->give_conDOFs(); if (!masterconDOFs) errol;
    
    int i,j;
    bool nocond = true;
    for (i=0; i<masterconDOFs[0](); i++) {
      if (masterconDOFs[0][i] == NULL)  continue;
      
      for (j=0; j<owner()->give_nno(); j++) {
        if (f_owner()->give_node(j)->give_mdl_masterex() == master->give_point(i))
      break;
      }
      if (j == owner()->give_nno()) continue;
      
      if (conDOFs[0][j]) errol;
      conDOFs->assign(j, new PointDOFsCondense(masterconDOFs[0][i], owner()));
      
      nocond = false;
    }
    
    if (nocond) {
      delete conDOFs;
      conDOFs = NULL;
    }
  }
}

//void FElemAttribs :: set_fowner (void)
//{
//  f_owner = dynamic_cast<const FElement*>(owner);
//  if (!f_owner)
//    errol;
//}

void FElemAttribs :: print_row (FILE *stream, femFileFormat fff, long did) const
{
  if (fff == FFF_OOFEM) {
    EALdirectCheck();
    
    // lcs
    if (f_owner()->isBeam()) {
      fprintf (stream, " refNode");
      const LCS_beam *llccss = this->give_lcs_global();
      
      if (llccss)  llccss->print_row_OOFEM(stream, did, (Beam*)owner());
      else fprintf (stream, " 0");
    }
    
    const CrossSection *c = this->give_cs();    if (c)     fprintf (stream,"  crossSect %ld", c->give_ID()+1);  else _errorr2 ("Element %ld: no crosssection assigned", owner()->give_ID()+1);
    const Material     *m = this->give_mat();   if (m)     fprintf (stream,"  mat %ld",       m->give_ID()+1);  else fprintf (stream,"  mat 1");
    IntPointSet     ipset = this->give_IPset(); if (ipset) fprintf (stream,"  NIP %d", IPS_inputfile_value_e2i_OOFEM (ipset));
    //int             nlg = this->give_nlgeo(); if (nlg>0) fprintf (stream,"  nlgeo %d", nlg);

    if (MatStiffMtrx) {
      fprintf (stream,"  symStiffMtrxOfMat %ld", MatStiffMtrx->give_size());
      for (int i=0; i<MatStiffMtrx->give_size(); i++)
    fprintf (stream, " %.6g", (*MatStiffMtrx)[i]);
    }
    
    if (loads()) {
      fprintf (stream,"  bodyLoads %ld", loads());
      for (long i=0; i<loads(); i++)  fprintf (stream," %ld", loads[i]->give_ID()+1);
    }
    
    long i, nedl, nfal;
    const GPA<const Edge>* edges = owner()->give_edges();
    const GPA<const Face>* faces = owner()->give_faces();
    
    nedl = nfal = 0;
    for (i=0; i<(*edges)(); i++)  nedl += (*edges)[i]->give_cloads(owner());
    for (i=0; i<(*faces)(); i++)  nfal += (*faces)[i]->give_cloads(owner());
    
    if (nedl + nfal) {
      long j;
      const GPA<const BoundaryCond>* loades;
      
      fprintf (stream,"  boundaryLoads %ld", 2 * (nedl + nfal));
      
      if (nedl)
    for (i=0; i<(*edges)(); i++) {
      loades = (*edges)[i]->give_loads(owner());
      if (loades)
        for (j=0; j<(*loades)(); j++)
          fprintf (stream," %ld %d", (*loades)[j]->give_ID()+1, ECN_convert_i2e (i, 1, this->give_ord(), owner()->give_cellGeom(), fff) + 1);
    }
      if (nfal)
    for (i=0; i<(*faces)(); i++) {
      loades = (*faces)[i]->give_loads(owner());
      if (loades)
        for (j=0; j<(*loades)(); j++)
          fprintf (stream," %ld %d", (*loades)[j]->give_ID()+1, ECN_convert_i2e (i, 2, this->give_ord(), owner()->give_cellGeom(), fff) + 1);
    }
    }
  }
  else if (fff == FFF_ANSYS) {
    const CrossSection *c = this->give_cs();    if (c)  fprintf (stream,"SECNUM, %ld\n", c->give_ID()+1);  else _errorr2 ("Element %ld: no crosssection assigned", owner()->give_ID()+1);
    const Material     *m = this->give_mat();   if (m)  fprintf (stream,"MAT, %ld\n",    m->give_ID()+1);  else _errorr2 ("Element %ld: no material assigned",     owner()->give_ID()+1);
  }
  else if (fff == FFF_SIFEL) {
    // code numbers
    fprintf (stream, "  0");
    
    // cross-section
    const CrossSection *c = this->give_cs();
    if (c) {
      int csid = CrossSectType_e2i_SIFEL(c->give_loctype_or_type(), Pd->give_analgroup());
      fprintf (stream, "  %d", csid);
      if (csid)
    fprintf (stream, " %ld", c->give_sifid()+1);
    }
    else _errorr2 ("Element %ld: no crosssection assigned", owner()->give_ID()+1);
    // only one material
    if (Pd->give_analgroup() == PAG_mechanics)  fprintf (stream,"  1");
    // material
    const Material     *m = this->give_mat();   if (m)     fprintf (stream, "  %d %ld",  MaterialType_e2i_SIFEL(m->give_loctype(), Pd->give_analgroup()), m->give_sifid()+1);  else _errorr2 ("Element %ld: no material assigned",     owner()->give_ID()+1);
  }
  else errol;
}

//*  ********************************************************************************************
//*  *** *** *** ***                    CLASS GELEMENTATTRIBS                     *** *** *** ***
//*  ********************************************************************************************
void GelemAttribs :: checkConsistency (void) const
{
  ElemAttribs :: checkConsistency();
  
  if (virt) {
    if (dpn      != DPN_Void ||
    sst      != SST_Void ||
    approx   != FEA_Void ||
    expltype != FET_Void ||
    //
    IPset  != IPS_Void ||
    //
    HNmstr || nlgeo ||
    //
    //lcs || lukas zadava lcs plosne vsude, nejde se tomu vyhnout
    MatStiffMtrx ||
    //
    conDOFs ||
    //
    cs || mat ||
    loads()
    )
      _errorr("attribute at virtual element");
  }
  
#ifdef DEBUG
  if (conDOFs && conDOFs->give_num_nonNULL_ptrs() == 0)
    errol;
#endif
}

void GelemAttribs :: set_nDOFs_BC (int nd, int *bc)
{
  if (dofbc) _errorr ("dofbc != NULL");
  if (!owner()) errol; // docasne
  dofbc = new PointDOFsBCPM((long)0, owner());
  dofbc->set_ndofsatt(nd, bc);
}
void GelemAttribs :: set_nDOFs_BC (int nd, long *bc)
{
  if (dofbc) _errorr ("dofbc != NULL");
  if (!owner()) errol; // docasne
  dofbc = new PointDOFsBCPM((long)0, owner());
  dofbc->set_ndofsatt(nd, bc);
}
// void GelemAttribs :: set_nDOFs_BC (const PointDOFsBCPM *src)
// {
//   if (src == NULL) _errorr2("There is no set of prescribed values with ID = %d",i+1);
//   if (dofbc) _errorr ("dofbc != NULL");
//   if (!owner()) errol; // docasne
//   dofbc = new PointDOFsBCPM(src, owner());
// }


//*  ********************************************************************************************
//*  *** *** *** ***                      CLASS NODEATTRIBS                       *** *** *** ***
//*  ********************************************************************************************
PointAttribs :: PointAttribs (const Point *ow, long p, const Problem *pd, const PointAttribs *gena) : Attributes (ow, p)
{
  if (GC) { if (pd) errol; }
  else    { if (!pd) errol;  this->set_Pd(pd); }
  
  genatt = gena;
  hinge = -1;
  dofbc = NULL;
  cs = NULL;
  lcs = NULL;
}
PointAttribs :: PointAttribs (const Point *ow, const Attributes *src) : Attributes (ow, src)
{
  if (owner() == NULL)  errol;

  classID cid = src->give_classid();
  if (cid == classPointAttribs) {
    const PointAttribs *na = dynamic_cast<const PointAttribs *>(src);
    if (!na) errol;

    genatt = na->genatt;

    //* give dofbc have to be local, pointer to superior attribs is inherited
    if (na->dofbc) dofbc = new PointDOFsBCPM(na->dofbc, owner());
    else           dofbc = NULL;
    
    hinge = na->hinge;
    
    cs = na->cs;
    
    if (na->lcs) errol; lcs = NULL;
  }
  else if (cid == classGelemAttribs) {
    const GelemAttribs *ga = dynamic_cast<const GelemAttribs *>(src);
    if (!ga) errol;
    
    genatt = NULL;
    
    //* give_dofbc have to be global, to get value recursively from superior elem. attribs
    if (ga->give_dofbc()) dofbc = new PointDOFsBCPM(ga->give_dofbc(), owner());
    else                  dofbc = NULL;
    
    hinge = -1;
    cs = NULL;
    lcs = NULL;
    
    loads.resize_zero();
  }
  else errol;
}
PointAttribs :: ~PointAttribs()
{
  delete dofbc;
  delete lcs;
}

bool PointAttribs :: initialize_from (const char *&str, femFileFormat ff, bool all)
{
  if (ff == FFF_MIDAS  ||  ff == FFF_OOFEM) {
    //bool result = false;
    long auxl;
    char WORD[255];
    while (SP_scan_word (str, WORD)) {
      if      (strcmp(WORD, "bc") == 0) {
    if (dofbc)                            dofbc->scan_att_ndofs_expected (str);
    else { dofbc = owner() ? new PointDOFsBCPM((long)0, owner()) : new PointDOFsBCPM((long)0, Pd);  dofbc->scan_att_ndofs_new      (str); }
      }
      else if (strcmp(WORD, "DofIDMask") == 0) {
    dofbc->scan_mask_ndofs_expected (str);
      }
      else if (strcmp(WORD, "load") == 0) {
    SP_scan_expected_number_exit (str, 1, "uz to podporuju, jen tady dodelej smyci nacitani");
    SP_scan_number (str, auxl);
    this->add_load(auxl-1);
      }
      else if (strcmp(WORD, "ndofs") == 0) {
    if (dofbc)                            dofbc->scan_ndofs_expected (str);
    else { dofbc = owner() ? new PointDOFsBCPM((long)0, owner()) : new PointDOFsBCPM((long)0, Pd);  dofbc->scan_ndofs_new      (str); }
      }
      else if (strcmp(WORD, "lcs") == 0) {
    if (lcs) errol;
    lcs = new LCS_pure();
    lcs->initialize_from(str, ff);
      }
      else
    if (all)
      _errorr3 ("Unknown OOFEM node key word \"%s\", att id = %d", WORD, prop);
    else {
      SP_unscan_word (str, WORD);
      break;
      }

      //result = true;
    }
  }
  else if (ff == FFF_SIFEL) {
    SP_skip_space(str);
    if (str[0] == '-')
      return false;
    
    int auxi, id;
    dofbc = owner() ? new PointDOFsBCPM((long)0, owner()) : new PointDOFsBCPM((long)0, Pd);
    dofbc->scan_ndofs_new (str);
    dofbc->set_standard_att_according_to_ndofs ();
    
    SP_scan_number (str, auxi);
    if (auxi) {
      SP_scan_number (str, id);
      this->set_cs_of_type(CrossSectType_i2e_SIFEL(auxi, Pd->give_analgroup()), id-1);
    }
    if (Pd->give_analgroup() == PAG_mechanics) {
      SP_scan_number (str, auxi);  if (auxi) errol;
    }
  }
  else errol;

  return true;
}
void PointAttribs :: initialize (void)
{
  Attributes :: initialize();
}

void PointAttribs :: finitialize ()
{
}

void PointAttribs :: checkConsistency (void) const
{
  Attributes :: checkConsistency();
  
  if (dofbc)  dofbc->checkConsistency();
  
  if (owner())
    if (loads())
      for (long i=0; i<loads(); i++)
    if (loads[i]->give_type() == BC_NL)
      if ( loads[i]->give_ncomp() != owner()->give_pointAttribs()->give_nDOFs())
        errol;
  
}

void PointAttribs :: set_nDOFs_BC (int nd, int *bc)
{
  if (dofbc) _errorr ("dofbc != NULL");
  dofbc = owner() ? new PointDOFsBCPM((long)0, owner()) : new PointDOFsBCPM((long)0, Pd);
  dofbc->set_ndofsatt(nd, bc);
}
void PointAttribs :: set_nDOFs_BC (int nd, long *bc)
{
  if (dofbc) _errorr ("dofbc != NULL");
  dofbc = owner() ? new PointDOFsBCPM((long)0, owner()) : new PointDOFsBCPM((long)0, Pd);
  dofbc->set_ndofsatt(nd, bc);
}
void PointAttribs :: set_nDOFs_BC (const PointDOFsBCPM *src)
{
  if (dofbc) _errorr ("dofbc != NULL");
  dofbc = new PointDOFsBCPM(src, owner());
}
void PointAttribs :: reset_dofbc_support_all_rot_dofs(void)
{
  if (this->give_DOFbc() && dofbc==NULL)  errol; // tohle musim teprve vyspekulovat, asi odshora prirazeny dofbc zkopiruju do lokalu a upravim
  if (!dofbc) dofbc = owner() ? new PointDOFsBCPM((long)0, owner()) : new PointDOFsBCPM((long)0, Pd);
  dofbc->BC_support_all_rot_dofs();
}

void PointAttribs :: setup_full_alloc_DOFvals (Dvctr *answer, const Dvctr *values) const
{
  //
  answer->resize_ignore_vals(6);
  int ndofs = this->give_nDOFs();
  const int *mask = this->give_dofBCmask();
  
  if (ndofs != 6)  answer->zero();
  
  while (ndofs--)  (*answer)[mask[ndofs]-1] = (*values)[ndofs];
  
  if (lcs) {
    MatriX rotmat;
    lcs->setup_rotmat_l2g(&rotmat);
    rotmat.rotate(answer);
  }
}

void PointAttribs :: checkEqualityWith (const PointAttribs *slave) const
{
  if (this->give_nDOFs() != slave->give_nDOFs())          _errorr ("node attributes are not equal - in nDOFs attribute");
  if (dofbc && !dofbc->is_identical_with(slave->dofbc))   _errorr ("node attributes are not equal - in dofbc attribute");
  
  if (!loads.is_identical_with(slave->loads))             _errorr ("node attributes are not equal - in bc attribute");
}


//*  *** READ ***
void PointAttribs :: read_bc (FILE *stream, femFileFormat fff)
{
  if (fff == FFF_SIFEL) {
    if (loads())  errol;
    
    BoundaryCond *lbc = new BoundaryCond (Pd, -1);
    lbc->initialize_BC_NL_SIFEL(stream);
    
    loads.add(((Problem*)Pd)->add_find_BC(lbc));
  }
  else errol;
}

//*  *** PRINT ***
bool PointAttribs :: print_prescribed_values (FILE *stream, femFileFormat fff) const
{
  if (fff == FFF_OOFEM) {
    if (!dofbc)  return false;
    fprintf (stream, "  bc %d", dofbc->give_ndofs());
    for (int i=0; i<dofbc->give_ndofs(); i++)
      fprintf (stream, " %d", dofbc->give_att(i));
    
    if (Pd->give_PDBO(PDBO_P_rershell))
      return dofbc->rer();
  }
  return false;
}
void PointAttribs :: print_supported_BC_to_line (FILE *stream, femFileFormat fff) const
{
  const PointDOFsBCPM *dofat = this->give_DOFbc();
  if (!dofat || !dofat->is_supported())  return;
  
  if (fff == FFF_SIFEL) {
    fprintf (stream, "%ld", owner()->give_ID()+1);
    
    for (int i=0; i<dofat->give_ndofs(); i++)
      fprintf (stream, " %d", dofat->BC_give_att_SIFEL_NODEBC_reverted(i));
    
    fprintf (stream, "\n");
  }
  else if (fff == FFF_ANSYS) {
    const int* att  = dofat->give_att ();
    const int* mask = dofat->give_mask();
    if (!mask)
      mask = Pd->give_DOFbc_mask();
    
    for (int i=0; i<dofat->give_ndofs(); i++)
      if (att[i])
    fprintf (stream, "D, %6ld, %s, 0.0\n", owner()->give_ID()+1, DOFtype_i2s_ANSYS((DOFtype)mask[i]));
    
    fprintf (stream, "\n");
  }
  else errol;
}

void PointAttribs :: print_DofIDMask_OOFEM (FILE *stream) const
{
  if (dofbc->mask_is_null())  return;
  fprintf (stream, "  ndofs %d  DofIDMask %d", dofbc->give_ndofs(), dofbc->give_ndofs());
  for (int i=0; i<dofbc->give_ndofs(); i++)
    fprintf (stream, " %d", dofbc->give_mask(i));
}
void PointAttribs :: print_bc (FILE *stream, femFileFormat fff) const
{
  if (loads() == 0)  return;
  
  if (fff == FFF_OOFEM) {
    fprintf (stream,"  load %ld", loads());
    for (int i=0; i<loads(); i++)
      fprintf (stream, " %ld",  loads[i]->give_ID()+1);
  }
  else if (fff == FFF_SIFEL) {
    if (loads() != 1)  errol;  // more bc not supported now
    
    fprintf (stream, "%ld", owner()->give_ID()+1);
    
    loads[0]->print_components(stream);
    fprintf (stream, "\n");
  }
  else if (fff == FFF_ANSYS) {
    if (loads() != 1)  errol;  // more bc not supported now
    
    ;     int ndofs = this->give_nDOFs();
    const int* mask = this->give_dofBCmask();
    
    double comp;
    for (int i=0; i<ndofs; i++) {
      comp = loads[0]->give_component(mask[i]-1);
      if (comp != 0.0)
    fprintf (stream, "F, %6ld, %s, %g\n", owner()->give_ID()+1, DOFtype_i2s_force_ANSYS((DOFtype)mask[i]), comp);
    }
    
    fprintf (stream, "\n");
  }
  
  else errol;
}
void PointAttribs :: print_row (FILE *stream, femFileFormat fff, long did) const
{
  if (fff == FFF_OOFEM) {
    bool lcsb = false;
    if (dofbc)       lcsb =   this->print_prescribed_values(stream, fff);
    else if (genatt) lcsb = genatt->print_prescribed_values(stream, fff);
    
    // lcs
    if (lcsb) {
      const LCS_pure *lcsl;
      if (lcs) lcsl = lcs;
      else     lcsl = ((Node*)owner())->give_mdl_lcs();
      
      fprintf (stream, "  lcs 6");
      fprintf (stream, " %lf %lf %lf", lcsl->n1()->x, lcsl->n1()->y, lcsl->n1()->z);
      fprintf (stream, " %lf %lf %lf", lcsl->n2()->x, lcsl->n2()->y, lcsl->n2()->z);
    }
    
    if (dofbc)         this->print_DofIDMask_OOFEM(stream);
    else if (genatt) genatt->print_DofIDMask_OOFEM(stream);
    
    if (loads())          this->print_bc(stream, fff);
    else if (genatt) genatt->print_bc(stream, fff);
    //fprintf (stream, "%s", oostring);
  }
  else if (fff == FFF_SIFEL) {
    fprintf (stream, "  %d", this->give_nDOFs());

    const CrossSection *locs = this->give_cs();
    if (locs) {
      if (locs->give_type() != CST_SIFEL)  _errorr2("no sifel cross section at node %ld", owner()->give_ID());    // docasne omezeni, zatim muzu pouzit jen CST_SIFEL, dalsi na to nejsou zarizeny
      fprintf (stream, " %d", CrossSectType_e2i_SIFEL(locs->give_loctype_or_type(), Pd->give_analgroup()));
      fprintf (stream, " %ld", locs->give_sifid()+1);
    }
    else  fprintf (stream, "  0");
    
    // transformation
    if (Pd->give_analgroup() == PAG_mechanics)  fprintf (stream, "  0");
  }
  else errol;
}


//*  ********************************************************************************************
//*  *** *** *** ***                       CLASS RANATTRIBS                       *** *** *** ***
//*  ********************************************************************************************
RANAttribs :: RANAttribs (const Point *ow, long p, const Problem *pd, const PointAttribs *gena) : PointAttribs (ow, p, pd, gena)
{
  AUX_msprop = -1;
  AUX_mslid = -1;
  master = NULL;
  doftype = NULL;
}
RANAttribs :: ~RANAttribs()
{
  master = NULL;
  delete doftype;
}

bool RANAttribs :: initialize_from (const char *&str, femFileFormat ff, bool all)
{
  char WORD[255];
  while (SP_scan_word (str, WORD))
    if      (strcmp(WORD, "mstrprop") == 0)
      SP_scan_number (str, AUX_msprop);
    else if (strcmp(WORD, "master") == 0)
      SP_scan_number (str, AUX_mslid);
    else if (strcmp(WORD, "dofType") == 0) {
      if (doftype)  errol;
      doftype = new PointDOFsRANHN((long)0, owner());
      doftype->scan_att_ndofs_new(str);
    }
    else if (strcmp(WORD, "masterMask") == 0) {
      if (doftype)                            doftype->scan_mask_ndofs_expected (str);
      else { doftype = new PointDOFsRANHN((long)0, owner());  doftype->scan_mask_ndofs_new      (str); }
    }
    else {
      SP_unscan_word (str, WORD);
      if (! PointAttribs :: initialize_from (str, ff, false) )
    _errorr3 ("Unknown OOFEM RANode key word \"%s\", att id = %d", WORD, prop);
    }

  return true;
}

void RANAttribs :: initialize (void)
{
  PointAttribs :: initialize();

  if (AUX_msprop+1) {
    if (master)  _errorr0;

    const GPA<Point> *nodes = Pd->give_Mesh(0)->give_Pjnts();
    long              nn = (*nodes)();

    long i;
    bool propex;

    propex = false;
    for (i=0; i<nn; i++) {
      if ((*nodes)[i]->has_mproperty(AUX_msprop)) {
    master = Pd->give_Mesh(0)->give_Node(i);
    break;
      }
      if ((*nodes)[i]->has_mproperty(prop))
    propex = true;
    }
    if (master == NULL && propex) _errorr2 ("Rigid arm node master with property was not found, property : %d", AUX_msprop);

    AUX_msprop = -1;
  }
  if (AUX_mslid+1) {
    if (master)  _errorr0;

    master = Pd->give_Mesh(0)->give_Node(AUX_mslid-1);

    AUX_mslid = -1;
  }

  if (doftype)  doftype->HN_initialize_slave_node();
}

void RANAttribs :: checkConsistency (void) const
{
  PointAttribs :: checkConsistency();

  if (AUX_msprop+1 || AUX_mslid+1)       _errorr0;
  if ( genatt && ( master ||  doftype))  _errorr0;
  if (!genatt && (!master || !doftype))  _errorr0;

  if (doftype) {
    doftype->checkConsistency();
    //if (doftype->give_ndofs() != Pd->give_global_nDOFs())  _errorr ("Mishmash in nDOFs");
    if (dofbc)
      if (dofbc->give_ndofs() != doftype->give_ndofs())  _errorr ("Mishmash in nDOFs");
  }
}

void RANAttribs :: complete_setup_yourself (const Node *mstr)
{
  master = mstr;
  doftype = new PointDOFsRANHN((long)0, owner());
  doftype->set_ndofs(this->give_nDOFs());
  doftype->RAN_set_full_slave_node();
}

void RANAttribs :: add_master_to_domain (long did)
{
  if (!master)  return ((RANAttribs*)genatt)->add_master_to_domain (did);

  ((Node*)master)->add_me_to_domain (did);
}

void RANAttribs :: print_row (FILE *stream, femFileFormat fff, long did) const
{
  if (fff == FFF_OOFEM) {
    if (owner()) PointAttribs :: print_row (stream, fff, did);
    
    if (!master)  return genatt->print_row (stream, fff, did);
    
    const Node *nmaster = dynamic_cast<const Node *>(master);
    if (nmaster == NULL)  errol;
    
    fprintf (stream, "  master %ld", nmaster->give_lid_id (did)+1);
    long i;
    fprintf (stream, "  dofType %d",    give_nDOFs());  for (i=0; i<give_nDOFs(); i++) fprintf (stream," %d", doftype->give_att (i));
    fprintf (stream, "  masterMask %d", give_nDOFs());  for (i=0; i<give_nDOFs(); i++) fprintf (stream," %d", doftype->give_mask(i));
  }
  else if (fff == FFF_SIFEL) {
    _errorr("RAN for SIFEL is not implemented");
  }
  else errol;
}


//*  ********************************************************************************************
//*  *** *** *** ***                       CLASS HNATTRIBS                        *** *** *** ***
//*  ********************************************************************************************
HNAttribs :: HNAttribs (const Point *ow, long p, const Problem *pd, const PointAttribs *gena) : PointAttribs (ow, p, pd, gena)
{
  type = 0;  cm = 0;  AUX_msprops = NULL;  AUX_mslids = NULL;
  masters = NULL;  doftype = NULL;
  contrib = NULL;
  MC = NULL;  dimMC = ordMC = 0;  nc = NULL;
}
HNAttribs :: HNAttribs (const Point *ow, const PointAttribs *src) : PointAttribs (ow, src)
{
  if (src->give_classid() == classPointAttribs) {
    type = 0;  cm = 0;  AUX_msprops = NULL;  AUX_mslids = NULL;
    masters = NULL;  doftype = NULL;
    contrib = NULL;
    MC = NULL;  dimMC = ordMC = 0;  nc = NULL;
  }
  else errol;
}
HNAttribs :: ~HNAttribs()
{
  delete [] AUX_msprops;  delete [] AUX_mslids;
  delete [] masters;      delete  doftype;
  delete [] contrib;
  delete nc;  MC = NULL;
}

bool HNAttribs :: initialize_from (const char *&str, femFileFormat fff, bool all)
{
  if (fff == FFF_OOFEM || fff == FFF_MIDAS) {
    char WORD[255];
    while (SP_scan_word (str, WORD))
      if      (strcmp(WORD, "type") == 0) {
    SP_scan_number (str, type);
    if (type == 0)  type = 1;
    else {
      dimMC = type%10;  type = type/10;
      ordMC = type%10;  type = type/10;
      if (cm==0)  cm = type;
      else if (cm != type) _errorr ("Invalid number of masters");
      type = 2;
      nc = new PoinT;
      nc->zero();
    }
      }
      else if (strcmp(WORD, "mstrprops") == 0) {
    if (cm) SP_scan_expected_number_exit (str, cm, "Invalid number of mstrprops");
    else    SP_scan_number               (str, cm);
    AUX_msprops = new long[cm];
    SP_scan_array (str, cm, AUX_msprops);
      }
      else if (strcmp(WORD, "masters") == 0) {
    if (cm) SP_scan_expected_number_exit (str, cm, "Invalid number of mstrprops");
    else    SP_scan_number               (str, cm);
    AUX_mslids = new long[cm];
    SP_scan_array (str, cm, AUX_mslids);
      }
      else if (strcmp(WORD, "weights") == 0) {
    if (cm) SP_scan_expected_number_exit (str, cm, "Invalid number of contribs");
    else    SP_scan_number               (str, cm);
    if (contrib != NULL)  _errorr ("contribs != NULL");
    contrib = new double[cm];
    SP_scan_array (str, cm, contrib);
      }
      else if (strcmp(WORD, "dofType") == 0) {
    if (doftype)                            doftype->scan_att_ndofs_expected (str);
    else { doftype = new PointDOFsRANHN((long)0, owner());  doftype->scan_att_ndofs_new      (str); }
      }
      else if (strcmp(WORD, "masterMask") == 0) {
    if (doftype)                            doftype->scan_mask_ndofs_expected (str);
    else { doftype = new PointDOFsRANHN((long)0, owner());  doftype->scan_mask_ndofs_new      (str); }
      }
      else if (strcmp(WORD, "ksi")   == 0) { if (!nc) _errorr0;  SP_scan_number (str, nc->x); }
      else if (strcmp(WORD, "eta")   == 0) { if (!nc) _errorr0;  SP_scan_number (str, nc->y); }
      else if (strcmp(WORD, "dzeta") == 0) { if (!nc) _errorr0;  SP_scan_number (str, nc->z); }
      else {
    SP_unscan_word (str, WORD);
    if (! PointAttribs :: initialize_from (str, fff, false) )
      _errorr3 ("Unknown OOFEM HNode key word \"%s\", att id = %d", WORD, prop);
      }
  }
  else if (fff == FFF_SIFEL) {
    Lvctr aux;
    
    type = 2;
    //
    SP_scan_number (str, cm);  cm *= -1;
    AUX_mslids = new long[cm];
    aux.resize_ignore_vals(cm);
    aux.scan(str);
    if (nc)  errol;
    nc = new PoinT;
    nc->scan_xyz(str);
    
    SP_scan_number (str, dimMC);
    switch (dimMC) {
    case 1:  // isolinear1d
      if (cm != 2)  errol;
      ordMC = 1;
      dimMC = 1;
      break;
    case 5:  // isolinear2d
      if (cm != 4)  errol;
      ordMC = 1;
      dimMC = 2;
      break;
    case 13:  // isolinear3d
      if (cm != 8)  errol;
      ordMC = 1;
      dimMC = 3;
      break;
    default: errol;
    }
    SP_scan_expected_number_exit (str, 0, "0 expected");
    SP_scan_expected_number_exit (str, 0, "0 expected");
    
    int e, i;
    for (e=0; e<cm; e++) {
      if (ordMC != 0 && ordMC != 1) errol; // zatim nepocitam s jinym ord nez 1, na prvcich -4, pokud se to zmeni, tak v nasledujicim radku prepis -4 zpet na ordMC
      i = ECN_convert_e2i (e, 0, -4, CellGeometry_i2e_HN (100*cm + 10*ordMC + dimMC), fff);
      AUX_mslids[i] = aux[e];
    }
  }
  else errol;
  
  return true;
}

void HNAttribs :: initialize (void)
{
  PointAttribs :: initialize();

  if (AUX_msprops) {
    if (masters)  _errorr0;

    const GPA<Point> *nodes = Pd->give_Mesh(0)->give_Pjnts();
    long              nn = (*nodes)();

    long i, j;
    long         auxCm    = 0;
    const Node **auxMstrs = new const Node*[nn];
    double      *auxCntrb = new      double[nn];

    // find HN with prop
    for (i=0; i<nn; i++)  if ((*nodes)[i]->has_mproperty(prop))  break;
    if (i==nn) _errorr2 ("Hanging node with property %d was not found", prop);

    // find masters
    for (i=0; i<cm; i++)
      for (j=0; j<nn; j++)
    if ((*nodes)[j]->has_mproperty(AUX_msprops[i])) {
      auxMstrs[auxCm  ] = Pd->give_Mesh(0)->give_Node(j);
      auxCntrb[auxCm++] = contrib[i];
    }

    if (!auxCm) _errorr2 ("Hanging node with property %d has no master node", prop);

    ;                   cm = auxCm;
    delete [] AUX_msprops;  masters = new const Node* [cm];
    delete [] contrib;      contrib = new      double [cm];

    for (i=0; i<cm; i++) {
      masters[i] = auxMstrs[i];
      contrib[i] = auxCntrb[i];
    }

    delete [] auxMstrs;
    delete [] auxCntrb;

    AUX_msprops = NULL;
  }
  if (AUX_mslids) {
    if (masters)  _errorr0;

    masters = new const Node* [cm];

    for (long i=0; i<cm; i++)
      masters[i] = Pd->give_Mesh(0)->give_Node(AUX_mslids[i]-1);

    delete [] AUX_mslids;
    AUX_mslids = NULL;
  }
  
  if (!doftype && type == 2) {
    doftype = new PointDOFsRANHN((long)0, owner());
    doftype->set_ndofs(Pd->give_global_nDOFs());
  }
  
  if (doftype)  doftype->HN_initialize_slave_node();
}

void HNAttribs :: checkConsistency (void) const
{
  PointAttribs :: checkConsistency();

  if (AUX_msprops || AUX_mslids)   _errorr0;

  if ( genatt && (type || cm || masters || doftype || contrib || MC || nc))  _errorr0;
  if (!genatt) {
    if (type != 1 && type != 2)  _errorr0;
    if (!masters || !doftype)    _errorr0;
    if (type == 1 && !contrib)   _errorr0;
    if (type == 2 && (!nc))      _errorr0;
  }
  
  if (doftype) {
    doftype->checkConsistency();
    //if (doftype->give_ndofs() != Pd->give_global_nDOFs())  _errorr ("Mishmash in nDOFs");
    if (dofbc)
      if (dofbc->give_ndofs() != doftype->give_ndofs())  _errorr ("Mishmash in nDOFs");
  }

  // check sum of contrib of hanging nodes
  if (type == 1) {
    double sum = 0.0;
    for (long i=0; i<cm; i++)  sum += contrib[i];
    if (isNonZero(sum-1.0, 1e-7))
      //_errorr3 ("checkingConsistency: suma of coefficients of master contributions(%f) != 1.0, property %ld", sum, prop);
      _warningg3 ("checkingConsistency: suma of coefficients of master contributions(%f) != 1.0, property %ld", sum, prop);
  }
}

void HNAttribs :: initialize_general (long countMN, const Node **mns, const double *cntrb, int n, int *val)
{
  if (type) errol;
  type = 1;
  
  cm = countMN;
  masters = new const Node* [cm];
  contrib = new double [cm];
  
  for (int i=0; i<cm; i++) {
    masters[i] = mns[i];
    contrib[i] = cntrb[i];
  }
  
  doftype = new PointDOFsRANHN((long)0, owner());
  doftype->set_ndofsatt(n, val);
}

void HNAttribs :: initialize_atelemet (const Cell *mc, long dimmc, long ordmc, long countMN, const Node **mns, const PoinT *natcoords)
{
  if (type) _errorr0;
  type = 2;

  if (Pd->give_fulldata() && this->give_nDOFs() != 3)  _errorr0;
  doftype = new PointDOFsRANHN((long)0, owner());
  doftype->set_ndofs(3);
  doftype->RAN_set_full_slave_node();

  MC = mc;
  dimMC = dimmc;
  if (ordmc != -4)
    errol;
  ordMC = 1; //ordmc;
  cm = countMN;
  
  masters = new const Node* [cm];
  nc      = new       PoinT;
  
  int i;
  for (i=0; i<cm; i++)  masters[i] = mns[i];
  nc->copy(natcoords)->round2abszero(ZERO_NC);
}

void HNAttribs :: add_masters_to_domain (long did)
{
  if (!masters)  return ((HNAttribs*)genatt)->add_masters_to_domain (did);

  for (long i=0; i<cm; i++)
    ((Node*)masters[i])->add_me_to_domain (did);
}
void HNAttribs :: check_masters_at_domain (long did) const
{
  if (!masters)  return ((HNAttribs*)genatt)->check_masters_at_domain (did);

  for (long i=0; i<cm; i++)
    if (masters[i]->give_lid(did) == -1)
      _errorr2 ("Hanging node and its master are not on same domain, global node number: %d", this->prop+1);
}
void HNAttribs :: find_hndomain (void)
{
  if (type != 2)  _errorr0;

  // 3d - domain podle MC
  if (dimMC == 3) {
    ((Node*)owner())->initialize_parallel (-((FElement*)MC)->give_domain(), NULL);
    return;
  }

  long i;
  // edge/surface is not shared
  for (i=0; i<cm; i++)
    if (!masters[i]->is_shared()) {
      ((Node*)owner())->initialize_parallel (-masters[i]->give_domain(), NULL);
      return;
    }

  // ... is shared
  const GPA<const Element> *superelem = ((Facedge*)MC)->give_superelems();
  long ned = superelem[0]();
  long *superdom = new long[ned];

  for (i=0; i<ned; i++)
    superdom[i] = ((FElement*)superelem[0][i])->give_domain();

  shaker (ned, superdom);
  ((Node*)owner())->initialize_parallel (ned, superdom);
  delete [] superdom;
}

void HNAttribs :: print_one_row (FILE *stream, long hid) const
{
  if (type != 2)  _errorr0;

  fprintf (stream,"  hn  %3ld  dimM %ld  order %ld", hid+1, dimMC, ordMC);

  const PoinT *coo = owner()->give_coords();
  fprintf (stream,"  coords  %12.5f%12.5f%12.5f  MNs  ", coo->x, coo->y, coo->z);

  for (long i=0; i<cm; i++)
    fprintf (stream, " %5ld", masters[i]->give_ID()+1);
  
  if (dimMC > 0)  fprintf (stream,"   ksi %5.2f",  nc->x);
  if (dimMC > 1)  fprintf (stream,"   eta %5.2f",  nc->y);
  if (dimMC > 2)  fprintf (stream,"   dzeta %5.2f",nc->z);
}

void HNAttribs :: print_row (FILE *stream, femFileFormat fff, long did) const
{
  long e,i;
  CellGeometry cg = CG_Void;
  
  if (type == 2) {
    cg = CellGeometry_i2e_HN (100*cm + 10*ordMC + dimMC);
    if (MC && MC->give_cellGeom() != cg)  errol;
  }
  
  if (fff == FFF_OOFEM) {
    if (owner()) PointAttribs :: print_row (stream, fff, did);
    
    if (!masters)  return genatt->print_row (stream, fff, did);
    
    bool general = (type==1) ? true : false;
    
    // type
    fprintf (stream, "  type %ld", general ? 0 : 100*cm + 10*ordMC + dimMC);
    // dofType
    fprintf (stream, "  dofType %d", give_nDOFs());
    for (i=0; i<give_nDOFs(); i++) fprintf (stream, " %d", doftype->give_att(i));
    // masters
    fprintf (stream, "  masters %ld", cm);
    for (e=0; e<cm; e++) {
      if (ordMC != 0 && ordMC != 1) errol; // zatim nepocitam s jinym ord nez 1, na prvcich -4, pokud se to zmeni, tak v nasledujicim radku prepis -4 zpet na ordMC
      if (type == 2)  i = ECN_convert_e2i (e, 0, -4, cg, fff); // ordMC
      else            i = e;
      fprintf (stream," %ld", masters[i]->give_lid_id(did)+1);
    }
    //
    if (general) {
      // weights
      fprintf (stream, "  weights %ld", cm);
      for (i=0; i<cm; i++) fprintf (stream, " %.8e", contrib[i]);
    }
    else {
      // ksi eta dzeta
      ;                     fprintf (stream,"  ksi %.9g",  this->nc->x);
      if (this->dimMC > 1)  fprintf (stream, " eta %.9g",  this->nc->y);
      if (this->dimMC > 2)  fprintf (stream, " dzeta %.9g",this->nc->z);
    }
  }
  else if (fff == FFF_SIFEL  ||  fff == FFF_JKTK) {
    if (type!=2)  _errorr("HN at finite element is supported only");
    
    // masters
    fprintf (stream, " -%ld", cm);
    for (e=0; e<cm; e++) {
      if (ordMC != 0 && ordMC != 1) errol; // zatim nepocitam s jinym ord nez 1, na prvcich -4, pokud se to zmeni, tak v nasledujicim radku prepis -4 zpet na ordMC
      i =  ECN_convert_e2i (e, 0, -4, cg, fff);
      fprintf (stream," %ld", masters[i]->give_lid_id(did)+1);
    }
    
    // ksi eta dzeta
    fprintf (stream,"  %g %g %g", this->nc->x, this->nc->y, this->nc->z);
    
    // typ_entity of master
    fprintf (stream, "  %d", CellGeometry_e2i_JKTK (cg));
    
    if (fff == FFF_SIFEL)
      fprintf (stream, "  0 0");
  }
  else errol;
}

} // namespace midaspace