gmpMaterialGeneralizedDualPorosity.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_HYDRAULIC_MATERIAL_GENERALIZEDDUALPOROSITY_H_
#define _GEMA_PLUGIN_HYDRAULIC_MATERIAL_GENERALIZEDDUALPOROSITY_H_
 
#include "gmpHydraulicMaterial.h"
#include "gmpMaterialDualPorosity.h"
 
class GMP_HYDRAULIC_PHYSICS_API_EXPORT GmpHydraulicMaterialGeneralizedDualPorosity : public GmpHydraulicMaterialDualPorosity
{
protected:
  enum DualPorosityElementPropertyIds
  {
    Sfr_ID = GmpHydraulicMaterialDualPorosity::NUM_PROPERTY_IDS, 
    Bfr_ID,                                                      
    DIP_ID,                                                      
    STRIKE_ID,                                                   
 
    // --- NO ADDING BELOW THIS LINE
    NUM_PROPERTY_IDS,  
  };
 
public:
 
  GmpHydraulicMaterialGeneralizedDualPorosity(int typeIndex, QString typeName, const GmLogCategory& logger)
    : GmpHydraulicMaterialDualPorosity(typeIndex, typeName, logger) {}
 
  static GmpFemPhysicsCommonMaterial* instance(GmSimulationData* simulation, int typeIndex, QString typeName, const GmLogCategory& logger)
  {
    Q_UNUSED(simulation);
    return new GmpHydraulicMaterialGeneralizedDualPorosity(typeIndex, typeName, logger);
  }
 
  // set dual porosity material map
  virtual const QVariantMap* materialMetaDataMap();
 
  virtual GmVector fractureSetSpacing(const GmElement* e, const GmVector* coord, int ip) const
  {
    S_TRACE(); assert(e);
    GmVector Sf;
    GmCellAccessor* sfAc = propertyAc(Sfr_ID);
    // fill property values
    if (!vectorPropertyValue(e, sfAc, Sf, coord, ip)) {
      Sf.set_size(1);
      return Sf.fill(0);
    }
    return Sf;
  }
 
  virtual GmVector fractureSetAperture(const GmElement* e, const GmVector* coord, int ip) const
  {
    S_TRACE(); assert(e);
    GmVector Bfr;
    GmCellAccessor* bfAc = propertyAc(Bfr_ID);
    // Fills property values
    vectorPropertyValue(e, bfAc, Bfr, coord, ip);
 
    return Bfr;
  }
  
  virtual GmVector fractureSetDip(const GmElement* e, const GmVector* coord, int ip) const
  {
    S_TRACE(); assert(e);
    GmVector Dip;
    GmCellAccessor* dipAc = propertyAc(DIP_ID);
    // Fills property values
    vectorPropertyValue(e, dipAc, Dip, coord, ip);
 
    return Dip;
  }
 
  virtual GmVector fractureSetStrike(const GmElement* e, const GmVector* coord, int ip) const
  {
    S_TRACE(); assert(e);
    GmVector Strike;
    GmCellAccessor* strikeAc = propertyAc(STRIKE_ID);
    // fill property values
    if (!vectorPropertyValue(e, strikeAc, Strike, coord, ip)) {
      Strike.set_size(1);
      return Strike.fill(0);
    }
    return Strike;
  }
 
  virtual double fillFracturePorosity(const GmElement* e, const GmVector* coord, int ip) const;
  
  virtual bool fillFracturePermeability(const GmElement* e, GmMatrix& Kper, const GmVector* coord, int ip) const;
  
  virtual bool fillShapeFactor(const GmElement* e, double& ws, GmMatrix Km, const GmVector* coord, int ip)const;
  
  virtual GmMatrix fillRotationMatrix(int dim, double dip, double strike) const
  {
          GmMatrix Rot(dim, dim);
          Rot.fill(0);
          if (dim == 2) 
          {
                  // fills bidimensional rotation matrix 
                  Rot(0, 0) = cos(strike);  Rot(0, 1) = sin(strike);
                  Rot(1, 0) = -sin(strike);  Rot(1, 1) = cos(strike);
          }
          if (dim == 3)  
          {
                  // fills threedimensional rotation matrix
                  Rot(0, 0) = sin(strike); 
                  Rot(0, 1) = cos(strike);
                  Rot(1, 0) = cos(dip)*cos(strike);
                  Rot(1, 1) = -cos(dip)*sin(strike);
                  Rot(1, 2) = -sin(dip);
                  Rot(2, 0) = -sin(dip)*cos(strike);
                  Rot(2, 1) =  sin(dip)*sin(strike);
                  Rot(2, 2) = -cos(dip);
          }
 
          return Rot;
 
  };
  
  virtual GmMatrix fillFractureLocalPermeability(int dim, double bi, double si) const
  {
          GmMatrix Kfrl(dim, dim);
          Kfrl.fill(0);
          if (dim == 2)
          {
                  // fills bidimensional rotation matrix
                  Kfrl(0, 0) = pow(bi, 3) / (12 * si);
          }
          if (dim == 3)
          {
                  // fills threedimensional rotation matrix
                  Kfrl(0, 0) = pow(bi, 3) / (12 * si);
                  Kfrl(1, 1) = pow(bi, 3) / (12 * si);
          }
          return Kfrl;
  };  
 
  bool GmpHydraulicMaterialGeneralizedDualPorosity::NormalFractureVector(GmVector& Vn, GmMatrix J)
{
        S_TRACE();
 
        double J1 = 0.0, J2 = 0.0, J3 = 0.0;
        J1 = J(0, 0)*J(1, 1) - J(1, 0)*J(0, 1);
        J2 = J(0, 0)*J(1, 2) - J(1, 0)*J(0, 2);
        J3 = J(0, 1)*J(1, 2) - J(1, 1)*J(0, 2);
 
        double  detJ2;
        //Normal Vn at normal direction 3
        detJ2 = sqrt(J1*J1 + J2 * J2 + J3 * J3);
        Vn(0) = J3 / detJ2;            // Vn(0)
        Vn(1) = -J2 / detJ2;           // Vn(1)
        Vn(2) = J1 / detJ2;            // Vn(2)
 
        return true;
}
};
 
 
#endif