xfemMesh.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_MESH_H_
#define _GEMA_XFEM_MESH_H_
 
#include <gmElementMesh.h>
 
#include "xfemElement.h"
#include "xfemMeshLoader.h"
 
#include "xfemLuaMesh.h"
#include "xfemLuaElement.h"
#include "xfemGaussAccessor.h"
 
#include <gmpCellMesh.h>
 
class XfemEnrichedElementData;
class XfemIntegrationRule;
class XfemSubElement;
class XfemFracture;
 
 
class XfemMesh : public GmElementMesh
{
public:
  XfemMesh(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger);
 
  virtual ~XfemMesh();
 
  virtual void printValues(const GmLogCategory& logger, int options);
 
  virtual const XfemElement* element(int index) const { return (XfemElement*)cell(index); }
 
  virtual XfemElement* element(int index) { return (XfemElement*)cell(index); }
 
  virtual bool enrichElement(XfemElement* e);
 
  virtual XfemEnrichedElementData* enrichedElementData(const XfemElement* e) const;
  
  const QMap<int, XfemEnrichedElementData*>& enrichedElementMap() const { return _elementMap; }
 
  virtual int                   numRegularSubElements (const XfemElement* e) const;
  virtual int                   numFractureSubElements(const XfemElement* e) const;
  virtual const XfemSubElement* subElement            (const XfemElement* e, int index) const;
  virtual const XfemSubElement* fractureSubElement    (const XfemElement* e, int index) const;
  virtual void                  clearSubElements();
  virtual void                  clearSubElements(XfemElement* e);
  virtual int                   addSubElement   (XfemElement* e, XfemSubElement* se, int ruleSet = 0);
  virtual void                  removeSubElement(XfemElement* e, int index);
  virtual void                  updateSubElementCoordinates(XfemElement* e, int index, const GmMatrix& seNaturalCoords, 
                                                            int ruleSet = 0);
 
  const GmIntegrationRule* enrichedElementRegularIntegrationRule (const XfemElement* e,     int ruleSet) const;
  const GmIntegrationRule* enrichedElementFractureIntegrationRule(const XfemSubElement* se, int ruleSet) const;
 
  virtual XfemGaussAccessor* enrichedGaussAttributeAccessor(QString id, Unit desiredUnit, const GmLogCategory& logger) const
  {
    return enrichedGaussAttributeAccessor(id, 0, true, desiredUnit, logger);
  }
 
  virtual XfemGaussAccessor* enrichedGaussAttributeAccessor(QString id, int snum, bool locked, Unit desiredUnit, const GmLogCategory& logger) const;
  
  virtual const QList<XfemFracture*>& naturalFractures() const { return _naturalFractures; }
  
  virtual void addNaturalFracture(XfemFracture* f) { _naturalFractures.append(f); }
  
  virtual void clearNaturalFractures();
 
  virtual GmVector getElemCutInfo( int id) const { return _elemCutInfo.at(id); }
 
  virtual void addElemCutInfo(QList<GmVector> eCI) { _elemCutInfo.append(eCI); }
 
  virtual void deleteElemCutInfo() { _elemCutInfo.clear(); }
  
  virtual int sizeElemCutInfo() { return _elemCutInfo.size(); }
 
  virtual int getTotalNumDOF(int id) const { return _totalDofSet.at(id); }
 
  virtual void addTotalNumDOF(QList<int> eCI) { _totalDofSet.append(eCI); }
 
  virtual void deleteTotalNumDOF() { _totalDofSet.clear(); }
 
  virtual int sizeTotalNumDOF() { return _totalDofSet.size(); }
 
  virtual QString getNodeStateVarIds(int id) const { return _nodeStateVarIds.at(id); }
 
  virtual void addNodeStateVarIds(QStringList eCI) { _nodeStateVarIds.append(eCI); }
 
  virtual void deleteNodeStateVarIds() { _nodeStateVarIds.clear(); }
 
  virtual int sizeNodeStateVarIds() const { return _nodeStateVarIds.size(); }
 
  void setCubicLaw(bool cubicLaw) { _cubicLaw = cubicLaw; }
 
  virtual bool getCubicLaw() const { return _cubicLaw; }
 
  void setMultiPhasic(bool multiPhasic) { _multiPhasic = multiPhasic; }
 
  virtual bool getMultiPhasic() const { return _multiPhasic; }
 
  void setNonIsoThermal(bool nonIsoThermal) { _nonIsoThermal = nonIsoThermal; }
 
  virtual bool getNonIsoThermal() const { return _nonIsoThermal; }
 
  void setSaturationRelativePermeabilityModel(char nonIsoThermal) { _SaRelPer = nonIsoThermal; }
 
  virtual bool getSaturationRelativePermeabilityModel() const { return _SaRelPer; }
 
  virtual QList<int> getNodeTopologicalMap(int i) const { return _nodeTopologicalMap.at(i); }
 
  virtual void addNodeTopologicalMap(QList<int> eCI) { _nodeTopologicalMap.append(eCI); }
 
  virtual QList<int> getElemTopologicalMap(int i) const { return _elemTopologicalMap.at(i); }
 
  virtual void addElemTopologicalMap(QList<int> eCI) { _elemTopologicalMap.append(eCI); }
  
  virtual QList<QPair<int, QList<int>>> getfaceTopologicalMap(int i) const { return _faceTopologicalMap.at(i); }
 
  virtual void addFaceTopologicalMap(QList<QPair<int, QList<int>>> eCI) { _faceTopologicalMap.append(eCI); }
 
 
protected:
  virtual GmGaussValueSetGroup* createGaussValueSetGroup(GmSimulationData* simulation, GmElementMesh* mesh);
 
  virtual void clearXfemData();
 
private:
  QMap<int, XfemEnrichedElementData*> _elementMap;        
  QList<XfemFracture*>                _naturalFractures;  
  QList<GmVector>                     _elemCutInfo;       
  QList<int>                          _totalDofSet;       
  QStringList                         _nodeStateVarIds;   // list with the state variable ids in the model
  bool                                _cubicLaw;          // Boolean to define whether cubic law or constant fracture permeability is used
  bool                                _multiPhasic;       // Boolean to define whether multiphasic analysis is carried out
  bool                                _nonIsoThermal;     // Boolean to define whether non-isothermal analysis is carried out
  char                                _SaRelPer;          // Char defining the Saturation and Relative Permeability Model
  QList<QList<int>>                   _nodeTopologicalMap;// Node list with element id who contain them 
  QList<QList<int>>                   _elemTopologicalMap;// list of element neighbors with element id who contain them 
  QList<QList<QPair<int, QList<int>>>>_faceTopologicalMap;// list of element neighbors for each face of the element
};
 
 
 
typedef GmpCellMeshBase<XfemMesh, XfemVector> XfemGemaMeshBase;
 
 
class XfemGemaMesh : public XfemGemaMeshBase
{
public:
  XfemGemaMesh(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger)
    : XfemGemaMeshBase(simulation, id, description, logger) {}
 
  // Comments on the base class
  virtual const char* pluginName() const { return "Xfem"; }
 
  // Comments on the base class
  virtual const char* pluginType() const { return "mesh"; }
 
  // Comments on the base class
  virtual bool hasCapability(QString capabilityName) const
  {
    if(capabilityName == "stateDump")
      return false;
    return (capabilityName == "enrichment") || XfemGemaMeshBase::hasCapability(capabilityName);
  }
 
  // Comments on the base class
  virtual void pushProxy(lua_State* L, const GmLogCategory& logger) { LuaProxy::pushObject(L, new XfemLuaMesh(this, logger)); }
 
  virtual void clear();
 
protected:
 
  virtual GmpMeshLoader<XfemVector>* meshLoader() { return new XfemMeshLoader(simulationData(), logger()); }
 
  virtual GmpCellAllocator cellAllocator(bool ghostSupport, bool hSupport) const
  {
    Q_UNUSED(ghostSupport);  Q_UNUSED(hSupport);
    assert(!hSupport);  // No support for XFEM hierarchical elements!!!!
 
    return GmpCellFactory<XfemGemaElement, XfemElement, XfemLuaElement, GmpCellMeshData<XfemVector>>;
  }
 
  virtual int cellSize(bool ghostSupport, bool hSupport) const
  {
    Q_UNUSED(ghostSupport);  Q_UNUSED(hSupport);
    assert(!hSupport);  // No support for XFEM hierarchical elements!!!!
 
    return GmpCellSize<XfemGemaElement, XfemElement, XfemLuaElement, GmpCellMeshData<XfemVector>>();
  }
 
#ifdef ENABLE_TESTS
  friend Q_DECL_EXPORT XfemMesh* TEST_XfemBuildTestMesh(GmSimulationData*, const GmLogCategory&);
#endif
};
 
 
#endif