xfemFracture.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_FRACTURE_H_
#define _GEMA_XFEM_FRACTURE_H_
 
#include <assert.h>
#include <QList>
#include "gmVector.h"
#include <gmMatrixUtils.h>
 
class XfemFracture
{
public:
        XfemFracture(int npoints, int ndim, double* coordinates, const QString& fracType = QString("HydraFrac"), const QString& fracState = QString("Open"));
 
  virtual ~XfemFracture();
 
  XfemFracture(const XfemFracture& other)
  {
          _npoints = other._npoints;                   
          _ndim = other._ndim;                         
          _npointsCrack = other._npointsCrack;         
          _headIp = other._headIp;                     
          _tailIp = other._tailIp;                     
          _crackPath = other._crackPath;               
          _subCrackPath = other._subCrackPath;         
          _elemCutPos = other._elemCutPos;             
          _crackCoordinates = other._crackCoordinates; 
          _changedElem = other._changedElem;           
          _isStrongFrac = other._isStrongFrac;         
          _head = other._head;                         
          _tail = other._tail;                         
          _headProp = other._headProp;                 
          _tailProp = other._tailProp;                 
          _changedCrack = other._changedCrack;
          _fracType = other._fracType;
          _fracState = other._fracState;
          _coordinates = new double[_npoints*_ndim];   
          memcpy(_coordinates, other._coordinates, _npoints*_ndim*sizeof(double));
  }
 
  int numPoints() const { return _npoints; }
  int numCrackPoints() const { return _npointsCrack; }
  int numCrackPaths() const { return _crackPath.size(); }
  int numSubCrackPaths() const { return _subCrackPath.size(); }
  int numElemCutPos() const { return _elemCutPos.size(); }
  int numSubElemCutPos() const { return _subElemCutPos.size(); }
  int numElemHeadIp() const { return _headIp.size(); }
  int numElemTailIp() const { return _tailIp.size(); }
  int numChangedElem() const { return _changedElem.size(); }
  int numfrontNodeBool() const { return _frontNodeBool.size(); }
  int numfrontNodeProp() const { return _frontNodeProp.size(); }
  int pointDimension() const { return _ndim; }
  void fixedHead() { _head = false; _headProp = false; } // verificar depois
  bool checkHeadStatus() const { return _head; }
  void fixedTail() { _tail = false; _tailProp = false; } // verificar depois
  bool checkTailStatus() const { return _tail; }
  void headProp(bool setHead=true) { _headProp = setHead; }
  bool checkHeadProp() const { return _headProp; }
  void tailProp(bool setTail=true) { _tailProp = setTail; }
  bool checkTailProp() const { return _tailProp; }
  QString checkFracType() const { return _fracType; }
  QString checkFracState() const { return _fracState; }
  void setIntactCrackDOFset() { _changedCrack = false; }
  void changeCrackDOFset() { _changedCrack = true; }
  bool checkCrackDOFset() const { return _changedCrack; }
 
  const double* coordinates(int index) const { assert(index >= 0 && index < _npoints); return _coordinates + index * _ndim; }
  // add crack coordinates
  void appendCrackCoordinates(QList<GmVector> B, bool type = true);
  // add crack coordinates
  void insertCrackCoordinates(GmVector C, int index);
  // replace crack coordinates
  void replaceCrackCoordinates(GmVector B, int index);
  // split crack coordinates
  void splitCrackCoordinates(int index2, int index, bool type = true);
  // get crack coordiantes
  void virtual getCrackCoodinates(GmVector& S1, int n) const;
  // Add crack path
  void appendCrackPath(GmVector Cr, bool type = true);
  // Add a point to a crack path, splitting it in two
  void splitCrackPath(int path, int node);
  // Add list with sub-crack paths
  void insertSubCrackPath(int path, GmVector A, GmVector B);
  // Get sub-crack path data
  void virtual getCrackPath(GmVector& A, int n) const;
  // Add sub-crack path
  void appendSubCrackPath(GmVector Cr, bool type = true);
  // Get sub-crack path data
  void virtual getSubCrackPath(GmVector& A, int n) const;
  // Add Changed Elements
  void appendChangedElem(QList<int> n);
  // Get Changed Elements
  void virtual getChangedElem(QList<int>& data) const;
  // Clear changed element list
  void clearChangedElem() { _changedElem.clear(); }
  // Add crack front nodes
  void appendCrackFrontNodes(QList<QList<int>> n);
  // Get crack front nodes
  void virtual getCrackFrontNodes(QList<QList<int>>& data) const;
  //Replace crack front node list at a specific location
  void replaceCrackFrontNodes(QList<int> n, int index);
  // Clear crack front nodes
  void clearCrackFrontNodes() { _crackFront.clear(); }
  // Add Integration Points belonging to the region around crack front
  void appendCrackFrontIp(QList<QList<QPair<int, QList<QList<int>>>>> crackFrontSeglist);
  // Get crack front ip
  void virtual getCrackFrontIp(QList<QList<QPair<int, QList<QList<int>>>>>& crackFrontSeglist) const;
  // Clear crack front ip
  void clearCrackFrontIp() { _crackFrontSeglist.clear(); }
  // Add crack front node booleans
  void appendFrontNodeBool(QPair<int, bool> n);
  // Get crack front node booleans
  void virtual getFrontNodeBool(int n, QPair<int, bool>& data) const;
  //Replace crack front node booleans at a specific location
  void replaceFrontNodeBool(int n, QPair<int, bool> data);
  // Clear crack front node booleans
  void clearFrontNodeBool() { _frontNodeBool.clear(); }
  // Add crack front node propagation
  void appendFrontNodeProp(QPair<int, bool> n);
  // Get crack front node propagation
  void virtual getFrontNodeProp(int n, QPair<int, bool>& data) const;
  //Replace crack front node booleans at a specific location
  void replaceFrontNodeProp(int n, QPair<int, bool> data);
  // Clear crack front node propagation
  void clearFrontNodeProp() { _frontNodeProp.clear(); }
  // Add ip head info
  void setHeadIp(QList<GmVector> B);
  // Get head ip data
  void virtual getHeadIp(GmVector& A, int n) const;
  // Clear head ip list
  void clearHeadIp() { _headIp.clear(); }
  // Add ip tail info
  void setTailIp(QList<GmVector> B);
  // Get tailip data
  void virtual getTailIp(GmVector& A, int n) const;
  // Clear tail ip list
  void clearTailIp() { _tailIp.clear(); }
  // Add element cut information
  void appendElemCutPos(GmVector cut, bool type = true);
  // Add a point to a element cut information, splitting it in two
  void splitElemCutPos(int path, int edge);
  // Get element cut information
  void virtual getElemCutPos(GmVector& S1, int n) const;
  // Add subelement cut information
  void appendSubElemCutPos(GmVector cut, bool type = true);
  // Get subelement cut information
  void virtual getSubElemCutPos(GmVector& S1, int n) const;
  // Add list with subelement cut information
  void insertSubElemCutPos(int path, GmVector A, GmVector B);
 
private:
  int                _npoints;          
  int                _ndim;             
  int                _npointsCrack;     
  QList<GmVector>    _headIp;           
  QList<GmVector>    _tailIp;           
  QList<GmVector>    _crackPath;        
  QList<GmVector>    _subCrackPath;     
  QList<GmVector>    _elemCutPos;       
  QList<GmVector>    _subElemCutPos;    
  QList<GmVector>    _crackCoordinates; 
  QList<int>         _changedElem;      
  double*            _coordinates;      
  bool               _isStrongFrac;     
  bool               _head;             
  bool               _tail;             
  bool               _headProp;         
  bool               _tailProp;         
  bool               _changedCrack;     
  QString            _fracType;         // Strhig to define if this fracture is a Hydraulic or a natural one
  QString            _fracState;        // Strhig to define if this fracture is open or closed
  QList<QList<int>>  _crackFront;       
  QList<QList<QPair<int, QList<QList<int>>>>> _crackFrontSeglist;       
  QList<QPair<int, bool>> _frontNodeBool;//Crack front node list (TRUE defines that it's available to propagate)
  QList<QPair<int, bool>> _frontNodeProp;//Crack front node list (TRUE defines that it has to propagate)
};
 
#endif