gmDiscontinuitySet.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2023 by Carlos Augusto Teixeira 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_DISCONTINUITY_SET_H_
#define _GEMA_DISCONTINUITY_SET_H_
 
#include "gmLog.h"
 
#include <QVector>
#include <unit.h>
#include "gmSurfaceCellIntersection.h"
#include "gmCellType.h"
#include "gmStateDumpItem.h"
#include <QDataStream>
 
class  GmDiscontinuity;
class  GmDiscontinuityAccessor;
struct GmSegmentCellIntersection;
class  GmCompact2DSegmentCellIntersection;
class  GmSegmentCell2DIntersectionCoordAccessor;
struct Gm3DSurfaceCellIntersection;
class  GmCell3DIntersectionCoordAccessor;
struct RayIntersection;
class  GmCell;
class  GmCellMesh;
class  GmValueSet;
class  GmPropertySet;
class  GmValueInfo;
class  GmSimulationData;
class  GmSpatialIndex;
class  LuaTable;
class  GmCellGeometryInfo;
class  GmBVHVisibility;
class  GmHdf5ModelReader;
 
 
class GMC_API_EXPORT GmDiscontinuitySet
{
public:
  enum DiscontinuityType
  {
    GM_DISC_POLYLINE,    
    GM_DISC_TRISURFACE,  
    GM_DISC_EDGELIST,    
    GM_DISC_FACELIST,    
    // -- If changes are made to this enum, please remember to adjust 
    //    discontinuityTypeToStr() and strToDiscontinuityType()
    GM_DISC_UNDEFINED,
  };
 
  using SegmentCell2DIntersectionList = QVarLengthArray<GmCompact2DSegmentCellIntersection*, 1>;
 
  GmDiscontinuitySet(GmSimulationData* simData, QString id, QString description, GmCellMesh* mesh, GmSpatialIndex* index,
      bool addElements, bool addGhostNodes, bool extraDofs, 
      double snapTol, double repelTol, double repelDistance, double parallelCosThreshold, 
      bool noInternalNodes, bool internalIntersections, bool discardOriginalGeometry, bool extendGeometry, bool visibilityOnly);
 
  ~GmDiscontinuitySet();
 
  QString id() const { return _id; }
 
  QString description() const { return _description; }
 
  DiscontinuityType type() const { return _type; }
 
  GmCellMesh* mesh() const { assert(!_visibilityOnly); return _mesh; }
 
  GmSpatialIndex* spatialIndex() const { return _index; }
 
  bool autoAddElements() const { return _addElements; }
 
  bool autoAddGhostNodes() const { return _addGhostNodes; }
 
  bool extraDofsInAddedElements() const { return _addedInterfElemHaveExtraDofs; }
 
  double snapTolerance() const { return _snapTol; }
 
  double repelTolerance() const { return _repelTol; }
 
  double repelDistance() const { return _repelDistance; }
 
  bool noInternalNodes() const { return _noInternalNodes; }             
 
  bool internalIntersections() const { return _internalIntersections; }
 
  bool discardOriginalGeometry() const { return _discardOriginalGeometry; }
 
  bool extendedOriginalGeometry() const { return _extendGeometry; }
 
  bool visibilityOnly() const { return _visibilityOnly; }
 
  int numDiscontinuities() const { return _data.size(); }
 
  const QVector<GmDiscontinuity*>& discontinuities() const { return _data; }
 
  int startAddedNodeIndex() const { return _startNode; }
 
  int discontinuityIndex(QString id) const;
 
  GmDiscontinuity* discontinuity(int index) { return _data[index]; }
 
  const GmDiscontinuity* discontinuity(int index) const { return _data[index]; }
 
  int dimension() const {
    switch(_type) {
    case GmDiscontinuitySet::GM_DISC_EDGELIST:
    case GmDiscontinuitySet::GM_DISC_POLYLINE:
      return 2;
    case GmDiscontinuitySet::GM_DISC_FACELIST:
    case GmDiscontinuitySet::GM_DISC_TRISURFACE:
      return 3;
    default:
      return -1;
    }
  }
 
  bool intersects(const GmCell* c, bool def) const;
 
  QStringList              attributeIds() const;
  GmValueInfo*             attributeInfo     (QString id) const;
  GmDiscontinuityAccessor* attributeAccessor (QString id, Unit desiredUnit, const GmLogCategory& logger) const;
  GmDiscontinuityAccessor* attributeAccessor (QString id, int snum, bool locked, Unit desiredUnit, const GmLogCategory& logger) const;
  int                      numAttributeStates(QString id) const;
 
  int numPropertySets() const { return _propertySets.size(); }
 
  const QVector<GmPropertySet*>& propertySets() const { return _propertySets; }
 
  int propertySetIndex(QString id) const;
 
  GmValueInfo*             propertyInfo    (QString id) const;
  GmDiscontinuityAccessor* propertyAccessor(QString id, Unit desiredUnit, const GmLogCategory& logger) const;
 
  bool buildIntersectionMaps(const GmLogCategory& logger);
 
  const SegmentCell2DIntersectionList&      cell2DPolylineIntersections(const GmCell* c) const;
  GmSegmentCell2DIntersectionCoordAccessor* cell2DPolylineCoordAccessor(Unit desiredUnit, const GmLogCategory& logger) const;
 
  const Gm3DSurfaceCellIntersection& cell3DSurfaceIntersections(const GmCell* c) const;
  GmCell3DIntersectionCoordAccessor* cell3DSurfaceCoordAccessor(Unit desiredUnit, const GmLogCategory& logger) const;
  const QMap<int, Gm3DSurfaceCellIntersection> cell3DSurfaceIntersectionsMap() const { return _elementSurfaceIntersectionMap; }
 
  static GmDiscontinuitySet* loadFromTable(LuaTable& tab, GmSimulationData* data, int type, const GmLogCategory& logger);
 
  bool loadFromDumpFile(QString dumpFile, GmSimulationData* data, const GmLogCategory& logger);
  bool loadFromHdf5File(GmHdf5ModelReader* reader, int dsIndex, const GmLogCategory& logger);
 
  bool loadFromTableAttrib(LuaTable& attrib, const GmLogCategory& logger, QVector<GmValueSet*>& outAttrib, int expectedSize = 0);
  bool loadFromTableProp(LuaTable& prop, const QMap<QString, GmPropertySet*>& propMap, const GmLogCategory& logger, QVector<GmPropertySet*>& outProp);
  bool loadFromTableDisc(LuaTable& disc, const QVector<QSharedPointer<GmValueAccessor>>& attAcc, int type, const GmLogCategory& logger);
 
  static DiscontinuityType getTypeFromTable(LuaTable& data);
  static QString getTableFieldFromType(DiscontinuityType type);
 
  bool setAttributes(const QVector<GmValueSet*>& attrib);
  bool setProperties(const QVector<GmPropertySet*>& prop);
 
  GmDiscontinuity* addDiscontinuity(QString id, DiscontinuityType dType, int* indexes, int ni, double* points, int np, const QVector<int>& propIndex, int cellGroupId = -1);
 
  void printParameters(const GmLogCategory& logger, GmLogLevel level) const;
  void print          (const GmLogCategory& logger, GmLogLevel level) const;
 
  size_t printMemoryStatistics(const GmLogCategory& logger, GmLogLevel level) const;
  size_t usedMemory() const;
 
  static QString discontinuityTypeToStr(DiscontinuityType type);
  static int     strToDiscontinuityType(QString str);
 
  /*  Checks visibility from point 'src' to 'dst'
   *  'dst' points near a discontinuity are considered to 
   *   be either always visible or not depending on the inclusive parameter.
   *   inclusive == true, then it is always visible
   *   inclusive == fase, the it is always invisible
   * 
   *   'eps' controls in absolute value how much is 'near'
   */
  bool checkVisibility(const double* src, const double* dst, bool inclusive, double eps = 3e-5) const;
 
  int getNumberOfDiscontinuities(const GmCell* c) const;
 
  int getNumberOfDiscontinuityElements(const GmCell* c) const;
 
  // Get the id of the discontinuity element (bar (2D)/triangle (3D)) k of the given cell in the mesh
  int getIdDiscontinuityElementInMesh(const GmCell* c, int k) const;
 
  // Get the ids of the discontinuity element (bar (2D)/triangle (3D)) k locally in the element
  int getLocalIdDiscontinuityElement(const GmCell* c, int k) const;
 
  // Fill the map with the global to local ids of the discontinuity elements nodes
  void fillDiscontinuityNodesGlobalToLocalMap(const GmCell* c, QMap<int, int>& globalToLocal) const;
 
  // Fill the discontinuity element local dof vector
  void fillDiscontinuityElementDofVector(int idMesh, const QMap<int, int>& dNodesGlobalToLocal, QVector<int>& dof) const;
 
  void getDiscontinuityGeometry(const GmCell* e, int id, GmVector& Xref, GmMatrix& mn) const;
  void getPolylineDiscontinuityGeometry(const GmCell* e, int id, GmVector& Xref, GmMatrix& mn) const;
  void getTrisurfDiscontinuityGeometry(const GmCell* e, int id, GmVector& Xref, GmMatrix& mn) const;
 
  inline static double heavisideFunction(const GmVector& X, const GmVector& Xref, const GmVector& nd);
 
  const QVector<GmVector3>& consolidated3DPoints() const { return _consolidatedPoints; }
  const QVector< Gm3DSurfacePointInfo>& consolidated3DPointsInfo() const { return _consolidatedPointsInfo; }
 
private:
  GmDiscontinuitySet(QString id, QString description, DiscontinuityType type, GmCellMesh* mesh,
                     GmSpatialIndex* index, bool addElements, bool addGhostNodes, bool extraDofs, double snapTol, double repelTol, 
                     double repelDistance, double parallelCosThreshold, bool noInternalNodes, bool internalIntersections, bool discardOriginalGeometry,
                     bool extendGeometry, bool visibilityOnly, GmSimulationData* simData);
 
  bool addIntersectionsToMesh(const GmLogCategory& logger);
  bool add2DSegmentCellIntersectionsToMesh(const GmLogCategory& logger);
  bool add3DTriangleCellIntersectionsToMesh(const GmLogCategory& logger);
  bool addGhostNodeIntersectionsToMesh(const GmLogCategory& logger);
  bool break2DPolylinesAtIntersections(const GmLogCategory& logger);
  bool extendGeometry(const GmLogCategory& logger);
 
  //Util for building 3D unique point map
  size_t encDiscPoint(int discId, int pointId) const;
  int push3DPoint(int discId, int pointId, GmIntersectionPointType ptype, const GmVector3& point);
  int get3DPoint(int discId, int pointId) const;
  inline void computeAxis(GmVector3& normal, GmVector3& tan) const;
  void removeUnused3DPoints();
 
  //Fill up _elementSurfaceIntersectionMap with 3D triSurface discontinuities
  bool consolidate3DSurfIntersections(const GmLogCategory& logger);
 
  void buildVisibilityBVH(const GmLogCategory& logger);
 
  QVector<QVector<int>>& getCellEEFaceMap(const GmCellType type);
 
  size_t usedElementMapMemory() const;
 
  void initResultAttributes(GmSimulationData* simulation);
 
  Q_DISABLE_COPY(GmDiscontinuitySet);
 
  QString           _id;          
  QString           _description; 
  DiscontinuityType _type;        
  GmCellMesh*       _mesh;        
  GmSpatialIndex*   _index;       
  bool              _addElements; 
  bool              _addGhostNodes; 
  bool              _addedInterfElemHaveExtraDofs; 
  double            _snapTol;                      
  double            _repelTol;                     
  double            _repelDistance;                
  double            _parallelCosThreshold;                 
  bool              _noInternalNodes;              
  bool              _internalIntersections;        
  bool              _discardOriginalGeometry;      
  bool              _extendGeometry;               
  bool              _intersectionsBuilt;           
  bool              _visibilityOnly;               
 
  QVector<GmValueSet*>      _attributes;    
  QVector<GmPropertySet*>   _propertySets;  
  QVector<GmDiscontinuity*> _data;          
  QMap<QString, int>        _attributesMap; 
  QMap<QString, int>        _dataMap;       
 
  QMap<int, SegmentCell2DIntersectionList> _elementPolylineIntersectionsMap;
  QMap<int, Gm3DSurfaceCellIntersection> _elementSurfaceIntersectionMap;
  QHash<GmCellType, QVector<QVector<int>>> _cellEEFaceMap;
  GmBVHVisibility* _visibilityBVH;
  GmSimulationData* _simData;
 
  int _startNode;                                        
  QMap<size_t, int>  _pointMapId;                        
  QVector<GmVector3> _consolidatedPoints;                
  QVector<Gm3DSurfacePointInfo> _consolidatedPointsInfo; 
  friend class GmDiscontinuitySetStateDumpItem;
  friend QDataStream& operator<<(QDataStream&, const GmDiscontinuitySet&);
  friend QDataStream& operator>>(QDataStream&, GmDiscontinuitySet&);
 
  friend class GmLuaDiscontinuitySet;
 
  //Static members used for statistics tracking
  static int _dsItem;
  static int _buildItem;
  static int _extendGItem;
  static int _intersecItem;
  static int _consol3Ditem;
  static int _add2MeshItem;
  static int _buildVisItem;
  //DEBUG
  void DebugCells();
};
 
class GMC_API_EXPORT GmDiscontinuitySetStateDumpItem : public GmGroupDumpItem
{
public:
 
    GmDiscontinuitySetStateDumpItem(GmDiscontinuitySet* ds);
 
    virtual ~GmDiscontinuitySetStateDumpItem();
 
    virtual bool addStateItemsToGroup(GmStateDump* state, int groupId);
    virtual bool stateLoaded(GmStateDump* state);
 
    virtual bool fillDumpControlMapData(QVariantMap* map, const GmLogCategory& logger);
    virtual bool dumpControlMapDataLoaded(QVariantMap* map, const GmLogCategory& logger);
 
private:
    GmDiscontinuitySet* _ds;
    QVariantMap _controlMap;
};
 
//QT serialization operators
QDataStream& operator<<(QDataStream&, const GmDiscontinuitySet::SegmentCell2DIntersectionList&);
QDataStream& operator>>(QDataStream&, GmDiscontinuitySet::SegmentCell2DIntersectionList&);
 
QDataStream& operator<<(QDataStream&, const RayIntersection&);
QDataStream& operator>>(QDataStream&, RayIntersection&);
 
#endif // _GEMA_DISCONTINUITY_SET_H_