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 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();

  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 bool loadFromDumpFile(T* bc, QString dumpFile, GmSimulationData* data, const GmLogCategory& logger, 
                               QString msgPrefix);

  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;

  // 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; 

  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);

private:
  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