Creation of a CoupleSolidModel to handle Poro-Solid-Damage models.

host-configs/darwin-clang.cmake

@@ -34,7 +34,7 @@ set(ENABLE_GEOSX_PTP ON CACHE BOOL "" FORCE)
 
 set(GEOSX_TPL_DIR "/usr/local/GEOSX/GEOSX_TPL" CACHE PATH "" FORCE )
 if(NOT ( EXISTS "${GEOSX_TPL_DIR}" AND IS_DIRECTORY "${GEOSX_TPL_DIR}" ) )
-    set(GEOSX_TPL_DIR "../../thirdPartyLibs/install-darwin-clang-release" CACHE PATH "" FORCE )
+    set(GEOSX_TPL_DIR "../../../thirdPartyLibs/install-darwin-clang-release" CACHE PATH "" FORCE )
 endif()
 
 include(${CMAKE_CURRENT_LIST_DIR}/tpls.cmake)

src/coreComponents/constitutive/CMakeLists.txt

@@ -34,6 +34,8 @@ set( constitutive_headers
      fluid/ProppantSlurryFluid.hpp
      fluid/ParticleFluidBase.hpp
      fluid/particleFluidSelector.hpp
+     solid/CompressibleSolid.hpp
+     solid/CoupledSolid.hpp
      solid/Damage.hpp
      solid/DamageVolDev.hpp
      solid/DamageSpectral.hpp
@@ -44,13 +46,17 @@ set( constitutive_headers
      solid/ElasticTransverseIsotropic.hpp
      solid/PoroElastic.hpp
      solid/PoreVolumeCompressibleSolid.hpp
+     solid/PorousSolid.hpp
      solid/PropertyConversions.hpp
      solid/SolidBase.hpp
      solid/SolidModelDiscretizationOps.hpp
      solid/SolidModelDiscretizationOpsFullyAnisotroipic.hpp
      solid/SolidModelDiscretizationOpsIsotropic.hpp
      solid/SolidModelDiscretizationOpsTransverseIsotropic.hpp
      solid/TriaxialDriver.hpp
+     solid/porosity/BiotPorosity.hpp
+     solid/porosity/PorosityBase.hpp
+     solid/porosity/PressurePorosity.hpp
      relativePermeability/RelativePermeabilityBase.hpp
      relativePermeability/BrooksCoreyRelativePermeability.hpp
      relativePermeability/BrooksCoreyBakerRelativePermeability.hpp
@@ -88,7 +94,8 @@ set( constitutive_sources
      fluid/SlurryFluidBase.cpp
      fluid/ProppantSlurryFluid.cpp
      fluid/ParticleFluidBase.cpp
-     fluid/ParticleFluid.cpp               
+     fluid/ParticleFluid.cpp
+     solid/CompressibleSolid.cpp      
      solid/Damage.cpp
      solid/DamageVolDev.cpp
      solid/DamageSpectral.cpp
@@ -98,8 +105,12 @@ set( constitutive_sources
      solid/ElasticTransverseIsotropic.cpp
      solid/PoroElastic.cpp
      solid/PoreVolumeCompressibleSolid.cpp
+     solid/PorousSolid.cpp
      solid/SolidBase.cpp
      solid/TriaxialDriver.cpp
+     solid/porosity/BiotPorosity.cpp
+     solid/porosity/PorosityBase.cpp
+     solid/porosity/PressurePorosity.cpp
      relativePermeability/RelativePermeabilityBase.cpp
      relativePermeability/BrooksCoreyRelativePermeability.cpp
      relativePermeability/BrooksCoreyBakerRelativePermeability.cpp

src/coreComponents/constitutive/ConstitutivePassThru.hpp

@@ -28,6 +28,7 @@
 #include "solid/ElasticIsotropic.hpp"
 #include "solid/ElasticTransverseIsotropic.hpp"
 #include "solid/PoroElastic.hpp"
+#include "solid/PorousSolid.hpp"
 
 namespace geosx
 {
@@ -190,6 +191,54 @@ struct ConstitutivePassThru< DamageBase >
   }
 };
 
+
+/**
+ * Specialization for the PorousSolid models.
+ */
+template<>
+struct ConstitutivePassThru< PorousSolidBase >
+{
+  template< typename LAMBDA >
+  static void execute( ConstitutiveBase & constitutiveRelation, LAMBDA && lambda )
+  {
+    if( auto * const ptr1 = dynamic_cast< PorousSolid< DruckerPragerExtended > * >( &constitutiveRelation ) )
+    {
+      lambda( *ptr1 );
+    }
+    else if( auto * const ptr2 = dynamic_cast< PorousSolid< DruckerPrager > * >( &constitutiveRelation ) )
+    {
+      lambda( *ptr2 );
+    }
+    else if( auto * const ptr3 = dynamic_cast< PorousSolid< ElasticIsotropic > * >( &constitutiveRelation ) )
+    {
+      lambda( *ptr3 );
+    }
+    else if( auto * const ptr4 = dynamic_cast< PorousSolid< ElasticTransverseIsotropic > * >( &constitutiveRelation ) )
+    {
+      lambda( *ptr4 );
+    }
+    else if( auto * const ptr5 = dynamic_cast< PorousSolid< DamageSpectral< ElasticIsotropic > > * >( &constitutiveRelation ) )
+    {
+      lambda( *ptr5 );
+    }
+    else if( auto * const ptr6 = dynamic_cast< PorousSolid< DamageVolDev< ElasticIsotropic > > * >( &constitutiveRelation ) )
+    {
+      lambda( *ptr6 );
+    }
+    else if( auto * const ptr7 = dynamic_cast< PorousSolid< Damage< ElasticIsotropic > > * >( &constitutiveRelation ) )
+    {
+      lambda( *ptr7 );
+    }
+    else
+    {
+      GEOSX_ERROR( "ConstitutivePassThru< PorousSolidBase >::execute failed. The constitutive relation is named "
+                   << constitutiveRelation.getName() << " with type "
+                   << LvArray::system::demangleType( constitutiveRelation ) );
+    }
+  }
+};
+
+
 }
 }
 

src/coreComponents/constitutive/permeability/CarmanKozenyPermeability.cpp

@@ -0,0 +1,64 @@
+/*
+ * ------------------------------------------------------------------------------------------------------------
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
+ * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
+ * Copyright (c) 2018-2020 Total, S.A
+ * Copyright (c) 2019-     GEOSX Contributors
+ * All rights reserved
+ *
+ * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
+ * ------------------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @file CarmanKozenyPermeability.cpp
+ */
+
+#include "CarmanKozenyPermeability.hpp"
+
+namespace geosx
+{
+
+using namespace dataRepository;
+
+namespace constitutive
+{
+
+
+CarmanKozenyPermeability::CarmanKozenyPermeability( string const & name, Group * const parent ):
+  PermeabilityBase( name, parent )
+{
+  registerWrapper( viewKeyStruct::particleDiameterString(), &m_particleDiameter ).
+    setInputFlag( InputFlags::REQUIRED ).
+    setDescription( "Diameter of the spherical particles." );
+
+  registerWrapper( viewKeyStruct::sphericityString(), &m_sphericity ).
+    setInputFlag( InputFlags::REQUIRED ).
+    setDescription( "Sphericity of the particles." );
+
+  registerWrapper( viewKeyStruct::dPerm_dPorosityString(), &m_dPerm_dPorosity );
+}
+
+std::unique_ptr< ConstitutiveBase >
+CarmanKozenyPermeability::deliverClone( string const & name,
+                                        Group * const parent ) const
+{
+  return ConstitutiveBase::deliverClone( name, parent );
+}
+
+void CarmanKozenyPermeability::allocateConstitutiveData( dataRepository::Group & parent,
+                                                         localIndex const numConstitutivePointsPerParentIndex )
+{
+  m_dPerm_dPorosity.resize( 0, numConstitutivePointsPerParentIndex, 3 );
+  PermeabilityBase::allocateConstitutiveData( parent, numConstitutivePointsPerParentIndex );
+}
+
+void CarmanKozenyPermeability::postProcessInput()
+{}
+
+REGISTER_CATALOG_ENTRY( ConstitutiveBase, CarmanKozenyPermeability, string const &, Group * const )
+
+}
+} /* namespace geosx */

src/coreComponents/constitutive/permeability/CarmanKozenyPermeability.hpp

@@ -0,0 +1,168 @@
+/*
+ * ------------------------------------------------------------------------------------------------------------
+ * SPDX-License-Identifier: LGPL-2.1-only
+ *
+ * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
+ * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
+ * Copyright (c) 2018-2020 Total, S.A
+ * Copyright (c) 2019-     GEOSX Contributors
+ * All rights reserved
+ *
+ * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
+ * ------------------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * @file CarmanKozenyPermeability.hpp
+ */
+
+#ifndef GEOSX_CONSTITUTIVE_PERMEABILITY_CARMANKOZENYPERMEABILITY_HPP_
+#define GEOSX_CONSTITUTIVE_PERMEABILITY_CARMANKOZENYPERMEABILITY_HPP_
+
+#include "constitutive/permeability/PermeabilityBase.hpp"
+
+
+namespace geosx
+{
+namespace constitutive
+{
+
+class CarmanKozenyPermeabilityUpdate : public PermeabilityBaseUpdate
+{
+public:
+
+  CarmanKozenyPermeabilityUpdate( arrayView3d< real64 > const & permeability,
+                                  arrayView3d< real64 > const & dPerm_dPressure,
+                                  arrayView3d< real64 > const & dPerm_dPorosity,
+                                  real64 const particleDiameter,
+                                  real64 const sphericity )
+    : PermeabilityBaseUpdate( permeability, dPerm_dPressure ),
+    m_dPerm_dPorosity( dPerm_dPorosity ),
+    m_particleDiameter( particleDiameter ),
+    m_sphericity( sphericity )
+  {}
+
+  /// Default copy constructor
+  CarmanKozenyPermeabilityUpdate( CarmanKozenyPermeabilityUpdate const & ) = default;
+
+  /// Default move constructor
+  CarmanKozenyPermeabilityUpdate( CarmanKozenyPermeabilityUpdate && ) = default;
+
+  /// Deleted copy assignment operator
+  CarmanKozenyPermeabilityUpdate & operator=( CarmanKozenyPermeabilityUpdate const & ) = delete;
+
+  /// Deleted move assignment operator
+  CarmanKozenyPermeabilityUpdate & operator=( CarmanKozenyPermeabilityUpdate && ) = delete;
+
+  GEOSX_HOST_DEVICE
+  GEOSX_FORCE_INLINE
+  void compute( real64 const & porosity,
+                arraySlice1d< real64 > const & permeability,
+                arraySlice1d< real64 > const & dPerm_dPorosity ) const;
+
+  GEOSX_HOST_DEVICE
+  GEOSX_FORCE_INLINE
+  virtual void updatePorosity( localIndex const k,
+                               localIndex const q,
+                               real64 const & porosity ) const override
+  {
+    compute( porosity,
+             m_permeability[k][q],
+             m_dPerm_dPorosity[k][q] );
+  }
+
+private:
+
+  /// dPermeability_dPorosity
+  arrayView3d< real64 > m_dPerm_dPorosity;
+
+  /// Particle diameter
+  real64 m_particleDiameter;
+
+  /// Sphericity of the particles
+  real64 m_sphericity;
+
+};
+
+
+class CarmanKozenyPermeability : public PermeabilityBase
+{
+public:
+  CarmanKozenyPermeability( string const & name, Group * const parent );
+
+  ~CarmanKozenyPermeability() = default;
+
+  std::unique_ptr< ConstitutiveBase > deliverClone( string const & name,
+                                                    Group * const parent ) const override;
+
+  virtual void allocateConstitutiveData( dataRepository::Group & parent,
+                                         localIndex const numConstitutivePointsPerParentIndex ) override;
+
+  static string catalogName() { return "CarmanKozenyPermeability"; }
+
+  virtual string getCatalogName() const override { return catalogName(); }
+
+  /// Type of kernel wrapper for in-kernel update
+  using KernelWrapper = CarmanKozenyPermeabilityUpdate;
+
+  /**
+   * @brief Create an update kernel wrapper.
+   * @return the wrapper
+   */
+  KernelWrapper createKernelWrapper()
+  {
+    return KernelWrapper( m_permeability,
+                          m_dPerm_dPressure,
+                          m_dPerm_dPorosity,
+                          m_particleDiameter,
+                          m_sphericity );
+  }
+
+
+  struct viewKeyStruct : public PermeabilityBase::viewKeyStruct
+  {
+    static constexpr char const * dPerm_dPorosityString() { return "dPerm_dPorosity"; }
+    static constexpr char const * particleDiameterString() { return "particleDiameter"; }
+    static constexpr char const * sphericityString() { return "sphericity"; }
+  } viewKeys;
+
+protected:
+  virtual void postProcessInput() override;
+
+private:
+  /// dPermeability_dPorosity
+  array3d< real64 > m_dPerm_dPorosity;
+
+  /// Particle diameter
+  real64 m_particleDiameter;
+
+  /// Sphericity of the particles
+  real64 m_sphericity;
+};
+
+
+GEOSX_HOST_DEVICE
+GEOSX_FORCE_INLINE
+void CarmanKozenyPermeabilityUpdate::compute( real64 const & porosity,
+                                              arraySlice1d< real64 > const & permeability,
+                                              arraySlice1d< real64 > const & dPerm_dPorosity ) const
+{
+  real64 const permValue = pow( m_sphericity*m_particleDiameter, 2 ) * pow( porosity, 3 )
+                           / (150 * pow( (1 - porosity), 2 ) );
+  real64 const dPerm_dPorValue = pow( m_sphericity*m_particleDiameter, 2 ) * pow( porosity, 3 );
+
+  for( localIndex i=0; i < permeability.size(); i++ )
+  {
+    permeability[i] = permValue;
+    dPerm_dPorosity[i] = dPerm_dPorValue;
+  }
+}
+
+
+
+}/* namespace constitutive */
+
+} /* namespace geosx */
+
+
+#endif //GEOSX_CONSTITUTIVE_PERMEABILITY_FRACTUREPERMEABILITY_HPP_