substructs.h

Go to the documentation of this file.

#ifndef MIDAS_SUBSTRUCTS_H
#define MIDAS_SUBSTRUCTS_H

#include "subject.h"


namespace midaspace {

//*  ********************************************************************************************
//*  *** *** *** ***                         CLASS DOFatt                         *** *** *** ***
//*  ********************************************************************************************
class PointDOFsAttributes : public GeomCompSubject
{
 protected:
  int  ndofs;
  int *att;
  int *mask;
  
 public:
  PointDOFsAttributes (                      long gid, const GeometryComponent *owner) : GeomCompSubject (gid, owner) { ndofs = -1;  att = mask = NULL; }
  PointDOFsAttributes (                      long gid, const Problem           *owner) : GeomCompSubject (gid, owner) { ndofs = -1;  att = mask = NULL; }
  PointDOFsAttributes (const PointDOFsAttributes *src, const GeometryComponent *owner) : GeomCompSubject (src->give_ID(), owner ? owner : src->give_GC()) {
    ndofs = src->ndofs;
    if (src->att)  { att  = new int[ndofs];  memcpy (att,  src->att,  ndofs*sizeof(int)); }  else att = NULL;
    if (src->mask) { mask = new int[ndofs];  memcpy (mask, src->mask, ndofs*sizeof(int)); }  else mask = NULL;
  }
  virtual ~PointDOFsAttributes() { delete [] att;  delete [] mask; }
  
  
  virtual void checkConsistency (void) const {
    GeomCompSubject :: checkConsistency();
    if (ndofs<1 || att == NULL) errol;
    if (mask == NULL)
      if (ndofs != Pd->give_global_nDOFs())  _errorr ("Mishmash in nDOFs");
  }
  
  // *** SET ***
  void set_ndofs    (int n           ) { ndofs = n; }
  void set_att      (int i, int   val) { if (               att == NULL) errol;  att[i] = val; }
  void set_ndofsatt (int n, int  *val) { if (ndofs != -1 || att != NULL) errol;  ndofs = n;  att = new int[ndofs];  memcpy (att, val, ndofs*sizeof(int));  }
  void set_ndofsatt (int n, long *val) { if (ndofs != -1 || att != NULL) errol;  ndofs = n;  att = new int[ndofs];  while (n--)  att[n] = val[n];  }
  
  // *** GET ***
  int give_ndofs      (void)  const { return ndofs; }
  int give_att        (int i) const { return att[i];  }
  int give_mask       (int i) const { return mask[i]; }
  const int* give_att  (void) const { return att;  }
  const int* give_mask (void) const { return mask; }
  
  // IS
  bool mask_is_null (void) const { return (mask == NULL) ? true : false; }
  bool is_identical_with (const PointDOFsAttributes *src) const {
    if (                               ndofs != src->ndofs )  return false;
    if (arrays_arenot_identical(ndofs, att,     src->att  ))  return false;
    if (arrays_arenot_identical(ndofs, mask,    src->mask ) && (mask || src->mask))  return false;
    return true;
  }
  
  
  // ndofs is -1,        att == NULL, mask == NULL
  void scan_ndofs_new           (const char *&str) { SP_scan_number (str, ndofs);                                                        }
  void scan_att_ndofs_new       (const char *&str) { SP_scan_number (str, ndofs);                                  this->scan_att(str);  }
  void scan_mask_ndofs_new      (const char *&str) { SP_scan_number (str, ndofs);                                  this->scan_mask(str); }
  // ndofs is initiated, att == NULL, mask == NULL
  void scan_ndofs_expected      (const char *&str) { SP_scan_expected_number_exit (str, ndofs, "nDOFs mismatch");                        }
  void scan_att_ndofs_expected  (const char *&str) { SP_scan_expected_number_exit (str, ndofs, "nDOFs mismatch");  this->scan_att(str);  }
  void scan_mask_ndofs_expected (const char *&str) { SP_scan_expected_number_exit (str, ndofs, "nDOFs mismatch");  this->scan_mask(str); }
  
  // ndofs is initiated, att == NULL, mask == NULL
  void rescan_att         (const char *&str) { if (att  == NULL)  _errorr ("att == NULL");                            SP_scan_array (str, ndofs, att);  }
  void scan_att           (const char *&str) { if (att  != NULL)  _errorr ("att != NULL");   att  = new int[ndofs];   SP_scan_array (str, ndofs, att);  }
  void scan_mask          (const char *&str) { if (mask != NULL)  _errorr ("mask != NULL");  mask = new int[ndofs];   SP_scan_array (str, ndofs, mask); }
  void scan_att_new_sparse(const char *&str) { if (mask != NULL)  _errorr ("mask != NULL");  att  = new int[ndofs];   memset(att, 0, ndofs*sizeof(int));
    int n, val;
    SP_scan_number (str, n);
    for (int i=0; i<n; i++) {
      SP_scan_number (str, val);
      if (val>ndofs)  errol;
      att[val-1] = 1;
    }
  }
  // ndofs == -1
  // nascanuji ndofs a pak pole att
  //   void scan_ndofsatt (const char *&str) {
  
  
  
};


//*  ********************************************************************************************
//*  *** *** *** ***                         CLASS DOFatt_cond                    *** *** *** ***
//*  ********************************************************************************************
class PointDOFsBCPM : public PointDOFsAttributes
{
 public:
  PointDOFsBCPM (                long gid, const GeometryComponent *owner) : PointDOFsAttributes (gid, owner) { if (!owner)  errol; }
  PointDOFsBCPM (                long gid, const Problem           *owner) : PointDOFsAttributes (gid, owner) { if (!owner)  errol; }
  PointDOFsBCPM (const PointDOFsBCPM *src, const GeometryComponent *owner) : PointDOFsAttributes (src, owner) { if (!owner)  errol; }
  virtual ~PointDOFsBCPM() { }
  
  bool rer (void) const
  {
    if (ndofs != 6) errol;
    if (att==NULL)  errol;
    
    return (att[0] == 0 && att[1] == 0 && att[2] == 0 && att[3] == 0 && att[4] == 0 && att[5] == 1);
  }
  
  bool is_supported (void) const
  {
    if (att==NULL) return false;
    register int i = ndofs, sum = 0;
    while (i--) sum += att[i];
    return sum;
  }
  
  void assemble_full_constrained (Lvctr *aa) const
  {
    if (att==NULL)  errol; // docasne, pokud to bude NULL tak by bylo cele pole -1
    aa->resize_ignore_vals(6);
    aa->fillYourselfBy (-1);
    if (mask==NULL) {
      ((PointDOFsBCPM*)this)->mask = DOFsPerNode2dofBCmask (Pd->give_DOFspnod());
    }
    for (int i=0; i<ndofs; i++)  (*aa)[(int)mask[i]-1] = att[i];
  }
  
  //        i
  //  1 ->  0 -> 0
  //  0 -> -1 -> 1
  // -1 -> -2 -> 2
  // -2 -> -3 -> 3
  void BC_att_SIFEL_NODEBC_revert (void)
  {
    for (int i=0; i<ndofs; i++)  att[i] = 1 - att[i];
  }
  int BC_give_att_SIFEL_NODEBC_reverted (int i) const { return 1 - att[i];  }
  
  void BC_support_all_rot_dofs (void)
  {
    if (ndofs == -1 && att==NULL) {
      ndofs = Pd->give_global_nDOFs();
      att = new int[ndofs];
      memset(att, 0, ndofs*sizeof(int));
    }
    else if (att == NULL) errol;
    
    if (mask) errol;
    if (Pd->give_DOFspnod() == DPN_DxyzRxyz)  att[3] = att[4] = att[5] = 1;
    else errol;
  }
  
  void set_standard_att_according_to_ndofs (void) {
    att = new int[ndofs];
    for (int i=0; i<ndofs; i++)
      att[i] = 0;
  }
  
  
  void set_elemDOFs_2nodesPERsixDOFs (void) {
    ndofs = 12;
    att  = new int[ndofs];  memset(att, 0, ndofs*sizeof(int));
    mask = new int[ndofs];  
    
    mask[0] = mask[ 6] = 1;
    mask[1] = mask[ 7] = 2;
    mask[2] = mask[ 8] = 3;
    mask[3] = mask[ 9] = 4;
    mask[4] = mask[10] = 5;
    mask[5] = mask[11] = 6;
  }
};

//*  ********************************************************************************************
//*  *** *** *** ***                         CLASS DOFatt_cond                    *** *** *** ***
//*  ********************************************************************************************
class PointDOFsRANHN : public PointDOFsAttributes
{
 public:
  PointDOFsRANHN (long gid, const GeometryComponent *owner) : PointDOFsAttributes (gid, owner) {}
  PointDOFsRANHN (long gid, const Problem           *owner) : PointDOFsAttributes (gid, owner) {}
  virtual ~PointDOFsRANHN() { }
  
  void RAN_set_full_slave_node (void) {
    if (ndofs < 1 || att != NULL || mask != NULL)  errol;
    att  = new int[ndofs];
    mask = new int[ndofs];
    fill_all_by (att,  ndofs, 2);
    fill_all_by (mask, ndofs, 1);
  }
  
  void HN_initialize_slave_node (void) {
    if (!mask && !att) {
      att = new int[ndofs];
      mask = new int[ndofs];
      for (int i=0; i<ndofs; i++) {
    att[i] = 2;
    mask[i] = 1;
      }
    }
    
    if (mask && !att) {
      att = new int[ndofs];
      for (int i=0; i<ndofs; i++)
    att[i] = mask[i] ? 2 : 0;
    }
    
    if (att && !mask) {
      mask = new int[ndofs];
      for (int i=0; i<ndofs; i++)
    mask[i] = att[i] ? 1 : 0;
    }
  }
};


//*  ********************************************************************************************
//*  *** *** *** ***                         CLASS DOFatt_cond                    *** *** *** ***
//*  ********************************************************************************************
class PointDOFsCondense : public PointDOFsAttributes
{
 public:
  PointDOFsCondense (long gid, const Element *owner);
  PointDOFsCondense (const PointDOFsCondense *src, const GeometryComponent *owner) : PointDOFsAttributes (src, owner) { if (!owner)  errol; }
  virtual ~PointDOFsCondense() { }
  
  virtual void checkConsistency (void) const { PointDOFsAttributes :: checkConsistency();  if (ndofs<1 || att == NULL || mask) errol; }
  
  void set_full_hinge (bool noXrot);
  bool is_full_hinge (void) const;
};

} // namespace midaspace

#endif // MIDAS_SUBSTRUCTS_H