gmBoundaryCondition.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_BOUNDARY_CONDITION_H_
#define _GEMA_BOUNDARY_CONDITION_H_
 
#include "gmCoreConfig.h"
#include "gmLog.h"
#include "gmStateDumpItem.h"
 
#include <QString>
#include <unit.h>
#include <assert.h>
 
class GmMesh;
class GmCell;
class GmBoundaryConditionAccessor;
class GmCellBoundary;
class GmNodeSet;
class GmValueInfo;
class GmValueSet;
class GmValueAccessor;
class GmSimulationData;
class LuaTable;
 
class BcNodeSet;
class BcCellBoundary;
class BcTaggedPtr;
class GmNanBoxedValue;
class GmBoundaryConditionStateDumpItem;
class GmStateDumpBufferDataItem;
class GmHdf5ModelReader;
 
class GMC_API_EXPORT GmBoundaryConditionBase
{
public:
  enum BcType
  {
    GM_BC_NODE,  
    GM_BC_EDGE,  
    GM_BC_FACE,  
    GM_BC_CELL,  
    // -- If changes are made to this enum, please remember to adjust 
    //    bcTypeToStr() and strToBcType()
  };
 
  virtual ~GmBoundaryConditionBase();
 
  QString id() const { return _id; }
 
  QString description() const { return _description; }
 
  QString type() const { return _type; }
 
  GmMesh* mesh() const { return _mesh; }
 
  BcType bcType() const { return _bcType; }
 
  int numValues() const { return _numValues; }
 
  int numProperties() const { return _userPropertiesData.size(); }
 
  QStringList  propertyIds () const;
  GmValueInfo* propertyInfo(QString propertyId) const;
 
  bool addProperty(GmValueInfo* info, GmSimulationData* data, const GmLogCategory& logger);
 
  int     numNodes          (int bcIndex) const;
  int     node              (int bcIndex, int nodeIndex) const; 
  GmCell* cell              (int bcIndex) const;
  int     numBoundaryCells  (int bcIndex) const;
  GmCell* boundaryCell      (int bcIndex, int cellIndex) const;
  int     boundaryCellBorder(int bcIndex, int cellIndex) const;
 
  const GmCellBoundary* boundary(int bcIndex) const; 
  GmCellBoundary*       boundary(int bcIndex);
  const GmNodeSet*      nodeSet (int bcIndex) const;
  GmNodeSet*            nodeSet (int bcIndex);
 
  void clear();
 
  void setNode    (int bcIndex, int node);
  void setNode    (int bcIndex, GmCellBoundary* boundary);
  void setNode    (int bcIndex, GmNodeSet* nodeSet);
  void setNode    (int bcIndex, int numNodes, int* nodes);
  void setCell    (int bcIndex, int cell);
  void setBoundary(int bcIndex, int cell, int border);
  void setBoundary(int bcIndex, GmCellBoundary* boundary);
  void setBoundary(int bcIndex, int numCells, int* cells, int* borders);
 
  void reloadNodeBoundaryData(int bcIndex);
 
  int  addLines(int n = 1);
  void removeLines(int bcIndex, int n = 1);
 
  int addNodeLine(int node) { int index = addLines(); if(index >= 0) setNode(index, node); return index; }
 
  int addNodeLine(GmCellBoundary* boundary) { int index = addLines(); if(index >= 0) setNode(index, boundary); return index; }
 
  int addNodeLine(GmNodeSet* nodeSet) { int index = addLines(); if(index >= 0) setNode(index, nodeSet); return index; }
 
  int addNodeLine(int numNodes, int* nodes) { int index = addLines(); if(index >= 0) setNode(index, numNodes, nodes); return index; }
 
  int addCellLine(int cell) { int index = addLines(); if(index >= 0) setCell(index, cell); return index; }
 
  int addBoundaryLine(int cell, int border) { int index = addLines(); if(index >= 0) setBoundary(index, cell, border); return index; }
 
  int addBoundaryLine(GmCellBoundary* boundary) { int index = addLines(); if(index >= 0) setBoundary(index, boundary); return index; }
 
  int addBoundaryLine(int numCells, int* cells, int* borders) { int index = addLines(); if(index >= 0) setBoundary(index, numCells, cells, borders); return index; }
 
  void print(const GmLogCategory& logger, GmLogLevel level, int summary) const;
 
  size_t printMemoryStatistics(const GmLogCategory& logger, GmLogLevel level) const;
  size_t usedMemory() const;
 
  static QString bcTypeToStr(BcType type);
  static int     strToBcType(QString str);
 
private:
  Q_DISABLE_COPY(GmBoundaryConditionBase);
 
protected:
  GmBoundaryConditionBase(QString id, QString description, QString type, GmMesh* mesh, BcType bcType);
 
  virtual void clearObjects();
  void clearIndex(int bcIndex);
 
  template <class T>
  static T* loadStructureFromBaseTable(LuaTable& tab, GmSimulationData* data, int dataType, const GmLogCategory& logger,
                                       int* merge, QString& dataTabName, QList<GmValueAccessor*>& acList,
                                       QString msgPrefix = "", const QList<GmValueInfo*>& appPointInfoList = QList<GmValueInfo*>());
 
  template <class T>
  static T* loadFromBaseTable(LuaTable& tab, GmSimulationData* data, const GmLogCategory& logger,
                              QString msgPrefix = "", const QList<GmValueInfo*>& appPointInfoList = QList<GmValueInfo*>());
 
  template <class T>
  static T* loadFromHdf5File(LuaTable& tab, GmSimulationData* data, GmHdf5ModelReader* hdf5Reader, const GmLogCategory& logger,
                             QString msgPrefix = "", const QList<GmValueInfo*>& appPointInfoList = QList<GmValueInfo*>());
 
  template <class T>
  static T* loadFromDumpFile(LuaTable& tab, GmSimulationData* data, QString dumpFile, const GmLogCategory& logger,
                             QString msgPrefix = "", const QList<GmValueInfo*>& appPointInfoList = QList<GmValueInfo*>());
 
  virtual QString msgPrefix() const { return ""; }
 
  virtual void printExtraHeaderInfo(const GmLogCategory& logger, GmLogLevel level) const { Q_UNUSED(logger); Q_UNUSED(level); }
 
  virtual void printExtraPropertyValues(const GmLogCategory& logger, GmLogLevel level) const { Q_UNUSED(logger); Q_UNUSED(level); }
 
  size_t appPointUsedMemory() const;
 
  GmValueAccessor* userValueAccessor(QString propertyId, Unit desiredUnit, const GmLogCategory& logger) const;
 
  QString nodeListStr        (int bcIndex, int titleSize, bool align, bool* cropped) const;
  QString cellBoundaryListStr(int bcIndex, int titleSize, bool* cropped) const;
 
  bool mergeLines(LuaTable& tab, int tabSize, const QList<GmValueAccessor*>& acList, int maxLines, 
                  const GmLogCategory& logger, QVector<int>& transTable, QVector<int>& countTable);
 
  bool parseValueFromVariant(GmValueAccessor* ac, const QVariant& v, GmNanBoxedValue* data, const GmLogCategory& logger);
 
  friend class GmBoundaryConditionAccessor;
  friend class GmContactBoundaryConditionAccessor;
  int appPointIndex(int bcIndex, int listIndex) const;
 
  // The following functions allow for the model writer object to have access to internal node and 
  // boundary sets created when MERGING BC lines. Those are needed by the model writer but are not
  // general purpose methods, exposing an internal implementation detail.
  friend class GmHdf5ModelWriter;
  const QVector<const GmNodeSet*>&      mergedNodeSets()   const { return _mergedNodeSets; }
  const QVector<const GmCellBoundary*>& mergedBoundaries() const { return _mergedBoundaries; }
 
  const GmNodeSet*      mergedNodeSet (int bcIndex) const;
  const GmCellBoundary* mergedBoundary(int bcIndex) const;
 
  // State dumping capabilities delegated to GmBoundaryConditionStateDumpItem in order to 
  // keep GmBoundaryConditionBase simpler
  friend class GmBoundaryConditionStateDumpItem; 
 
  QString _id;          
  QString _description; 
  QString _type;        
  GmMesh* _mesh;        
  BcType  _bcType;      
  
  int     _numValues;   
 
  QMap<QString, int>   _userPropertiesMap;      
  QVector<GmValueSet*> _userPropertiesData;     
  QVector<GmValueSet*> _appPointPropertiesData; 
  bool                 _appPointUserProperties; 
 
  QVector<const GmNodeSet*>      _mergedNodeSets;   
  QVector<const GmCellBoundary*> _mergedBoundaries; 
 
  QVarLengthArray<BcTaggedPtr, 1>* _appPointData;
};
 
class GMC_API_EXPORT GmBoundaryCondition : public GmBoundaryConditionBase
{
public:
  GmBoundaryCondition(QString id, QString description, QString type, GmMesh* mesh,
                      BcType bcType)
    : GmBoundaryConditionBase(id, description, type, mesh, bcType), _hasTaggedFunctionAccessors(false) {}
 
  virtual ~GmBoundaryCondition();
 
  GmBoundaryConditionAccessor* propertyAccessor(QString propertyId, Unit desiredUnit, const GmLogCategory& logger) const;
 
  bool hasTags() const { return !_taggedProperties.isEmpty(); }
 
  bool tagNeedsPerNodeEvaluation() const { return _hasTaggedFunctionAccessors; }
 
  quint64 tagMask(int bcIndex, int listIndex) const;
 
  static GmBoundaryCondition* loadFromTable(LuaTable& tab, GmSimulationData* data, const GmLogCategory& logger);
  static GmBoundaryCondition* loadFromTableAndHdf5File(LuaTable& tab, GmSimulationData* data, GmHdf5ModelReader* hdf5Reader, const GmLogCategory& logger);
  static GmBoundaryCondition* loadFromTableAndDumpFile(LuaTable& tab, GmSimulationData* data, QString dumpFile, const GmLogCategory& logger);
 
private:
  static void adjustTagInfo(GmBoundaryCondition* bc, const GmLogCategory& logger);
 
  QVector<int> _taggedProperties; 
  QVector<GmBoundaryConditionAccessor*> _taggedAccessors; 
  bool _hasTaggedFunctionAccessors; 
};
 
 
class GMC_API_EXPORT GmBoundaryConditionStateDumpItem : public GmGroupDumpItem
{
public:
  GmBoundaryConditionStateDumpItem(GmBoundaryCondition* bc);
 
  virtual ~GmBoundaryConditionStateDumpItem();
 
  virtual bool addStateItemsToGroup(GmStateDump* state, int groupId);
 
  virtual bool fillDumpControlMapData  (QVariantMap* map, const GmLogCategory& logger);
  virtual bool dumpControlMapDataLoaded(QVariantMap* map, const GmLogCategory& logger);
 
  virtual bool stateLoaded(GmStateDump* state);
 
private:
  GmBoundaryCondition*       _bc;              
  QVariantMap                _controlMap;      
  QMap<uintptr_t, QString>   _translationMap;  
  char*                      _appPointDataPtr; 
  GmStateDumpBufferDataItem* _auxObjDumpItem;  
  QVector<void*>             _auxObj;          
};
 
 
 
#endif