gmpFemSolver.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_SOLVER_H_
#define _GEMA_PLUGIN_FEM_SOLVER_H_

#include <QList>

#include <gmElementMesh.h>
#include <gmElement.h>

#include "gmpFemMatrixSet.h"
#include "gmpFemVectorSet.h"
#include "gmpFemProcessConfig.h"
#include "gmpFemSolverOptions.h"
#include "gmpFemAssembler.h"
#include "gmpFemPhysics.h"

class GmNumSolver;
class GmLogCategory;
class GmSolverMatrix;
class GmBoundaryCondition;
class GmCellBoundary;
class GmMatrixDof;

class GmpFemAssembler;
class GmpFemAssemblerMatrixCombiner;
class GmpFemAssemblerVectorCombiner;

class GMP_FEM_PROCESS_API_EXPORT GmpFemSolver : public QObject, public GmGroupDumpItem
{
  Q_OBJECT

public:
  enum PrintOptions
  {
    PRINT_ELEMENT_MATRICES    = 0x001,  
    PRINT_ELEMENT_VECTORS     = 0x002,  
    PRINT_ELEMENT_DOF_MAPPING = 0x004,  
    PRINT_EQ_MATRIX           = 0x008,  
    PRINT_EQ_VECTOR           = 0x010,  
    PRINT_GLOBAL_MATRICES     = 0x020,  
    PRINT_GLOBAL_VECTORS      = 0x040,  
    PRINT_LINEAR_MATRIX       = 0x080,  
    PRINT_LINEAR_VECTOR       = 0x100,  
    PRINT_LINEAR_RESULT       = 0x200,  
  };

  GmpFemSolver(GmElementMesh* mesh, GmSimulationData* simulation, const QList<GmpFemPhysics*>& physics,
               GmNumSolver* solver, const GmpFemSolverOptions& options, const GmLogCategory& logger);
  virtual ~GmpFemSolver(void);

  virtual bool init();
  bool run();

  bool calcLinearResidual(double* rnorm, double* maxNodeDiff, double* avgNodeDiff);

  void setMatrixCombinerObject(const GmpFemAssemblerMatrixCombiner* combiner) { _matCombiner = combiner; }

  void setVectorCombinerObject(const GmpFemAssemblerVectorCombiner* combiner) { _vecCombiner = combiner; }

  bool update(int mode, QString& err);

  virtual bool addStateItemsToGroup(GmStateDump* state, int groupId);
  virtual bool stateAboutToBeSaved (GmStateDump* state);
  virtual bool stateSaved          (GmStateDump* state);
  virtual bool stateAboutToBeLoaded(GmStateDump* state);
  virtual bool stateLoaded         (GmStateDump* state);

  virtual bool fillStateControlMapData  (QVariantMap* map);
  virtual bool stateControlMapDataLoaded(QVariantMap* map);

  virtual bool stateLoadedCalcDerivedResultsNonLinear() { return false; }

private:
  Q_DISABLE_COPY(GmpFemSolver)

protected slots :
  virtual void meshChanged();

protected:

  enum DisabledWarnings
  {
    PrescribedForceForInvalidDof, 
    PrescribedForceForFixedDof,   
    FixedBcForInvalidDof,         
    ConflictingFixedBcValue,      
    //---------- Do not add lines bellow here -----------
    NumDisabledWarnings,          
  };

  bool initSolver(GmpFemAssembler::FixedDofMode assemblerMode, bool assemblerReverseMapping, bool enableFastUpdate);

  virtual bool initElementSets(GmNumSolver* solver);
  virtual bool initResultAttributes(QString prefix);
  virtual bool cleanup();

  GmpFemPhysics::FemResultType prepareMatrices(bool skipFixedBcs = false);
  GmpFemPhysics::FemResultType saveElementData(int iter);
  bool solveLinearSystem(bool xFilled);

  double timeConvert(double val);

  GmpFemPhysics::FemResultType traverseElements();
  GmpFemPhysics::FemResultType traverseBoundaryElements();
  GmpFemPhysics::FemResultType traverseExternalLoads();
  GmpFemPhysics::FemResultType traverseContactBoundaries();
  GmpFemPhysics::FemResultType traverseElementsForSaving(FILE* f, int iter);

  GmpFemPhysics::FemResultType fillElementData        (const GmElement* e, int physIndex);
  GmpFemPhysics::FemResultType fillElementBoundaryData(const GmElement* e, int physIndex, const GmBoundaryCondition* bc, 
                                                       int bcIndex, int bcListIndex, int border, const GmCellBoundary* b);
  GmpFemPhysics::FemResultType fillContactData(GmMatrixDof& localDofMap, const GmContactBoundaryCondition* cbc, int physIndex, int index1, int index2);

  bool addFixedForces();
  virtual bool applyFixedBoundaryConditions(int* numFixed);
  bool collectFixedBcs(QVector<bool>& fixedRows, QVector<double>& fixedValues, QList<int>& dofIndex);

  virtual void collectGlobalContactPairs(const GmContactBoundaryCondition* cbc, QList<QPair<int, int> >& contactPairs);

  void printElementData(const GmElement* e, int ndof, const int* dofMapping, const GmpFemPhysics* p, 
                        const GmBoundaryCondition* bc = NULL, const GmContactBoundaryCondition* cbc = NULL,
                        int loadId1 = -1, int id2 = -1);
  void printGlobalData (bool linear);

  int                   _solverId;     
  GmElementMesh*        _mesh;         
  GmSimulationData*     _simulation;   
  QList<GmpFemPhysics*> _physicsList;  
  GmNumSolver*          _solver;             
  const GmLogCategory&  _logger;             
  QMutex                _printMutex;   

  bool                  _enabledWarn[NumDisabledWarnings]; 

  GmpFemSolverOptions   _solverOptions;  

  UnitConverter*        _timeConv;       

  GmpFemAssembler*                     _assembler; 
  const GmpFemAssemblerMatrixCombiner* _matCombiner;  
  const GmpFemAssemblerVectorCombiner* _vecCombiner;  

  GmpFemVectorSet                   _vecSet;    
  GmpFemMatrixSet                   _matSet;    
  GmVector                                    _x;             
  GmVector                                    _r;             
                         
  unsigned                                    _preCount;        
  unsigned                                    _runCount;        

  QVariantMap           _controlMap; 

  int _iterResAttr;     
  int _iterResErrAttr;  

#ifdef TRACK_PHYSICS_TIME
  void resetTimeData() { _elapsedTime = 0; }
  void printTimeData(const GmLogCategory& logger) { gmTimeMsg(logger, QObject::tr("  *** Physics build matrix time: %1 s").arg(_elapsedTime / 1.0e9)); }
  qint64 _elapsedTime;
#endif
};

#endif