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 bellow 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 QList<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 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; }

#ifdef TRACK_ASSEMBLER_TIME
  void resetTimeData() { _elapsedTime = 0; }
  void printTimeData(const GmLogCategory& logger) { gmTimeMsg(logger, QObject::tr("  *** Assembler merge total time: %1 s").arg(_elapsedTime/1.0e9)); }
#endif

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 QList<GmpFemPhysics*>& physicsList, QMap<QPair<int, int>, double>& fixedData,
                                     bool saveNonConstantPhysics, QString& err);
  bool             fillUnitMap      (const QList<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 QList<GmpFemPhysics*>& physList, const QList<QList<int> >& elementLists,
                                   bool nodesAdded, int updateFixedMode, bool updateUnits, QString& err);

  QHash<int, GmElementDofMap> createUpdateNodeDofMap(const QList<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 QList<GmpFemPhysics*>& _physicsList;  
  FixedDofMode                 _fixedDofMode; 
  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;   

  QList<GmpFemPhysics*> _nonConstantFixedValuesPhysics;

  QList<GmpFemPhysics*> _nonConstantDofPhysics;

  QMap<QPair<GmElementDofMap, GmElementDofMap>, int> _templateCache;

  QMap<int, int> _dofToSvCache;

  Unit* _dofUnitList; 

  Unit _timeUnit;

  bool _hasRemapInfo;  

  QVector<int> _remapInfo;

#ifdef TRACK_ASSEMBLER_TIME
  qint64 _elapsedTime;
#endif

#if defined ENABLE_TESTS || defined ENABLE_ASSEMBLER_TESTS
  void validateInternalStructure() const;
#endif
};

#endif