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 <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 GmNumSolverPrinter;
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
{
  friend class XfemSolver;
  Q_OBJECT
 
public:
 
  GmpFemSolver(GmElementMesh* mesh, GmSimulationData* simulation, const QVector<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  below here -----------
    NumDisabledWarnings,          
  };
 
  bool initSolver(GmpFemAssembler::FixedDofMode assemblerMode, bool assemblerReverseMapping, bool enableFastUpdate);
 
  virtual bool initElementSets(GmNumSolver* solver);
  virtual bool initResultAttributes(int fatherItemId);
  virtual void intLinearSolverPrintOptions();
  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 fillElementDataForLoads(const GmElement* e, int physIndex, int loadIndex);
  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, QVector<int>& dofIndex);
  virtual void collectGlobalContactPairs(const GmContactBoundaryCondition* cbc, QVector<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 ();
 
  int                     _solverId;     
  GmElementMesh*          _mesh;         
  GmSimulationData*       _simulation;   
  QVector<GmpFemPhysics*> _physicsList;  
  GmNumSolverPrinter*     _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; 
 
  bool _parallelAssembler; 
  int  _ntasks;
  int  _nworkers;
  GmTaskManager::CellPartitionStrategy _strategy;
 
  int _iterAttr    = -1;  
  int _iterErrAttr = -1;  
 
  int _femItem         = -1; 
  int _prepareItem     = -1; 
  int _physicsItem     = -1; 
  int _fixedBcItem     = -1; 
  int _fixedForcesItem = -1; 
  int _assemblerItem   = -1; 
  int _physicsBeforeLoopItem           = -1; 
  int _physicsfillElemDataItem         = -1; 
  int _physicsfillElemDataBcItem       = -1; 
  int _physicsfillElemDataExtLoadsItem = -1; 
  int _physicsfillContactDataItem      = -1; 
  int _physicsAfterLoopItem            = -1; 
  int _assemblerBeginItem              = -1; 
  int _assemblerAddItem                = -1; 
  int _assemblerEndItem                = -1; 
  int _assemblerT1Item                 = -1; 
  int _assemblerT2Item                 = -1; 
  int _assemblerT3Item                 = -1; 
  int _assemblerT4Item                 = -1; 
};
 
#endif