xfemEnrichedElementData.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together 
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND, 
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR 
** A PARTICULAR PURPOSE.
**
************************************************************************/
 
#ifndef _GEMA_XFEM_ENRICHED_ELEMENTDATA_H_
#define _GEMA_XFEM_ENRICHED_ELEMENTDATA_H_
 
#include <qglobal.h>
 
#include <gmCell.h>
 
class XfemIntegrationRule;
class GmIntegrationRule;
class XfemSubElement;
class GmElementDof;
 
class XfemEnrichedElementData
{
public:
  XfemEnrichedElementData(XfemIntegrationRule* ir);
 
  virtual ~XfemEnrichedElementData();
 
  XfemIntegrationRule* regularIntegrationRule() const { return _ir; }
 
  int numRegularSubElements() const { return _nRegular; }
 
  int numFractureSubElements() const { return _subElements.size() - _nRegular; }
 
  int numElemInterInfo() const { return _elemInterInfo.size() ; }
 
  int numDofSet() const { return _dofSet.size(); }
 
  int numInteractingCraks() const { return _interactingCraks.size(); }
 
  int numSubCraks() const { return _subCrackInfo.size(); }
 
  int numNodalLevelSet() const { return _nodalLevelSet.size(); }
 
  int numGaussLevelSet() const { return _gaussLevelSet.size(); }
 
  int numNodedofSet() const { return _NodedofSet.size(); }
 
  int numGaussDofSet() const { return _gaussLevelSetInter.size(); }
 
  int numTopDofSet() const { return _TopLevelSetInter.size(); }
 
  int numBotDofSet() const { return _BottomLevelSetInter.size(); }
 
  // Return the number of Fracture segments info about hydraulic or Natural and Open or closed states
  int numSubCrackState() const { return _subCrackState.size(); }
 
  // Return the number of Fracture segment info about reactivation of cracks
  int numSubCrackReactivation() const { return _crackReactivation.size(); }
 
  // Return the number of edge nodes cut by crack front nodes
  int numCrackFrontNodes() const { return _crackFront.size(); }
 
  // Return the number of nearest element to crack front nodes
  int numNearestElem() const { return _nearestElem.size(); }
 
  XfemSubElement* subElement(int index) const { return _subElements.at(index); }
 
  XfemSubElement* fractureSubElement(int index) const { return _subElements.at(index + _nRegular); }
 
  GmElementDof* dofMap()  { return _dofMap; }
  
  void setDofMap(GmElementDof* dofMap) { assert(!_dofMap);  _dofMap = dofMap; }
 
  void clearDofMap(){ _dofMap = NULL; }
 
  // Add Element Intersection Information
  void appendElemInterInfo(GmVector Cr, bool type = true);
 
  //Get Element Intersection information {Crack's id, first crack node, second crack node} at a specific position
  void virtual getElemInterInfo(GmVector& A, int n) const;
 
  // Add Element Intersection Information
  void appendSubCrackInfo(GmVector Cr, bool type = true);
 
  // Adds list with sub-crack paths
  void insertSubCrackInfo(int path, GmVector A, GmVector B);
 
  //Get Element Intersection information {Crack's id, first crack node, second crack node} at a specific position
  void virtual getSubCrackInfo(GmVector& A, int n) const;
 
  // Add DOF sets to be used per element
  void appendDofSet(GmVector Cr, bool type = true);
 
  // Add DOF sets to be used for an node that has different  DOF set compared to other nodes of the same element
  void appendNodeDofSet(QList<GmVector> list, double n, bool type = true);
 
  // A list with Fracture segment info about hydraulic or Natural and Open or closed states
  void appendSubCrackState(bool fracType, bool fracState, bool type = true);
 
  // A list with Fracture segment info about hydraulic or Natural and Open or closed states
  void appendSubCrackReactivation(bool fracType, bool type = true);
 
  //Get DOF sets to be used per element at a specific position
  void virtual getDofSet(GmVector& A, int n) const;
 
  // get DOF sets to be used for an node that has different  DOF set compared to other nodes of the same element
  void getNodeDofSet(QList<QPair<double, QList<GmVector>>>& list, int n)const;
 
  // get list with Fracture segment info about hydraulic or Natural and Open or closed states
  void getSubCrackState(QList<QPair<bool, bool>>& list, int n) const;
 
  // get list with Fracture segment info about hydraulic or Natural and Open or closed states
  void getSubCrackReactivation(bool& list, int n) const;
 
  //replace DOF sets to be used per element at a specific position
  void virtual replaceDofSet(GmVector A, int n);
 
  // replace crack state pair in list of segment info about hydraulic or Natural and Open or closed states
  void replaceSubCrackState(bool fracType, bool fracState, int index);
 
  // replace crack state pair in list of segment info about hydraulic or Natural and Open or closed states
  void replaceSubCrackReactivation(bool fracType, int index);
 
  void deleteDofSet(){ _dofSet.clear(); }
 
  void deleteNodeDof(){ _NodedofSet.clear(); }
 
  // get list with Fracture segment info about hydraulic or Natural and Open or closed states
  void deleteSubCrackState(){ _subCrackState.clear(); }
 
  // Add Element Intersection Information
  void appendInteractingCraks(GmVector Cr, bool type = true);
 
  //Get Element Intersection information {Crack's id, first crack node, second crack node} at a specific position
  void virtual getInteractingCraks(GmVector& A, int n) const;
 
  // Add list with information about the number of DOF per element
  void appendnumAddDOF(int Cr, bool type = true);
 
  //Replace the number of DOF per element information at specific position on the list
  void replaceNumAddDOF(int Cr, int index);
 
  //Get the number of additional DOF per element at a specific position
  void virtual getnumAddDOF(int& A, int n) const;
 
  // delete Element Intersection Information
  void deleteNumAddDOF(){ _numAddDOF.clear(); }
 
  // Add list with crack front nodes
  void appendCrackFrontNodes(int Cr, int Cr2, bool type = true);
 
  // Replace crack front nodes at specific position on the list
  void replaceCrackFrontNodes(int Cr, int Cr2, int index);
 
  // Get crack front nodes at a specific position
  void virtual getCrackFrontNodes(QPair<int, int>& crack, int n) const;
 
  // delete list with edge nodes cut by crack front nodes
  void deleteCrackFrontNodes(int id) { _crackFront.removeAt(id); }
 
  // Add list with enrichment functions for element nodes
  void addNodalLevelSet(QList<QList<int>> nodalLevelSet);
 
  //Get the list with enrichment functions for element nodes
  void virtual getNodalLevelSet(int n, QList<int>& nodalLevelSet) const;
 
  //Replace the list of nodalLevelSet
  void replaceNodalLevelSet(int n, QList<int> nodalLevelSet);
 
  // delete Element Intersection Information
  void deleteNodalLevelSet(){ _nodalLevelSet.clear(); }
 
  // Add list with crack front nodes and the nearest element to them
  void addNearestElement(QList<int> nodalLevelSet);
 
  //Get the list with crack front nodes and the nearest element to them
  void virtual getNearestElement(int n, QList<int>& nodalLevelSet) const;
 
  // Add list with enrichment functions for gauss points
  void addGaussLevelSet(QList<int> gaussLevelSet);
 
  //Get the list with enrichment functions for gauss points
  void virtual getGaussLevelSet(int n, QList<int>& gaussLevelSet) const;
 
  // delete Element Intersection Information
  void deleteGaussLevelSet(){ _gaussLevelSet.clear(); }
 
  // Add list with enrichment functions for element nodes
  void addTopLevelSet(QList<int> TopLevelSet);
 
  //Get the list with enrichment functions for element nodes
  void virtual getTopLevelSet(int n, QList<int>& TopLevelSet) const;
 
  // delete Element Intersection Information
  void deleteTopLevelSet(){ _TopLevelSet.clear(); }
 
  // Add list with enrichment functions for element nodes
  void addBottomLevelSet(QList<int> BottomLevelSet);
 
  //Get the list with enrichment functions for element nodes
  void virtual getBottomLevelSet(int n, QList<int>& BottomLevelSet) const;
 
  // delete Element Intersection Information
  void deleteBottomLevelSet(){ _BottomLevelSet.clear(); }
 
  // Add list with enrichment functions for gauss points
  void addGaussLevelSetInter(int n, QList<QList<int>> gaussLevelSetInter);
 
  //Get the list with enrichment functions for gauss points
  void virtual getGaussLevelSetInter(int n, QPair<int, QList<QList<int>>>& gaussLevelSetInter) const;
 
  // delete Element Intersection Information
  void deleteGaussLevelSetInter(){ _gaussLevelSetInter.clear(); }
 
  //Replace the list of gaussLevelSet
  void replaceGaussLevelSetInter(int n, QPair<int, QList<QList<int>>> gaussLevelSetInter);
 
  // Add list with enrichment functions for element nodes
  void addTopLevelSetInter(int n, QList<QList<int>> TopLevelSetInter);
 
  //Get the list with enrichment functions for element nodes
  void virtual getTopLevelSetInter(int n, QPair<int, QList<QList<int>>>& TopLevelSetInter) const;
 
  // delete Element Intersection Information
  void deleteTopLevelSetInter(){ _TopLevelSetInter.clear(); }
 
  //Replace the list of TopLevelSet
  void replaceTopLevelSetInter(int n, QPair<int, QList<QList<int>>> TopLevelSetInter);
 
  // Add list with enrichment functions for element nodes
  void addBottomLevelSetInter(int n, QList<QList<int>> BottomLevelSetInter);
 
  //Get the list with enrichment functions for element nodes
  void virtual getBottomLevelSetInter(int n, QPair<int, QList<QList<int>>>& BottomLevelSetInter) const;
 
  // delete Element Intersection Information
  void deleteBottomLevelSetInter(){ _BottomLevelSetInter.clear(); }
 
  //Replace the list of TopLevelSet
  void replaceBottomLevelSetInter(int n, QPair<int, QList<QList<int>>> BottomLevelSetInter);
 
#if defined ENABLE_TESTS 
  void validateInternalStructure();
#endif
 
private:
  Q_DISABLE_COPY(XfemEnrichedElementData)
  
  // IMPORTANT: Functions used for adding / removing subelements are marked private since 
  //            they should not be called directly.  Their conuterparts in the XfemMesh 
  //            interface should be used instead since they can adjust other values 
  //            needed for maintaining mesh consistency when adding subelements.
  friend class XfemMesh;
 
  void clearSubElements();
  int  addSubElement   (GmCellType type, XfemSubElement* se, const GmIntegrationRule* seIr);
  void removeSubElement(int index);
  void updateSubElement(GmCellType type, XfemSubElement* se, const GmIntegrationRule* seIr, const GmMatrix& seNaturalCoords);
 
 
  XfemIntegrationRule*                  _ir;                    // Enriched element private integration rule for regular (non fracture) sub elements
  QList<XfemSubElement*>                _subElements;           // A list with subelements from this element. Regular (non fracture) sub elements come first in the list.
  int                                   _nRegular;              // The number of "regular (or non fracture) sub-elements. Those are the first sub-elements in _subElements. 
  GmElementDof*                         _dofMap;                // The element dof mapping
  QList<GmVector>                       _elemInterInfo;         // A list with information about id of intersected fractures and crack nodes contained in a element {Crack's id, first crack node, second crack node}
  QList<GmVector>                       _subCrackInfo;          // A list with information about id of intersected fractures and crack nodes contained in a element {Crack's id, first crack node, second crack node}
  QList<GmVector>                       _interactingCraks;      // A list with information abaout strong and weak crack and location of the weak crack regarding the strong one for level set computation 
  QList<int>                            _numAddDOF;             // A list with the number of additional DOF per element
  QList<GmVector>                       _dofSet;                // A list with DOF sets to be used per element {Crack's id, DOF}
  QList<QPair<double, QList<GmVector>>> _NodedofSet;            // A list with node id and list with specific dof list different to the other nodes of the same element
  QList<QList<int>>                     _nodalLevelSet;         // A list with enrichment functions for element nodes
  QList<QList<int>>                     _gaussLevelSet;         // A list with enrichment functions for element gauss points
  QList<QList<int>>                     _TopLevelSet;           // A list with enrichment functions for element nodes
  QList<QList<int>>                     _BottomLevelSet;         // A list with enrichment functions for element gauss points
  QList<QPair<int, QList<QList<int>>>>  _gaussLevelSetInter;    // A list with enrichment functions for element gauss points when this element is neighborn to a crack intersection
  QList<QPair<int, QList<QList<int>>>>  _TopLevelSetInter;      // A list with enrichment functions for element nodes when this element is neighborn to a crack intersection
  QList<QPair<int, QList<QList<int>>>>  _BottomLevelSetInter;   // A list with enrichment functions for element gauss points when this element is neighborn to a crack intersection
  QList<QPair<bool, bool>>              _subCrackState;         // A list with Fracture segment info about hydraulic or Natural and Open or closed states 
  bool                                  _changeCrackState;      // Boolean to define when to evaluate a change in fracture state from close to open
  QList<bool>                           _crackReactivation;      // Boolean to define when to evaluate a change in fracture state from close to open
  QList<QPair<int, int>>                _crackFront;            // A list with edge nodes cut by a crack front node
  QList<QList<int>>                     _nearestElem;           // A list with crack front nodes and the nearest element to them
};
 
#endif