xfemHydroMechanicalMaterial.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2017 by Geomechanic group - Tecgraf/Puc-Rio
** 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_XFEM_HYDROMECHANICALMATERIAL_H_
#define _GEMA_XFEM_HYDROMECHANICALMATERIAL_H_
 
#include <gmTrace.h>
#include <gmpHydraulicMaterial.h>
#include <gmpMechanicalMaterial.h>
 
#include "xfemMaterial.h"
 
//template <class T> class XfemHydroMechanicalMaterial : public T
class XfemHydroMechanicalMaterial : public XfemMaterial
{
public:
  //enum ElemHMXfemGaussAttributeIds
  //{
  //  Sw_GA_ID,             //!< Base Id for Gauss attribute(s) used to store the wetting fluid saturation
  //
  //  // --- NO ADDING BELOW THIS LINE
  //  NUM_GA_IDS,  //!< The number of property ids above
  //};
  XfemHydroMechanicalMaterial(int typeIndex, QString typeName, const GmLogCategory& logger)
    : XfemMaterial(typeIndex, typeName, logger)
  {
    _hydroMaterial = NULL;
    _mechanoMaterial = NULL;
  }
 
  // destructor
  virtual ~XfemHydroMechanicalMaterial(){};
 
  static GmpFemPhysicsCommonMaterial* instance(GmSimulationData* simulation, int typeIndex, QString typeName, const GmLogCategory& logger)
  {    
    Q_UNUSED(simulation);
    return new XfemHydroMechanicalMaterial(typeIndex, typeName, logger);
  }
 
  // Returns a map with material associated properties. 
  virtual const QVariantMap* materialMetaDataMap();
 
  // Returns the constitutive tangent matrix
  virtual void tangentModulus(const GmElement* e, GmMatrix& Dep, const GmpMechanicPoint* mp, const GmVector* coord, unsigned nc, unsigned ips) const;
 
  // Returns the stresses according to the material behavior adopted
  virtual void returnMapping(const GmElement* e, GmMatrix& Dep, const GmpMechanicPoint* mp, const GmVector* coord, unsigned nc, unsigned ips) const;
  
  //virtual bool initialCondition(const GmElement* e, const GmVector* coord, int ip) const;
  
  // Returns a gauss atribute accessor
  //virtual GmGaussAccessor* gaussAttributeAccessor(int gausAcc)const;
  
  // Returns a gauss atribute accessor
  //virtual XfemGaussAccessor* enrichedGaussAttributeAccessor(int gausAcc)const;
 
  virtual double solidBulkModulus(const GmElement* e, const GmVector* coord, int ip) const
  {
    if (propertyAc(KSS_ID) == NULL)
    {
      return 1.0e25;
    }
        double Kss = propertyAc(KSS_ID)->scalarValueAt(e, coord, ip);
        if (Kss <= 0.0) { Kss = 1.0e25; }
 
        return Kss;
  }
 
  virtual double nonWettingBulkModulus(const GmElement* e, const GmVector* coord, int ip) const
  {
          if (propertyAc(Knw_ID) == NULL)
          {
                  return 1.0e25;
          }
          double Kss = propertyAc(Knw_ID)->scalarValueAt(e, coord, ip);
          if (Kss <= 0.0) { Kss = 1.0e25; }
 
          return Kss;
  }
 
  virtual double fluidViscosity(const GmElement* e, const GmVector* coord, int ip) const
  {
    S_TRACE();
    assert(e);
    return propertyAc(UFw_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double interfaceBiotModulus(const GmElement* e, const GmVector* coord, int ip) const
  {
    S_TRACE();
    assert(e);
    if (propertyAc(MFw_ID) == NULL)
    {
      return 0;
    }
    return propertyAc(MFw_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double leakoffTop(const GmElement* e, const GmVector* coord, int ip) const
  {
    S_TRACE();
    assert(e);
    if (propertyAc(LKT_ID) == NULL)
    {
      return 0;
    }
    return propertyAc(LKT_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double leakoffBottom(const GmElement* e, const GmVector* coord, int ip) const
  {
    S_TRACE();
    assert(e);
    if (propertyAc(LKB_ID) == NULL)
    {
      return 0;
    }
    return propertyAc(LKB_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double initialWaterSaturation(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(SIW_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(SIW_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double residualWaterSaturation(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(SRW_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(SRW_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double bubblingPressure(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(PBB_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(PBB_ID)->scalarValueAt(e, coord, ip);
  }
  
  virtual double nWFluidViscosity(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(UFnw_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(UFnw_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double intrinsicPermeability(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(Kim_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(Kim_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double wettingFluidDensity(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(rhow_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(rhow_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double nonWettingFluidDensity(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(rhonw_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(rhonw_ID)->scalarValueAt(e, coord, ip);
  }
  
  virtual double solidDensity(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(rhos_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(rhos_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double gammaNonWettingFluid(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(Gnw_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(Gnw_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double specificHeatWettingFluid(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(CTw_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(CTw_ID)->scalarValueAt(e, coord, ip);
  }
  
  virtual double specificHeatNonWettingFluid(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(CTnw_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(CTnw_ID)->scalarValueAt(e, coord, ip);
  }
  
  virtual double specificHeatSolid(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(CTs_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(CTs_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double thermalConductivityWettingFluid(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(KTw_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(KTw_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double thermalConductivityNonWettingFluid(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(KTnw_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(KTnw_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double thermalConductivitySolid(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(KTs_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(KTs_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double thermalExpansionWettingFluid(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(BTw_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(BTw_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double thermalExpansionNonWettingFluid(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(BTnw_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(BTnw_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double thermalExpansionSolid(const GmElement* e, const GmVector* coord, int ip) const
  {
          S_TRACE();
          assert(e);
          if (propertyAc(BTs_ID) == NULL)
          {
                  return 0;
          }
          return propertyAc(BTs_ID)->scalarValueAt(e, coord, ip);
  }
 
  virtual double cubicLaw(const GmElement* e, const GmVector* coord, int ip, double wn, bool cubiclaw) const;
  virtual double cubicLawMP(const GmElement* e, const GmVector* coord, int ip, double wn, bool cubiclaw) const;
 
protected:
  enum ElemHMXfemPropertyIds
  {
    KSS_ID = XfemMaterial::NUM_PROPERTY_IDS,  
    UFw_ID,                                   
    MFw_ID,                                   
    LKT_ID,                                   
    LKB_ID,                                   
        SIW_ID,                                    
        SRW_ID,                                   
        PBB_ID,                                   
        UFnw_ID,                                  
        Knw_ID,                                  
        Kim_ID,                                  
        rhow_ID,                                  
        rhonw_ID,                                  
        rhos_ID,                                  
        Gnw_ID,                                  
        CTw_ID,                                  
        CTnw_ID,                                  
        CTs_ID,                                  
        KTw_ID,                                  
        KTnw_ID,                                  
        KTs_ID,                                  
        BTw_ID,                                  
        BTnw_ID,                                  
        BTs_ID,                                  
    // --- NO ADDING BELOW THIS LINE
    NUM_PROPERTY_IDS,  
  };
 
 
private:
  GmpFemPhysicsCommonMaterial*  _hydroMaterial;   
  GmpFemPhysicsCommonMaterial*  _mechanoMaterial; 
 
};
#endif