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 <gmpCellMeshBase.h>
#include <gmpGemaCellMeshData.h>

class XfemEnrichedElementData;
class XfemIntegrationRule;
class XfemSubElement;
class XfemFracture;

class XfemMesh : public GmpMeshBaseDataInterface<GmElementMesh, GmpGemaMeshData<XfemVector>, GmpGemaCellMeshData<XfemVector>>
{
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 GmGaussValueSet* createGaussValueSet(GmValueInfo* info);

  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, GmpGemaMeshCoordAccessor<GmpGemaMeshData<XfemVector>, XfemVector>,
                        GmpGemaMeshGhostCoordAccessor<GmpMeshData<XfemVector>, XfemVector>,
                        GmpGemaMeshData<XfemVector>, GmpGemaCellMeshData<XfemVector>,
                        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();

  virtual GmpGemaMeshData<XfemVector>*     theNodeData() { return &_nd; }
  virtual GmpGemaCellMeshData<XfemVector>* theCellData() { return &_cd; }

protected:

  virtual GmpMeshLoader<XfemVector>* meshLoader() { return new XfemMeshLoader(simulationData(), logger()); }

  virtual GmpMeshLoaderCellAllocator 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, GmpGemaCellMeshData<XfemVector>>;
  }

#ifdef ENABLE_TESTS
  friend Q_DECL_EXPORT XfemMesh* TEST_XfemBuildTestMesh(GmSimulationData*, const GmLogCategory&);
#endif
};


#endif