gmpFemAssembler.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_PLUGIN_FEM_ASSEMBLER_H_
#define _GEMA_PLUGIN_FEM_ASSEMBLER_H_
 
#include <QList>
#include <QVector>
#include <QHash>
#include <gmElementMesh.h>
#include <gmElementDof.h>
#include <gmElement.h>
#include <gmThreadLocalBuffer.h>
 
#include "gmpFemProcessConfig.h"
 
class GmpFemPhysics;
class GmpFemMatrixSet;
class GmpFemVectorSet;
class GmpFemLocker;
 
class GmStateVar;
class GmLogCategory;
class GmSolverMatrix;
 
class GmpFemAssemblerMatrixAdder;
class GmpFemAssemblerVectorAdder;
 
class GmpFemAssemblerMatrixCombiner;
class GmpFemAssemblerVectorCombiner;
 
class GmSparseMatrixLayoutBuilder;
 
// Enable the define  below to force validation of internal structures after assembler initialization
// #define ENABLE_ASSEMBLER_TESTS
 
 
class GMP_FEM_PROCESS_API_EXPORT GmpFemAssembler
{
public:
 
  enum FixedDofMode
  {
    NO_DOF_HANDLING,  
    REMOVE_DOF,       
  }; 
 
  enum GhostDofMode
  {
    GHOST_SUPPORT,      
    NO_GHOST_SUPPORT,   
    AUTO_GHOST_SUPPORT, 
  };
 
  enum UpdateMode
  {
    NODES_ADDED       = 0x001,   
    DOFS_ADDED        = 0x002,   
    DOFS_REMOVED      = 0x004,   
    ELEMENTS_ADDED    = 0x008,   
    ELEMENTS_REMOVED  = 0x010,   
 
    FIXED_BCS_UPDATE  = 0x020,   
    FIXED_BCS_CHANGED = 0x040,   
    FIXED_BCS_ALL     = 0x080,   
    FIXED_BCS_KEEPOLD = 0x100,   
 
    FULL_UPDATE       = 0x4000, 
    SAVE_MAPPING_INFO = 0x8000, 
  };
 
  GmpFemAssembler(GmElementMesh* mesh, const QVector<GmpFemPhysics*>& physics);
  ~GmpFemAssembler();
  
  bool init(GmpFemMatrixSet* matSet, GmpFemVectorSet* vecSet, FixedDofMode fixedMode, 
            GhostDofMode ghostMode, bool enableFastUpdate, bool createReverseMapping, 
            int numThreads, QString& err);
  bool update(int mode, QString& err);
 
  void setBcWarningMode(bool warnOnFixedInvalidDof, bool warnOnFixedDofConflict)
  {
    _warnOnFixedInvalidDof  = warnOnFixedInvalidDof;
    _warnOnFixedDofConflict = warnOnFixedDofConflict;
  }
 
  void setPartitions(int npart);
 
  int numDof() const { return _nMatrixDof; }
 
  int numTotalDof() const { return _nTotalDof; }
 
  // Returns the number of fixed degrees of freeedom handled by the assembler. Equal to numTotalDof() - numDof()
  int numFixedDof() const { return _nTotalDof - _nMatrixDof; }
 
  int numElementDof(const GmElement* e, int physicsIndex) const;
 
  int maxElementDof() const { return _elemIndexMap.size(); }
 
  int dofIndex    (int node, int dof) const;
  int fillIndexMap(const GmElement* e, int physicsIndex, int* indexMap, const GmElementDof*& dofMap);
 
  double dofFixedValue(int index) { assert(index < 0); return _fixedValues[abs(index+1)]; }
 
  GmStateVar* stateVar (int globalIndex);
  int         svGroupId(int globalIndex);
 
  const QVector<QPair<GmStateVar*, GmValueAccessor*> >& stateVars() const { return _stateVars; }
 
  Unit timeUnit() const { return _timeUnit; }
 
  bool beginAssembly();
  bool endAssembly(bool discardData = false);
  const int* addElementData(const GmElement* e, int physicsIndex, 
                            const GmpFemAssemblerMatrixCombiner* matCombiner,
                            const GmpFemAssemblerVectorCombiner* vecCombiner);
  bool addLocalMatrixData  (GmMatrixDof& localDofMap, 
                            const GmpFemAssemblerMatrixCombiner* matCombiner,
                            const GmpFemAssemblerVectorCombiner* vecCombiner);
 
  void saveResultData(const GmVector& data, double lambda = 1.0);
  void saveResultData(const GmVector& data, int baseDof, GmValueAccessor* ac, double lambda = 1.0);
  void saveResultDataToFixedDofs(const GmVector& data, int baseDof, GmValueAccessor* ac, bool clearFree);
 
  void loadResultData(GmVector& data);
  void loadFixedData(GmVector& data);
 
  const QVector<int>& remapInfo() const;
  void remapData(GmVector& data, double newValue = 0.0) const;
  void remapData(const GmVector& oldData, GmVector& newData, double newValue = 0.0) const;
 
  bool fastUpdate() const { return _dofUnitList; }
 
private:
  Q_DISABLE_COPY(GmpFemAssembler)
 
  
  struct TemplateData
  {
    int _dofMap[GM_MAX_DOF]; 
 
    int _nFreeDof;
 
    QVector<int> _sv;     
 
    QVector<int> _svOffset;
  };
 
  bool addMappedMatrixData(int ndof, const int* indexMap, const GmDofMap* dofMap,
                           const GmpFemAssemblerMatrixCombiner* matCombiner,
                           const GmpFemAssemblerVectorCombiner* vecCombiner);
 
  bool initSparseLayout(GmSparseMatrixLayoutBuilder* layoutBuilder);
 
  void cleanup();
  bool initTranslationStructures(bool enableFastUpdate, bool createReverseMapping, QString& err);
  bool initTemplateAssociations(const GmElementDofMap* nodeDofMap, const QHash<int, GmElementDofMap>& fixedNodeDofMap, QString& err);
  void initDofToNodeIndex(int firstNode);
  void initUpdateDofPhysicsList();
 
  GmElementDofMap* createNodeDofMap (GmElementDofMap* physicsDofMapList, int* maxElemDof, size_t* dofsSum);
  bool             fillFixedDofMap  (QHash<int, GmElementDofMap>& fixedDofMap, const GmElementDofMap* fullNodeDofMap, 
                                     const QHash<int, GmElementDofMap>* partialNodeDofMap, QString& err);
  bool             fillBcNodeDofMap (const QVector<GmpFemPhysics*>& physicsList, QMap<QPair<int, int>, double>& fixedData,
                                     bool saveNonConstantPhysics, QString& err);
  bool             fillUnitMap      (const QVector<GmpFemPhysics*>& physicsList, GmElementDofMap* physicsDofMapList, QString& err);
  int              fecthNodeTemplate(const GmElementDofMap& nodeDofMap, const GmElementDofMap& fixedNodeDofMap, int node, QString& err);
  int              fecthDofStatevar (int dof);
  void             fillFixedData(double* data, int size);
 
  bool updateFixedBcValues(QString& err);
  bool updateTranslationStructures(const QVector<GmpFemPhysics*>& physList, const QList<QList<int> >& elementLists,
                                   bool nodesAdded, int updateFixedMode, bool updateUnits, QString& err);
 
  QHash<int, GmElementDofMap> createUpdateNodeDofMap(const QVector<GmpFemPhysics*>& physList, const QList<QList<int> >& elementLists,
                                                     GmElementDofMap* physicsDofMapList, int* maxElemDof, size_t* dofsSum);
 
  int updateNodeTemplate(int node, const GmElementDofMap& addedDofMap, const GmElementDofMap& newFixedDofMap, 
                         bool useOldFixedDofMap, int* nFreeAdded, int* nFixedAdded, QString& err);
 
  int extendedDofIndex(int node, int dof) const;
 
  bool saveNodeDofInfo(QVector<QPair<int, int> >& map, QString& err) const;
  bool buildRemapInfo(const QVector<QPair<int, int> >& oldMap, QString& err);
 
  int tgi(int node) const { return _mesh->toLinearGhostIndex(node); }
 
  int nodeIndex(int node) const { return _nodeIndex[tgi(node)]; }
 
  void setNodeIndex(int node, int baseIndex) { _nodeIndex[tgi(node)] = baseIndex; }
 
  void incNodeIndex(int node, int offset) { _nodeIndex[tgi(node)] += offset; }
 
  int nodeTemplateIndex(int node) const { return _nodeTemplateIndex[tgi(node)]; }
 
  void setNodeTemplateIndex(int node, int templateIndex) { _nodeTemplateIndex[tgi(node)] = templateIndex; }
 
  const TemplateData& nodeTemplate(int node) const { return _templateList.at(nodeTemplateIndex(node)); }
 
  GmElementMesh*               _mesh;         
  const QVector<GmpFemPhysics*>& _physicsList;  
  FixedDofMode                 _fixedDofMode; 
  bool                         _warnOnFixedInvalidDof;  
  bool                         _warnOnFixedDofConflict; 
  GmpFemMatrixSet*             _matSet;       
  GmpFemVectorSet*             _vecSet;       
 
  GmpFemLocker*                _locker;       
 
  GmpFemAssemblerMatrixAdder* _matAdder;  
  GmpFemAssemblerVectorAdder* _vecAdder;  
 
  GmpFemAssemblerMatrixAdder* _debugMatAdder;  
  GmpFemAssemblerVectorAdder* _debugVecAdder;  
 
  int                   _nthreads;     
  int                   _nt;           
  bool                  _ghostEnabled; 
  int                   _nMatrixDof;   
  int                   _nTotalDof;    
  int                   _maxNodeDofs;  
  size_t                _elemDofsSum;  
  int                   _nNodes;       
  int*                  _nodeIndex;    
  QVector<int>          _dofNode;      
  unsigned char*        _nodeTemplateIndex; 
  QVector<double>       _fixedValues;       
  QVector<double>       _oldFixedValues;    
  QHash<int, int>       _fixedNodeIndex;    
  QVector<TemplateData> _templateList;      
 
  QVector<QPair<GmStateVar*, GmValueAccessor*> > _stateVars; 
 
  GmTLBuffer<int, true> _elemIndexMap;   
 
  QVector<GmpFemPhysics*> _nonConstantFixedValuesPhysics;
 
  QVector<GmpFemPhysics*> _nonConstantDofPhysics;
 
  QMap<QPair<GmElementDofMap, GmElementDofMap>, int> _templateCache;
 
  QMap<int, int> _dofToSvCache;
 
  Unit* _dofUnitList; 
 
  Unit _timeUnit;
 
  bool _hasRemapInfo;  
 
  QVector<int> _remapInfo;
 
#if defined ENABLE_TESTS || defined ENABLE_ASSEMBLER_TESTS
  void validateInternalStructure() const;
#endif
};
 
#endif