gmpMaterialPowerLawCreep.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_MECHANICALMATERIAL_POWERLAWCREEP_H_
#define _GEMA_PLUGIN_MECHANICALMATERIAL_POWERLAWCREEP_H_
 
#include "gmpMechanicalConfig.h"
#include <gmpFemPhysics.h>
#include <gmMathUtils.h>
 
#include <gmpMaterialCreep.h>
#include "gmpMechanicPoint.h"
 
class GMP_MECHANICAL_PHYSICS_API_EXPORT GmpMaterialPowerLawCreep : public GmpMaterialCreep
{
protected:
  enum ElementPropertyIds
  {
    Af_ID = GmpMaterialCreep::ElementPropertyIds::NUM_PROPERTY_IDS,  
    An_ID,                              
    Am_ID,                              
    Ak_ID,                              
 
    // --- NO ADDING BELOW THIS LINE
    NUM_PROPERTY_IDS,  
  };
 
public:
 
  GmpMaterialPowerLawCreep(int typeIndex, QString typeName, const GmLogCategory& logger)
    : GmpMaterialCreep(typeIndex, typeName, logger) {}
 
  virtual ~GmpMaterialPowerLawCreep() {}
 
  static GmpFemPhysicsCommonMaterial* instance(GmSimulationData* simulation, int typeIndex, QString typeName, const GmLogCategory& logger)
  {
    Q_UNUSED(simulation);
    return new GmpMaterialPowerLawCreep(typeIndex, typeName, logger);
  }
 
  // Returns a map with material associated properties. 
  virtual const QVariantMap* materialMetaDataMap()
  {
    S_TRACE();
    static QVariantMap m;
    if (m.isEmpty())
    {
      // read the material attribute map from elastic interface material
      m = *GmpMaterialCreep::materialMetaDataMap();
 
      // Adds material properties
      GmpFemPhysicsCommon::ValueList matPLProp = m["properties"].value<GmpFemPhysicsCommon::ValueList>();
      matPLProp.append(GmpFemPhysicsCommon::ScalarValue(Af_ID, "Af", QObject::tr("Structure factor of PL"), "", true));
      matPLProp.append(GmpFemPhysicsCommon::ScalarValue(An_ID, "An", QObject::tr("Stress power of PL"), "", true));
      matPLProp.append(GmpFemPhysicsCommon::ScalarValue(Am_ID, "Am", QObject::tr("Time power of PL"), "", true));
      matPLProp.append(GmpFemPhysicsCommon::ScalarValue(Ak_ID, "Ak", QObject::tr("Temperature power of PL"), "", true));
      m["properties"] = matPLProp;
    }
    return &m;
  }
 
  // Returns the stresses according to the material behavior adopted
  virtual double fillCreepStrainRate(const GmElement* e, const GmpMechanicPoint* mp, const GmVector* coord, const GmVector& Time, double MISES) const
  {
    S_TRACE();
    assert(e);
 
    double creepRate = 0.0, A, k, n, m;
    double cTime,  TEMP; //pTime, dTime,
 
    // Reads time parameters 
    cTime = Time(0);
    //pTime = Time(1);
    //dTime = cTime - pTime;
 
    unsigned pointIndex = mp->_index.localData();
    // Reads steady-state creep parameters      
    A = structureFactorPL(e, coord, pointIndex);  // Power law multiplier
    n = stressPowerPL(e, coord, pointIndex);      // stress power
    m = timePowerPL(e, coord, pointIndex);        // time power
    k = temperaturePowerPL(e, coord, pointIndex); // Temperature power PL
 
    // No creep for Misses equal to zero
    if (MISES == 0.0)
    {
      return 0.0;
    }
    
    // Read the Temperature at integration point
    if (nodeAttrAc(T_NA_ID) != NULL)
    {
      TEMP = fillTemperatureFromNodalAttr(e, coord);
    }
    else
    {
      TEMP = temperatureProperty(e, coord, pointIndex);
    }
 
    // Computes the creep strain rate 
    if (cTime > 0)
    {
      creepRate = A * pow(TEMP, k) * pow(MISES, n) * pow(cTime, m);
    }
  
#if 0
 
  if (dTime > 0)
    eCreepRate = (A * pow(MISES, n) * pow(TEMP, k) / (m + 1)) * (pow(cTime, (m + 1)) - pow(pTime, (m + 1))) * (1 / dTime);
  else
    eCreepRate = 0;
#endif // 0
 
    return creepRate;
  }
 
  double timePowerPL(const GmElement* e, const GmVector* coord, int ip) const
  {
    return propertyAc(Am_ID)->scalarValueAt(e, coord, ip);
  }
 
  double structureFactorPL(const GmElement* e, const GmVector* coord, int ip) const
  {
    return propertyAc(Af_ID)->scalarValueAt(e, coord, ip);
  }
 
  double temperaturePowerPL(const GmElement* e, const GmVector* coord, int ip) const
  {
    return propertyAc(Ak_ID)->scalarValueAt(e, coord, ip);
  }
 
  double stressPowerPL(const GmElement* e, const GmVector* coord, int ip) const
  {
    return propertyAc(An_ID)->scalarValueAt(e, coord, ip);
  }
};
 
#endif