LagrangeBasis3GL.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 Total, S.A
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_FINITEELEMENT_ELEMENTFORMULATIONS_ELEMENTFORMULATIONS_LAGRANGEBASIS3GL_HPP_
#define GEOS_FINITEELEMENT_ELEMENTFORMULATIONS_ELEMENTFORMULATIONS_LAGRANGEBASIS3GL_HPP_
 
#include "common/DataTypes.hpp"
 
namespace geos
{
namespace finiteElement
{
 
class LagrangeBasis3GL
{
public:
  constexpr static localIndex numSupportPoints = 4;
 
  constexpr static real64 sqrt5 = 2.2360679774997897;
 
  GEOS_HOST_DEVICE
  inline
  constexpr static real64 weight( const int q )
  {
    switch( q )
    {
      case 1:
      case 2:
        return 5.0/6.0;
      default:
        return 1.0/6.0;
    }
  }
 
  GEOS_HOST_DEVICE
  inline
  // MODIF1 : Harcoding the Gauss-Lobatto coordinates and return the right one
  // depending on the supportPointIndex value
  //Switch case
  constexpr static real64 parentSupportCoord( const localIndex supportPointIndex )
  {
    real64 result=0.0;
 
    switch( supportPointIndex )
    {
      case 0:
        result = -1.0;
        break;
      case 1:
        result = -1.0/sqrt5;
        break;
      case 2:
        result = 1.0/sqrt5;
        break;
      case 3:
        result = 1.0;
        break;
      default:
        break;
    }
 
    return result;
  }
 
 
  GEOS_HOST_DEVICE
  inline
//MODIF3 : Change the  way to return the base function evaluated at the desired coord
  constexpr static real64 value( const int index,
                                 const real64 xi )
  {
    real64 result=0.0;
 
    switch( index )
    {
      case 0:
        result = LagrangeBasis3GL::value0( xi );
        break;
      case 1:
        result = LagrangeBasis3GL::value1( xi );
        break;
      case 2:
        result = LagrangeBasis3GL::value2( xi );
        break;
      case 3:
        result = LagrangeBasis3GL::value3( xi );
        break;
      default:
        break;
    }
 
    return result;
  }
 
 
  GEOS_HOST_DEVICE
  inline
  //MODFI4 : Implemented new base functions and their derivative for Q3
  constexpr static real64 value0( const real64 xi )
  {
    return -(5.0/8.0)*(xi*xi*xi-xi*xi-(1.0/5.0)*xi+1.0/5.0);
  }
 
  GEOS_HOST_DEVICE
  inline
  constexpr static real64 value1( const real64 xi )
  {
    return (5.0*sqrt5/8.0)*(xi*xi*xi-(1.0/sqrt5)*xi*xi-xi+1.0/sqrt5);
  }
 
  GEOS_HOST_DEVICE
  inline
  constexpr static real64 value2( const real64 xi )
  {
    return -(5.0*sqrt5/8.0)*(xi*xi*xi+(1.0/sqrt5)*xi*xi-xi-1.0/sqrt5);
  }
 
  GEOS_HOST_DEVICE
  inline
  constexpr static real64 value3( const real64 xi )
  {
    return (5.0/8.0)*(xi*xi*xi+xi*xi-(1.0/5.0)*xi-1.0/5.0);
  }
 
 
  GEOS_HOST_DEVICE
  inline
  //MODIF5 : New function returning the derivated base function at desired coord
  constexpr static real64 gradient( const int index,
                                    const real64 xi )
  {
    real64 result=0.0;
 
    switch( index )
    {
      case 0:
        result = LagrangeBasis3GL::gradient0( xi );
        break;
      case 1:
        result = LagrangeBasis3GL::gradient1( xi );
        break;
      case 2:
        result = LagrangeBasis3GL::gradient2( xi );
        break;
      case 3:
        result = LagrangeBasis3GL::gradient3( xi );
        break;
      default:
        break;
    }
 
    return result;
  }
 
  GEOS_HOST_DEVICE
  inline
  constexpr static real64 gradient0( const real64 xi )
  {
    return -(5.0/8.0)*(3.0*xi*xi-2.0*xi-(1.0/5.0));
  }
 
  GEOS_HOST_DEVICE
  inline
  constexpr static real64 gradient1( const real64 xi )
  {
    return (5.0*sqrt5/8.0)*(3.0*xi*xi-(2.0/sqrt5)*xi-1.0);
  }
 
  GEOS_HOST_DEVICE
  inline
  constexpr static real64 gradient2( const real64 xi )
  {
    return -(5.0*sqrt5/8.0)*(3.0*xi*xi+(2.0/sqrt5)*xi-1.0);
  }
 
  GEOS_HOST_DEVICE
  inline
  constexpr static real64 gradient3( const real64 xi )
  {
    return (5.0/8.0)*(3.0*xi*xi+2.0*xi-(1.0/5.0));;
  }
 
  GEOS_HOST_DEVICE
  GEOS_FORCE_INLINE
  constexpr static real64 gradientAt( const int q,
                                      const int p )
  {
    switch( q )
    {
      case 0:
        return p == 0 ? -3.0 : -0.80901699437494742410;
      case 1:
        return p == 0 ? 4.0450849718747371205 : 0.0;
      case 2:
        return p == 0 ? -1.5450849718747371205 : 1.1180339887498948482;
      case 3:
        return p == 0 ? 0.5 : -0.30901699437494742410;
      default:
        return 0;
    }
  }
 
  struct TensorProduct2D
  {
    constexpr static localIndex numSupportPoints = 16;
 
    GEOS_HOST_DEVICE
    inline
    constexpr static int linearIndex( const int i,
                                      const int j )
    {
      return i + 4 * j;
    }
 
 
 
    GEOS_HOST_DEVICE
    inline
    constexpr static void multiIndex( int const linearIndex,
                                      int & i0,
                                      int & i1 )
    {
 
      i1 = linearIndex/4;
 
      i0 = linearIndex%4;
 
    }
 
 
    GEOS_HOST_DEVICE
    inline
    static void value( const real64 (& coords)[2],
                       real64 (& N)[numSupportPoints] )
    {
      for( int a=0; a<4; ++a )
      {
        for( int b=0; b<4; ++b )
        {
          const int lindex = LagrangeBasis3GL::TensorProduct2D::linearIndex( a, b );
          N[ lindex ] = LagrangeBasis3GL::value( a, coords[0] ) *
                        LagrangeBasis3GL::value( b, coords[1] );
        }
      }
    }
  };
 
  struct TensorProduct3D
  {
    constexpr static localIndex numSupportPoints = 64;
 
    GEOS_HOST_DEVICE
    inline
    //MODIF6 : Change linearIndex for 64 nodes
    constexpr static int linearIndex( const int i,
                                      const int j,
                                      const int k )
    {
      return i + 4 * j + 16 * k;
    }
 
 
 
    GEOS_HOST_DEVICE
    inline
    //MODIF7 : Change calcul of multiIndex
    constexpr static void multiIndex( int const linearIndex,
                                      int & i0,
                                      int & i1,
                                      int & i2 )
    {
 
      i2 = linearIndex/16;
 
      i1 = (linearIndex%16)/4;
 
      i0 = (linearIndex%16)%4;
 
    }
 
 
    GEOS_HOST_DEVICE
    inline
    static void value( const real64 (& coords)[3],
                       real64 (& N)[numSupportPoints] )
    {
      for( int a=0; a<4; ++a )
      {
        for( int b=0; b<4; ++b )
        {
          for( int c=0; c<4; ++c )
          {
            const int lindex = LagrangeBasis3GL::TensorProduct3D::linearIndex( a, b, c );
            N[ lindex ] = LagrangeBasis3GL::value( a, coords[0] ) *
                          LagrangeBasis3GL::value( b, coords[1] ) *
                          LagrangeBasis3GL::value( c, coords[2] );
          }
        }
      }
    }
  };
};
 
 
}
}
 
 
#endif /* GEOS_FINITEELEMENT_ELEMENTFORMULATIONS_ELEMENTFORMULATIONS_LAGRANGEBASIS3GL_HPP_ */