gmpFemPhysicsCommon.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_COMMON_H_
#define _GEMA_PLUGIN_FEM_PHYSICS_COMMON_H_
 
#include "gmpFemPhysics.h"
#include <gmBoundaryCondition.h>
 
#include <luaEnv.h>
#include <QList>
 
class GmpFemPhysicsCommonMaterial;
class GmpFemPhysicsCommonMaterialFactory;
class GmpFemPhysicsData;
class GmpFemNeuralNetwork;
class GmSegmentCell2DIntersectionCoordAccessor;
 
class GMP_FEM_PROCESS_API_EXPORT GmpFemPhysicsCommon: public GmpFemPhysics
{
public:
 
  struct RequiredIf
  {
    enum RequiredIfOp
    {
      EQ,         
      NEQ,        
      LT,         
      LTE,        
      GT,         
      GTE,        
      EXISTS,     
      NOT_EXISTS, 
      OR,         
      AND,        
    };
 
    RequiredIf(bool required) : _mode(required), _l(NULL), _r(NULL) {}
 
    RequiredIf(QString type, QString attr, RequiredIfOp op, QVariant val = QVariant())
      : _mode(2), _type(type), _attr(attr), _op(op), _val(val), _l(NULL), _r(NULL)
    {
      assert(type == "dimension" || type == "attributes" || type == "stateVars" || type == "properties");
      assert(type == "dimension" || !attr.isEmpty());
      assert(((op == EXISTS || op == NOT_EXISTS) && val.isNull()) ||
             ((op != EXISTS && op != NOT_EXISTS) && !val.isNull()));
    }
 
    RequiredIf(const RequiredIf& l, RequiredIfOp op, const RequiredIf& r)
      : _mode(3), _op(op), _l(new RequiredIf(l)), _r(new RequiredIf(r))
    {
      assert(op == OR || op == AND);
    }
 
    // Copy constructor. Needded since left and right operads for logical cluses are allocated by the object
    RequiredIf(const RequiredIf& other)
    {
      _mode = other._mode;
      _type = other._type;
      _attr = other._attr;
      _op   = other._op;
      _val  = other._val;
      _l    = other._l ? new RequiredIf(*other._l) : NULL;
      _r    = other._r ? new RequiredIf(*other._r) : NULL;
    }
 
    ~RequiredIf() { delete _l; delete _r; }
 
    bool operator()(const GmpFemPhysicsCommon* p, GmpFemPhysicsCommonMaterial* m) const;
 
    int          _mode;   
    QString      _type;   
    QString      _attr;   
    RequiredIfOp _op;     
    QVariant     _val;    
    const RequiredIf* _l; 
    const RequiredIf* _r; 
  };
 
  struct Size
  {
    enum
    {
      Any        = -1, 
      Dimension  = -2, 
      Dimension2 = -3, 
      AttrVal    = -4, 
      AttrLin    = AttrVal, 
      AttrCol    = -5,      
    };
 
    Size(int lin = Any, int col = Any) : _nlin(lin), _ncol(col) { assert(lin > AttrLin && col > AttrLin); }
    
    Size(int lin, QString linType, QString linAttr, int col, QString colType, QString colAttr) 
      : _nlin(lin), _ncol(col), _linAttrType(linType), _linAttr(linAttr), _colAttrType(colType), _colAttr(colAttr) {}
 
    int nlin(const GmpFemPhysicsCommon* p, GmpFemPhysicsCommonMaterial* m = NULL) const { return dim(p, m, _nlin, _linAttrType, _linAttr); }
 
    int ncol(const GmpFemPhysicsCommon* p, GmpFemPhysicsCommonMaterial* m = NULL) const { return dim(p, m, _ncol, _colAttrType, _colAttr); }
 
    int dim(const GmpFemPhysicsCommon* p, GmpFemPhysicsCommonMaterial* m, int val, QString valType, QString valAttr) const;
 
    int     _nlin;         
    int     _ncol;         
    QString _linAttrType;  
    QString _colAttrType;  
    QString _linAttr;      
    QString _colAttr;      
  };
 
  struct Attribute
  {
    enum AttributeType
    {
      User,           
      Bool,           
      Int,            
      Double,         
      String,         
      DoubleList,     
      StringList,     
      Vector,         
      Matrix,         
      ScalarOrVector, 
      Enum,           
    };
 
    Attribute() : _id(-1), _type(User), _size(-1, -1), _required(false) {}
 
    Attribute(int id, QString name, AttributeType type, int nlin, int ncol, const RequiredIf& required, QString unit = "", QVariant defValue = QVariant())
      : _id(id), _name(name), _type(type), _size(nlin, ncol), _unit(unit), _defVal(defValue), _required(required) { assert(id >= 0 && type != Enum); }
 
    Attribute(int id, QString name, AttributeType type, const RequiredIf& required, QString unit = "", QVariant defValue = QVariant())
      : _id(id), _name(name), _type(type), _size(-1, -1), _unit(unit), _defVal(defValue), _required(required) { assert(id >= 0 && type != Enum); }
 
    Attribute(int id, QString name, AttributeType type, QVariant defValue)
      : _id(id), _name(name), _type(type), _size(-1, -1), _defVal(defValue), _required(false) { assert(id >= 0 && type != Enum); }
 
    Attribute(int id, QString name, AttributeType type, int nlin, int ncol, QVariant defValue)
      : _id(id), _name(name), _type(type), _size(nlin, ncol), _defVal(defValue), _required(false) { assert(id >= 0 && type != Enum); }
 
    Attribute(int id, QString name, const QMap<QString, int>& enumMap, const RequiredIf& required, QString unit = "", QVariant defValue = QVariant())
      : _id(id), _name(name), _type(Enum), _enumMap(enumMap), _size(-1, -1), _unit(unit), _defVal(defValue), _required(required) { assert(id >= 0); }
 
    Attribute(int id, QString name, const QMap<QString, int>& enumMap, QVariant defValue)
      : _id(id), _name(name), _type(Enum), _enumMap(enumMap), _size(-1, -1), _defVal(defValue), _required(false) { assert(id >= 0); }
 
    operator QVariant() const { QVariant v; v.setValue(*this); return v; }
 
    int nlin(const GmpFemPhysicsCommon* p) const { return _size.nlin(p); }
    int ncol(const GmpFemPhysicsCommon* p) const { return _size.ncol(p); }
 
    int                _id;       
    QString            _name;     
    AttributeType      _type;     
    Size               _size;     
    QString            _unit;     
    QVariant           _defVal;   
    QMap<QString, int> _enumMap;  
    RequiredIf         _required; 
  };
 
  struct ValueType
  {
    ValueType(GmDimType type, int nlin = -1, int ncol = -1, bool canBeFunction = true, int history = -1, const char* format = "")
      : _type(type), _size(nlin, ncol), _function(canBeFunction), _history(history), _format(format) {}
 
    ValueType(GmDimType type, int nlin, QString linType, QString linAttr, int ncol, QString colType, QString colAttr, 
              bool canBeFunction = true, int history = -1, const char* format = "")
      : _type(type), _size(nlin, linType, linAttr, ncol, colType, colAttr), 
        _function(canBeFunction), _history(history), _format(format) {}
 
    int nlin(const GmpFemPhysicsCommon* p, GmpFemPhysicsCommonMaterial* m = NULL) const { return _size.nlin(p, m); }
    int ncol(const GmpFemPhysicsCommon* p, GmpFemPhysicsCommonMaterial* m = NULL) const { return _size.ncol(p, m); }
 
    GmDimType  _type;     
    Size       _size;     
    bool       _function; 
    int        _history;  
    QString    _format;   
  };
 
  struct Value
  {
    Value() : _id(-1), _required(false), _historyRefId(-1), _historyState(0), _historyLocked(true) {}
 
    Value(int id, QString name, QString description, QString unit, const ValueType& type, const RequiredIf& required = RequiredIf(true))
      : _id(id), _name(name), _description(description), _unit(unit), _types(QList<ValueType>() << type), _required(required),
        _historyRefId(-1), _historyState(0), _historyLocked(true) { assert(id >= 0); }
 
    Value(int id, QString name, QString description, QString unit, const QList<ValueType>& types, const RequiredIf& required = RequiredIf(true))
      : _id(id), _name(name), _description(description), _unit(unit), _types(types), _required(required), 
        _historyRefId(-1), _historyState(0), _historyLocked(true)
    { assert(id >= 0); }
 
    operator QVariant() const { QVariant v; v.setValue(*this); return v; }
 
    int              _id;            
    QString          _name;          
    QString          _description;   
    QString          _unit;          
    QList<ValueType> _types;         
    RequiredIf       _required;      
    int              _historyRefId;  
    int              _historyState;  
    bool             _historyLocked; 
  };
 
  struct ScalarValue : public Value
  {
    ScalarValue() {}
 
    ScalarValue(int id, QString name, QString description, QString unit, const RequiredIf& required = RequiredIf(true),
                bool canBeFunction = true, int history = -1, const char* format = "")
      : Value(id, name, description, unit, ValueType(GM_SCALAR_VALUE, -1, -1, canBeFunction, history, format), required) {}
  };
 
  struct VectorValue: public Value
  {
    VectorValue() {}
 
    VectorValue(int id, QString name, QString description, QString unit, int nlin, const RequiredIf& required = RequiredIf(true),
                bool canBeFunction = true, int history = -1, const char* format = "")
      : Value(id, name, description, unit, ValueType(GM_VECTOR_VALUE, nlin, -1, canBeFunction, history, format), required) {}
 
    VectorValue(int id, QString name, QString description, QString unit, int nlin, QString linType, QString linAttr,
                const RequiredIf& required = RequiredIf(true), bool canBeFunction = true, int history = -1, const char* format = "")
      : Value(id, name, description, unit, ValueType(GM_VECTOR_VALUE, nlin, linType, linAttr, -1, "", "", 
                                                     canBeFunction, history, format), required) {}    
  };
 
  struct MatrixValue: public Value
  {
    MatrixValue() {}
 
    MatrixValue(int id, QString name, QString description, QString unit, int nlin, int ncol, const RequiredIf& required = RequiredIf(true),
                bool canBeFunction = true, int history = -1, const char* format = "")
      : Value(id, name, description, unit, ValueType(GM_MATRIX_VALUE, nlin, ncol, canBeFunction, history, format), required) {}
 
    MatrixValue(int id, QString name, QString description, QString unit, int nlin, QString linType, QString linAttr, 
                int ncol, QString colType, QString colAttr, const RequiredIf& required = RequiredIf(true),
                bool canBeFunction = true, int history = -1, const char* format = "")
      : Value(id, name, description, unit, ValueType(GM_MATRIX_VALUE, nlin, linType, linAttr, ncol, colType, colAttr,
                                                     canBeFunction, history, format), required) {}
  };
 
  struct HistoryValue: public Value
  {
    HistoryValue() {}
 
    HistoryValue(int id, int refId, int state, bool locked = true)
      : Value(id, "", "", "", QList<ValueType>())
    {
      assert(refId >= 0);
      _historyRefId  = refId;
      _historyState  = state;
      _historyLocked = locked;
    }
  };
 
  template <class T> class TList: public QList<T>
  {
  public:
    typedef T listType;
    operator QVariant() const { QVariant v; v.setValue(*this); return v; }
    TList& operator<< (const T& t) { this->append(t); return *this; }
  };
 
  typedef TList<int>       IntList;       
  typedef TList<Attribute> AttributeList; 
  typedef TList<Value>     ValueList;     
 
  struct Bc
  {
    enum BcType
    {
      Node = GmBoundaryCondition::GM_BC_NODE, 
      Edge = GmBoundaryCondition::GM_BC_EDGE, 
      Face = GmBoundaryCondition::GM_BC_FACE, 
      Cell = GmBoundaryCondition::GM_BC_CELL, 
      EdgeFace,                               
    };
 
    enum BcUseType
    {
      Calc,       
      FixedForce, 
      FixedDof,   
    };
 
    Bc() : _id(-1), _required(false) {}
 
    Bc(int id, QString name, BcType bcType, BcUseType bcUseType, const Value& bcValue, const RequiredIf& required = RequiredIf(false))
      : _id(id), _name(name), _bcType(bcType), _bcUseType(bcUseType),
        _bcValues(ValueList() << bcValue), _required(required) { assert(id >= 0); }
 
    Bc(int id, QString name, BcType bcType, BcUseType bcUseType, const ValueList& bcValues, const RequiredIf& required = RequiredIf(false))
      : _id(id), _name(name), _bcType(bcType), _bcUseType(bcUseType),
        _bcValues(bcValues), _required(required) { assert(id >= 0); }
 
    operator QVariant() const { QVariant v; v.setValue(*this); return v; }
 
    int              _id;         
    QString          _name;       
    BcType           _bcType;     
    BcUseType        _bcUseType;  
    ValueList        _bcValues;   
    RequiredIf       _required;   
  };
 
  typedef TList<Bc>  BcList; 
 
  enum DiscSetRequiredMode
  {
    DS_IGNORED,  
    DS_REQUIRED, 
    DS_OPTIONAL, 
  };
 
 
  GmpFemPhysicsCommon(GmSimulationData* simulation, QString id, QString description,
                     const GmpFemPhysicsCommonMaterialFactory* matFactory, const GmLogCategory& logger);
  virtual ~GmpFemPhysicsCommon();
 
  void printParameters(const GmLogCategory& logger);
 
  virtual const QVariantMap* physicsMetaDataMap() = 0;
 
  template<class T> static T listFromVariant(const QVariant& v)
  {
    if(v.canConvert<typename T::listType>())
      return T() << v.value<typename T::listType>();
    else
      return v.value<T>();
  }
 
  static void fillMatrixFromPropertyAc(GmCellAccessor* ac, const GmElement* e, const GmVector* coord, int ip, GmMatrix& K);
 
public:
 
  const QVariant& attribute(int id) const { return _attributes.at(id); }
 
  GmValueAccessor* nodeAc() const { return _nodeAccessor; }
 
  int nodeDim() const { return _nodeDim; }
 
  bool isoParametric() const { return _iso; }
 
  int svCount() const { return _svAccessors.size(); }
 
  GmValueAccessor* svAc(int id) const { return _svAccessors.at(id); }
 
  int baseDof(int id) const { return _svDof.at(id); }
 
  GmCellAccessor* propertyAc(int id) const { return _propertyAccessors.at(id); }
 
  bool constantProperty(int id) const { return _constantProperties.at(id); }
 
  GmValueAccessor* nodeAttrAc(int id) const { return _nodeAttrAccessors.at(id); }
 
  GmCellAccessor* cellAttrAc(int id) const { return _cellAttrAccessors.at(id); }
 
  GmGaussAccessor* gaussAttrAc(int id) const { return _gaussAttrAccessors.at(id); }
 
  const GmBoundaryCondition* boundaryCondition(int id) const { return _boundaryConditions.at(id); }
 
  const GmContactBoundaryCondition* contactCondition(int id) const { return _contactConditions.at(id); }
 
  GmBoundaryConditionAccessor* bcAc(int id) const { return _bcAccessors.at(id); }
 
  GmContactBoundaryConditionAccessor* contactAc(int id) const { return _contactAccessors.at(id); }
 
  bool constantBc(int id) const { return _constantBcValues.at(id); }
 
  bool constantContactBc(int id) const { return _constantContactBcValues.at(id); }
 
  const QVector<const GmBoundaryCondition*>& calcBoundaryConditions() const { return _calcBoundaryConditions; }
 
  GmValueAccessor* loadAc(int loadId) const { return _loadAccessors.isEmpty() ? NULL : _loadAccessors.at(loadId); }
 
  GmDiscontinuityAccessor* discontinuityAc(int discId) const { return _discSetPropertyAccessors.at(discId); }
 
  GmSegmentCell2DIntersectionCoordAccessor* discontinuity2dIntersectionCoordAc() const { return _discSet2DInterCoordAc; }
 
  GmValueAccessor* cloneSvAcWithDifferentUnit       (int id, QString unitSystemName, QString defUnit) const;
  GmCellAccessor*  clonePropertyAcWithDifferentUnit (int id, QString unitSystemName, QString defUnit) const;
  GmValueAccessor* cloneNodeAttrAcWithDifferentUnit (int id, QString unitSystemName, QString defUnit) const;
  GmCellAccessor*  cloneCellAttrAcWithDifferentUnit (int id, QString unitSystemName, QString defUnit) const;
  GmGaussAccessor* cloneGaussAttrAcWithDifferentUnit(int id, QString unitSystemName, QString defUnit) const;
 
  const GmpFemPhysicsCommonMaterial* material(const GmElement* e) const;
 
  const QVector<GmpFemPhysicsCommonMaterial*>& materialList() const { return _materials; }
 
  enum DerivedResultsRecoveryMode
  {
    RECOVER_AT_GAUSS  = 0x01,  
    RECOVER_AT_NODES  = 0x02,  
    DIRECT_NODE_EVAL  = 0x04,  
    ADD_RESULTS       = 0x08,  
    IP_ONLY           = 0x10,  
    GAUSS_FILLED      = 0x20,  
  };
 
  bool calcDerivedResult(int recoveryMode, GmValueAccessor* nodeAc, GmGaussAccessor* gaussAc, int resultId = -1);
 
  void fillElementNodeValues(const GmValueAccessor* ac, const GmElement* e, GmVector& v, int nv = -1) const;
  bool fillMissingNodeValues(GmValueAccessor* ac);
 
  bool fillScalarFixedNodalBcLists(int bcId, int propertyId, int dofId, QVector<int>& nodes, QVector<int>&dof,
                                   QVector<double>& values, bool* constantValues) const;
 
  bool fillVectorFixedNodalBcLists(int bcId, int propertyId, int dofId, bool ignoreZeroValues, bool ignoreDefValues,
                                   QVector<int>& nodes, QVector<int>&dof, QVector<double>& values, bool* constantValues) const;
 
  bool fillMultiScalarFixedNodalBcLists(int bcId, const QVector<int>& propertyIds, int dofId, bool ignoreZeroValues, bool ignoreDefValues,
                                        QVector<int>& nodes, QVector<int>&dof, QVector<double>& values, bool* constantValues) const;
 
  virtual void calcElementDerivedResultAtPoints(const GmElement* e, int resultId, const GmMatrix& evalPoints, bool evalAtIp, GmMatrix& result)
  {
    Q_UNUSED(e); Q_UNUSED(resultId); Q_UNUSED(evalPoints); Q_UNUSED(evalAtIp);  Q_UNUSED(result);
    assert(0);  // This function must be reimplemented in the real physics class to allow for using calcDerivedResults()
  }
 
  virtual bool checkLoadedData() { return true; }
 
  void addMaterialTranslation(const char* modelName, const char* physicsName, int modelIndex, bool defaultMaterial);
  GmpFemPhysicsCommonMaterial* material(QString modelName) const;
 
protected:
  friend class GmpFemPhysicsCoupled; // Coupled needs to call checkAndLoadXxx() functions from its common physics 'components'
 
  // See comments on the base class
  virtual bool supportsCellType(GmCellType type) const { assert(_attrMap);  return _supportedTypes[type]; }
 
  // See comments on the base class
  virtual bool supportsParallel(FemSupportedParallelMethods methodType) const { assert(_attrMap);  return _parallelMethods & methodType; }
 
  virtual const GmElementDof* dofMapping(GmCellType type) const;
  virtual Unit dofUnit(int dof) const;
 
  // See comments on the base class
  virtual Unit timeUnit() const { return _timeUnit; }
 
  virtual GmVector timeSim() const;
 
  // See comments on the base class
  virtual const QList<QPair<int, GmValueAccessor*> >& dofForceAttributes() const { return _dofForceAttributes; }
 
  // See comments on the base class
  virtual const QStringList& supportedBcTypes() const { return _boundaryConditionTypes; }
 
  // See comments on the base class
  virtual const QStringList& supportedContactBcTypes() const { return _contactConditionTypes; }
 
  virtual bool bcAffectsCalc(const GmBoundaryCondition* bc) const;
 
  // See comments on the base class
  virtual const QStringList& supportedExternalLoads() const { return _externalLoadsList; }
 
  // See comments on the base class
  virtual bool checkAndLoadPrivateData(LuaTable& table);
  virtual bool checkMeshDimension(int ndim);
  virtual bool checkAndLoadDofMapping(LuaTable& table);
  virtual bool checkAndLoadPropertyAccessors(LuaTable& table);
  virtual bool checkAndLoadAttributeAccessors(LuaTable& nodeTable, LuaTable& cellTable, LuaTable& gaussTable);
  virtual bool checkAndLoadExternalLoadAccessors(LuaTable& loadsTable);
  virtual bool checkAndLoadBcAccessors();
  virtual bool checkAndLoadContactBcAccessors();
  virtual bool checkAndLoadDiscontinuitySetAccessors(LuaTable& table);
 
  template<class T> QString accessorNameList(const QVector<T*> list) const;
 
  bool checkAndLoadPropertyAccessorsAux(LuaTable& table, const QList<Value>& defList,
                                        QVector<GmCellAccessor*>& accessors, QVector<bool>& constants);
 
  template<class T, class Ac> 
  bool checkAndLoadBcAccessorsAux(QString attrName, QString msgPrefix, QMap<QString, const T*>& bcMap,
                                  QVector<const T*>& boundaryConditions, QVector<Ac*>& bcAccessors, QVector<bool>& constantBcValues,
                                  QStringList& boundaryConditionTypes, QVector<const T*>* calcBoundaryConditions,  
                                  Ac* (GmPhysics::*acGetFn)(const T*, QString, QString, Unit, bool, int, int, int, bool, bool));
 
  bool checkAndLoadNodeAttributeAccessors (LuaTable& table, const QList<Value>& naList, QVector<GmValueAccessor*>& accessors, GmpFemPhysicsCommonMaterial* m = NULL);
  bool checkAndLoadCellAttributeAccessors (LuaTable& table, const QList<Value>& caList, QVector<GmCellAccessor*>&  accessors, GmpFemPhysicsCommonMaterial* m = NULL);
  bool checkAndLoadGaussAttributeAccessors(LuaTable& table, const QList<Value>& gaList, QVector<GmGaussAccessor*>& accessors, GmpFemPhysicsCommonMaterial* m = NULL);
  bool checkAndLoadSavedGaussAttributes(const QList<int>& attrIdList, QString prefix, int numGaussAttributes, QVector<int>& savedIdList);
 
  bool createMaterials(LuaTable& table);
 
  bool loadAttributes    (LuaTable& table);
  void loadUnitSystemData(LuaTable& table);
  QString getUnit(QString id, QString defUnit) const;
 
  mutable GmElementDof* _dofMap[GM_NUM_CELL_TYPES];  
 
  bool loadAdditionalPrivateData(LuaTable& table, GmpFemPhysicsData& elemData);
  
  bool loadNodeData(LuaTable& table, GmpFemPhysicsData& elemData);
 
  bool loadElementData(LuaTable& table, GmpFemPhysicsData& elemData);
 
  bool loadNeuralNetworkData(LuaTable& table, const char* name, GmpFemNeuralNetwork* netData);
 
private:
  const QVariantMap* _attrMap; 
  const GmpFemPhysicsCommonMaterialFactory*    _matFactory; 
  const GmSimulationData*                      _simData;                           
  QVector<QVariant>                            _attributes;                        
  int                                          _nodeDim;                           
  bool                                         _iso;                               
  bool                                         _supportedTypes[GM_NUM_CELL_TYPES]; 
protected:  
  unsigned int                                 _parallelMethods;                   
private:
  QList<QPair<int, GmValueAccessor*> >         _dofForceAttributes;                
  QVector<GmValueAccessor*>                    _svAccessors;                       
  QVector<int>                                 _svDof;                             
  GmValueAccessor*                             _nodeAccessor;           
  QVector<GmCellAccessor*>                     _propertyAccessors;      
  QVector<bool>                                _constantProperties;     
  QVector<GmValueAccessor*>                    _nodeAttrAccessors;      
  QVector<GmCellAccessor*>                     _cellAttrAccessors;      
  QVector<GmGaussAccessor*>                    _gaussAttrAccessors;     
  QVector<const GmBoundaryCondition*>          _boundaryConditions;     
  QVector<const GmContactBoundaryCondition*>   _contactConditions;      
  QStringList                                  _boundaryConditionTypes; 
  QStringList                                  _contactConditionTypes;  
  QVector<const GmBoundaryCondition*>          _calcBoundaryConditions; 
  QVector<GmBoundaryConditionAccessor*>        _bcAccessors;            
  QVector<GmContactBoundaryConditionAccessor*> _contactAccessors;       
  QVector<bool>                                _constantBcValues;       
  QVector<bool>                                _constantContactBcValues;
  QVector<GmValueAccessor*>                    _loadAccessors;          
  QStringList                                  _externalLoadsList;      
 
  DiscSetRequiredMode                          _discSetMode;              
  bool                                         _discSetElementMode;       
  QVector<GmDiscontinuityAccessor*>            _discSetPropertyAccessors; 
  GmSegmentCell2DIntersectionCoordAccessor*    _discSet2DInterCoordAc;    
 
  QMap<QString, QString>                       _unitSystem;             
  Unit                                         _timeUnit;               
  QVector<GmpFemPhysicsCommonMaterial*>        _materials;              
  GmCellAccessor*                              _materialIndex;          
  int                                          _defaultMaterialIndex;   
 
  struct MaterialTranslationInfo
  {
    MaterialTranslationInfo() 
      : _physicsName(""), _modelIndex(-1) {}
 
    MaterialTranslationInfo(QString physicsName, int modelIndex)
      : _physicsName(physicsName), _modelIndex(modelIndex) {}
 
    QString _physicsName;  
    int     _modelIndex;   
  };
 
  QMap<QString, MaterialTranslationInfo> _materialTranslationMap; 
  int     _largestModelMaterialIndex; 
  QString _defaultModelMaterialName;  
};
 
 
// Register types for storing them inside a QVariant
Q_DECLARE_METATYPE(GmpFemPhysicsCommon::Attribute);
Q_DECLARE_METATYPE(GmpFemPhysicsCommon::Value);
Q_DECLARE_METATYPE(GmpFemPhysicsCommon::ScalarValue);
Q_DECLARE_METATYPE(GmpFemPhysicsCommon::VectorValue);
Q_DECLARE_METATYPE(GmpFemPhysicsCommon::MatrixValue);
Q_DECLARE_METATYPE(GmpFemPhysicsCommon::HistoryValue); 
Q_DECLARE_METATYPE(GmpFemPhysicsCommon::Bc);
Q_DECLARE_METATYPE(GmpFemPhysicsCommon::AttributeList);
Q_DECLARE_METATYPE(GmpFemPhysicsCommon::ValueList);
Q_DECLARE_METATYPE(GmpFemPhysicsCommon::BcList);
Q_DECLARE_METATYPE(GmpFemPhysicsCommon::IntList);
 
#endif