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>

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 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 state
  void setStressStateVector(const double[6], GmVector&, unsigned, double = 1.0);
  void setStressStateMatrix(const double[6][6], GmMatrix&, unsigned, double = 1.0);

  //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);

  // Computes the The Macaulay brackets
  GmVector vectorialMacaulay(GmVector x);

  // Returns the scalar Macaulay function
  double macaulayFunction(double x);

  // 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