gmpFemPhysics.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_PHYSICS_H_
#define _GEMA_PLUGIN_FEM_PHYSICS_H_

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

#include "gmpFemProcessConfig.h"
#include "gmpFemMatrixSet.h"
#include "gmpFemVectorSet.h"

class GmElementDof;
class GmMatrixDof;
class GmBoundaryCondition;
class GmContactBoundaryCondition;
class GmDiscontinuitySet;
class GmGaussAccessor;
class GmStateDump;

class GMP_FEM_PROCESS_API_EXPORT GmpFemPhysics : public GmPhysics
{
public:

  enum FemResultType 
  {
    FEM_RESULT_OK,  
    FEM_ERROR_FI,   
    FEM_ERROR,      
  };

  enum FemSupportedParallelMethods
  {
    FEM_PARALLEL_FILL_ELEMENT_DATA = 0x01,   
  };
  
  GmpFemPhysics(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger);
  virtual ~GmpFemPhysics();

  GmElementMesh* mesh() const { return _mesh; }

  const GmCellGroupSet* meshGroupSet() const { return _gs; }

  int numSupportedExternalLoads() const { return _externalLoadGroupSets.size(); }

  const GmCellGroupSet* externalLoadGroupSet(int loadId) const { return _externalLoadGroupSets[loadId]; }

  const QMap<QString, const GmBoundaryCondition*>& boundaryConditions() const { return _bcMap; }

  const QMap<QString, const GmContactBoundaryCondition*>& contactBoundaryConditions() const { return _cbcMap; }

  GmDiscontinuitySet* discontinuitySet() const { return _discSet; }

  virtual bool checkPhysicsDependencies(const QList<GmpFemPhysics*>& physicsList, int index) 
  {
    Q_UNUSED(physicsList);
    Q_UNUSED(index);
    return true;
  }

  virtual bool dofByElement(bool* fixed = NULL, bool* addOnly = NULL, bool* trackChanges = NULL) const 
  { 
    Q_UNUSED(fixed); Q_UNUSED(addOnly); Q_UNUSED(trackChanges);
    return false; 
  }

  virtual const GmElementDof* dofMapping(GmCellType type) const = 0;

  virtual const GmElementDof* dofMapping(const GmElement* e) const { return dofMapping(e->type()); }

  virtual Unit dofUnit(int dof) const = 0;

  virtual Unit timeUnit() const = 0;

  virtual const QList<QPair<int, GmValueAccessor*> >& dofForceAttributes() const
  {
    static QList<QPair<int, GmValueAccessor*> > dummyList;
    return dummyList;
  }

  virtual bool supportsCellType(GmCellType type) const = 0;

  virtual bool supportsParallel(FemSupportedParallelMethods methodType) const { Q_UNUSED(methodType); return false; }

  virtual bool beforeElementStiffnessLoop(const GmpFemMatrixSet& elemMatrices, 
                                          const GmpFemVectorSet& elemVectors) 
  { 
    Q_UNUSED(elemMatrices); Q_UNUSED(elemVectors);
    return true; 
  }

  virtual void afterElementStiffnessLoop() {}

  virtual FemResultType fillElementData(const GmElement* e, GmpFemMatrixSet& elemMatrices, GmpFemVectorSet& elemVectors) = 0;

  virtual const QStringList& supportedBcTypes() const
  {
    static QStringList dummyList;
    return dummyList;
  }

  virtual bool bcAffectsCalc(const GmBoundaryCondition* bc) const
  {
    Q_UNUSED(bc);
    return false;
  }

  virtual FemResultType fillElementDataForBc(const GmElement* e, const GmBoundaryCondition* bc, int bcIndex, int bcListIndex,
                                             int border, GmpFemMatrixSet& elemMatrices, GmpFemVectorSet& elemVectors)
  {
    Q_UNUSED(e); Q_UNUSED(bc); Q_UNUSED(bcIndex); Q_UNUSED(bcListIndex); Q_UNUSED(border);
    Q_UNUSED(elemMatrices); Q_UNUSED(elemVectors);
    return FEM_ERROR;
  }
  
  virtual bool fixedNodalForcesBc(QList<int>& nodes, QList<int>&dof, QList<double>& values) const 
  { 
    Q_UNUSED(nodes); Q_UNUSED(dof); Q_UNUSED(values);
    return true;
  }

  virtual bool fixedNodalDofsBc(QList<int>& nodes, QList<int>&dof, QList<double>& values, bool* constantValues) const
  {
    Q_UNUSED(nodes); Q_UNUSED(dof); Q_UNUSED(values);
    *constantValues = true;
    return true;
  }

  virtual const QStringList& supportedContactBcTypes() const
  {
    static QStringList dummyList;
    return dummyList;
  }

  virtual FemResultType fillContactData(const GmContactBoundaryCondition* cbc, int bcIndex1, int bcIndex2,
                                        GmMatrixDof& dofMap, GmpFemMatrixSet& matrixSet, GmpFemVectorSet& vecSet)
  {
    Q_UNUSED(cbc); Q_UNUSED(bcIndex1); Q_UNUSED(bcIndex2);
    Q_UNUSED(dofMap); Q_UNUSED(matrixSet); Q_UNUSED(vecSet);
    return FEM_ERROR;
  }

  virtual const QStringList& supportedExternalLoads() const 
  { 
    static QStringList dummyList;
    return dummyList;
  }
  
  virtual FemResultType fillElementDataForLoads(const GmElement* e, int loadId, GmpFemVectorSet& elemVectors)
  { 
    Q_UNUSED(e); Q_UNUSED(loadId); Q_UNUSED(elemVectors);
    return FEM_ERROR;
  }

  virtual bool calcDerivedResults(bool nonLinearSolver)
  {
    Q_UNUSED(nonLinearSolver);
    return true;
  }

  virtual bool supportsStateDumping() { return false; }

  virtual bool addStateItemsToGroup(GmStateDump* state, bool fixedHint, int groupId) { Q_UNUSED(state); Q_UNUSED(fixedHint); Q_UNUSED(groupId);  return true; }

  virtual bool fillStateControlMapData(QVariantMap* map) { Q_UNUSED(map); return true; }

  virtual bool stateControlMapDataLoaded(QVariantMap* map) { Q_UNUSED(map); return true; }

  virtual bool stateAboutToBeSaved(GmStateDump* state) { Q_UNUSED(state); return true; }

  virtual bool stateSaved(GmStateDump* state) { Q_UNUSED(state); return true; }

  virtual bool stateAboutToBeLoaded(GmStateDump* state) { Q_UNUSED(state); return true; }

  virtual bool stateLoaded(GmStateDump* state) { Q_UNUSED(state); return true; }


  virtual QList<int> changedElements() const { return QList<int>(); }

  virtual void clearChangedElements() {}

  const GmIntegrationRule*       elementIntegrationRule(GmCellType type) const;
  const GmBorderIntegrationRule* borderIntegrationRule (GmCellType type, int borderIndex) const;
  const GmBorderIntegrationRule* faceIntegrationRule   (GmCellType type, int faceIndex) const;
  const GmBorderIntegrationRule* edgeIntegrationRule   (GmCellType type) const;

  int integrationRuleSet() const { return _intRuleSet; }

  bool setIntegrationRuleSet(int ruleSet);

  virtual bool loadPrivateData(LuaTable& table);
  virtual void printParameters(const GmLogCategory& logger);

protected:

  virtual bool checkMeshDimension(int ndim) = 0;

  virtual bool checkAndLoadPrivateData(LuaTable& table) = 0;

  virtual bool checkAndLoadDofMapping(LuaTable& table) = 0;

  virtual bool checkAndLoadPropertyAccessors(LuaTable& table) = 0;

  virtual bool checkAndLoadAttributeAccessors(LuaTable& nodeTable, LuaTable& gaussTable) = 0;

  virtual bool checkAndLoadExternalLoadAccessors(LuaTable& loadsTable) = 0;

  virtual bool checkAndLoadBcAccessors() = 0;

  virtual bool checkAndLoadContactBcAccessors() = 0;

  virtual bool checkAndLoadDiscontinuitySetAccessors(LuaTable& table) = 0;

  GmGaussAccessor* gaussAttributeAccessor(GmElementMesh* mesh, QString stdAttributeName, QString msgDescription,
                                          LuaTable& table, Unit desiredUnit, bool required, int type = -1, 
                                          int nlin = -1, int ncol = -1, int history = -1, bool canBeFunction = true, 
                                          bool create = false, QString createFormat = "", int createHistory = -1, 
                                          bool ignoreWarnings = false);

  virtual GmGaussAccessor* createGaussAttributeAccessor(GmElementMesh* mesh, QString id, int snum, bool locked, 
                                                        Unit desiredUnit, const GmLogCategory& logger) const
  {
    return mesh->gaussAttributeAccessor(id, snum, locked, desiredUnit, logger);
  }


  GmElementMesh*        _mesh;       
  const GmCellGroupSet* _gs;         
  int                   _intRuleSet; 
  GmDiscontinuitySet*   _discSet;    
  QMap<QString, const GmBoundaryCondition*>        _bcMap;  
  QMap<QString, const GmContactBoundaryCondition*> _cbcMap; 

  QVector<const GmCellGroupSet*> _externalLoadGroupSets; 
};


#endif