gmpMechanicalMaterial.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_MECHANICAL_MATERIAL_H_
#define _GEMA_PLUGIN_MECHANICAL_MATERIAL_H_
 
#include "gmpMechanicalConfig.h"
 
#include <gmpFemPhysicsCommonMaterial.h>
#include "gmpFemPhysicsCommon.h"
#include "gmpMechanicPoint.h"
#include "gmpFemPhysics.h"
#include "gmVector.h"
#include "gmMatrix.h"
#include <gmTrace.h>
 
#define SQRT3 1.7320508075688772935274463415059
class GMP_MECHANICAL_PHYSICS_API_EXPORT GmpMechanicalMaterial : public GmpFemPhysicsCommonMaterial
{
public:
 
  GmpMechanicalMaterial(int typeIndex, QString typeName, const GmLogCategory& logger)
    : GmpFemPhysicsCommonMaterial(typeIndex, typeName, logger)
  {
  }
 
  virtual ~GmpMechanicalMaterial() {}
 
  virtual bool mechanicalConstitutiveModel(const GmElement* e, GmMatrix& Dep, const GmpMechanicPoint* mp, const GmVector* coord, const GmVector& Time, unsigned nc, bool ips = false) const = 0;
 
  virtual void tangentModulus(const GmElement* e, GmMatrix& Dep, const GmpMechanicPoint* mp, const GmVector* coord, unsigned nc, unsigned ips = false) const
  {
    // TODO: Revisar para retirar da barra que ainda usa 
          Q_UNUSED(e); Q_UNUSED(Dep); Q_UNUSED(mp); Q_UNUSED(coord); Q_UNUSED(nc); Q_UNUSED(ips);
  }
 
  virtual bool isIsotropic() const = 0;
 
  virtual bool setInitialConditions(const GmElement* e, GmpMechanicPoint* mp, const GmVector* coord, unsigned sc) const
  {
    Q_UNUSED(e); Q_UNUSED(mp); Q_UNUSED(coord); Q_UNUSED(sc);
    return true;
  }
  
  // Updates deformation gradient F according to material requirement
  virtual bool updateDeformationGradient(GmMatrix& F, const GmElement* e, const GmVector* coord, int ip, bool ips = false) const
  {
    S_TRACE();
    Q_UNUSED(F); Q_UNUSED(ips); Q_UNUSED(e); Q_UNUSED(coord); Q_UNUSED(ip);
    // To check and implement...
    // Plane strain condition
    //F.at(2, 2) = 1;
    return true;
  }
 
  virtual bool calcDerivedResults(const GmElement* e, GmpMechanicPoint* mp, const GmVector* coord, unsigned sc) const
  {
    Q_UNUSED(e); Q_UNUSED(mp); Q_UNUSED(coord); Q_UNUSED(sc);
    return true;
  }
};
 
namespace GmpMechanicUtils
{
  //Returns the number of stress componets
  GMP_MECHANICAL_PHYSICS_API_EXPORT int getNumStressComp(unsigned st);
  // Returns the Shear modulus
  double shearModulus(double E, double nu);
  // Returns the Bulk modulus
  double bulkModulus(double E, double nu);
  // Returns the Lame modulus
  double lameModulus(double E, double nu);
 
  //stress invariants
  double stressInvariantI1(const GmVector&, unsigned);
  double stressInvariantI2(const GmVector&, unsigned);
  double stressInvariantI3(const GmVector&, unsigned);
 
  GmVector stressInvariants(const GmVector&, unsigned);
 
  void stressGradientI1(const GmVector&, unsigned, GmVector&);
  void stressGradientI2(const GmVector&, unsigned, GmVector&);
  void stressGradientI3(const GmVector&, unsigned, GmVector&);
 
  void stressHessianI2(const GmVector&, unsigned, GmMatrix&);
  void stressHessianI3(const GmVector&, unsigned, GmMatrix&);
 
  //principal stress
  GmVector stressPrincipal(const GmVector&, unsigned);
 
  //hydrostatic stress
  double hydrostaticStress(const GmVector&, unsigned);
 
  void hydrostaticGradient(const GmVector&, unsigned);
 
  //deviatoric stress
  GmVector deviatoricTensor(const GmVector& s, unsigned st);
 
  // Deviatoric invariant J2
  double deviatoricInvariantJ2(const GmVector&, unsigned);
  // Deviatoric invariant J3
  double deviatoricInvariantJ3(const GmVector&, unsigned);
  // Deviatoric invariants J = [J1, J2, J3]'
  GmVector deviatoricInvariants(const GmVector&, unsigned);
  // Deviatoric stress gradient dJ2/ds
  void deviatoricGradientJ2(const GmVector&, unsigned, GmVector&);
  // Deviatoric stress gradient dJ3/ds
  void deviatoricGradientJ3(const GmVector&, unsigned, GmVector&);
  // Deviatoric stress hessian ddJ2/dds
  void deviatoricHessianJ2(const GmVector&, unsigned, GmMatrix&);
  // Deviatoric stress hessian ddJ3/dds
  void deviatoricHessianJ3(const GmVector&, unsigned, GmMatrix&);
 
  //deviatoric principal
  GmVector deviatoricPrincipal(const GmVector&, unsigned);
 
  //von mises stress
  double vonMisesStress(const GmVector&, unsigned);
  // Von-Mises stress gradient
  void vonMisesGradient(const GmVector&, unsigned, GmVector&);
  // Von-Mises hessian
  void vonMisesHessian(const GmVector&, unsigned, GmMatrix&);
 
  // Lode angle
  double lodeAngle(const GmVector&, unsigned);
  // Lode coordinates
  GmVector lodeCoordinates(const GmVector&, unsigned);
  // Lode MC angle
  double lodeAngleMC(const GmVector&, unsigned);
 
  // Isotropic damage matrix 
  GmMatrix isotropicDamageMatrix(double d);
  // Anisotropic damage matrix 
  GmMatrix anisotropicDamageMatrix(GmVector dam);
 
  // Reorganize from vector to tensorial representation and vice versa
  void vectorialToTensorial(GmVector& Av, GmMatrix& Am, unsigned sc, QString type = "strain", bool mode = true);
 
  // Fills the vectorial rotation matrix
  void fillTransformationMatrix(GmMatrix R, GmMatrix& Te, GmMatrix& Tei, int ns);
 
  // Fills rotation matrix using the angle of dip and strike
  void fillRotationMatrixFromDip(GmMatrix& R, double dip, double strike);
 
  // Fills rotation matrix using The Euler's angles
  void fillRotationMatrixFromEulerAngle(GmMatrix& R, double phi, double theta, double psi);
 
  // Evaluates pseudo-inverse
  //void pseudoInverse(GmMatrix& M, double tol = 0.0);
 
  // Computes the elastic stiffness matrix using E and Nu
  void elasticStiffness(GmMatrix& De, double E, double nu, unsigned sc, unsigned ips);
 
  // Computes the elastic stiffness matrix using lame and G
  void elasticStiffnessLameG(GmMatrix& De, double lame, double G, unsigned sc, unsigned ips);
 
  // Computes the elastic stiffness matrix using K and G
  void elasticStiffnessKG(GmMatrix& De, double K, double G, unsigned sc, unsigned ips);
 
  // Computes the elastic flexibility matrix using E and Nu
  void elasticFlexibility(GmMatrix& Ce, double E, double nu, unsigned sc, unsigned ips);
};
#endif