CompositionalMultiphaseUtilities.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 TotalEnergies
 * 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_PHYSICSSOLVERS_FLUIDFLOW_COMPOSITIONALMULTIPHASEUTILITIES_H_
#define GEOS_PHYSICSSOLVERS_FLUIDFLOW_COMPOSITIONALMULTIPHASEUTILITIES_H_
 
#include "common/DataTypes.hpp"
 
namespace geos
{
 
enum class GravityDensityScheme : integer
{
  ArithmeticAverage, 
  PhasePresence      
};
 
ENUM_STRINGS( GravityDensityScheme,
              "ArithmeticAverage",
              "PhasePresence" );
 
namespace compositionalMultiphaseUtilities
{
 
enum class ScalingType : integer
{
  Global,         
  Local            
};
 
ENUM_STRINGS( ScalingType,
              "Global",
              "Local" );
 
template< typename VEC >
GEOS_HOST_DEVICE
void shiftBlockElementsAheadByOneAndReplaceFirstElementWithSum( integer const numRowsToShift,
                                                                integer const numRowsInBlock,
                                                                integer const numBlocks,
                                                                VEC && v )
{
  for( integer i = 0; i < numBlocks; ++i )
  {
    integer const ind = i * numRowsInBlock + numRowsToShift - 1;
    real64 tmp = v[ind];
    for( int j = ind - 1; j >= i * numRowsInBlock; --j )
    {
      v[j+1] = v[j];
      tmp += v[j];
    }
    v[i*numRowsInBlock] = tmp;
  }
}
 
template< typename VEC >
GEOS_HOST_DEVICE
void shiftElementsAheadByOneAndReplaceFirstElementWithSum( integer const numRows,
                                                           VEC && v )
{
  shiftBlockElementsAheadByOneAndReplaceFirstElementWithSum( numRows, numRows, 1, v );
}
 
template< typename MATRIX, typename VEC >
GEOS_HOST_DEVICE
void shiftBlockRowsAheadByOneAndReplaceFirstRowWithColumnSum( integer const numRowsToShift,
                                                              integer const numRowsInBlock,
                                                              integer const numColsInBlock,
                                                              integer const numBlocks,
                                                              MATRIX && mat,
                                                              VEC && work )
{
  for( integer k = 0; k < numBlocks; ++k )
  {
    integer const ind = k * numRowsInBlock + numRowsToShift - 1;
    for( integer j = 0; j < numColsInBlock; ++j )
    {
      work[j] = mat[ind][j];
    }
    for( integer i = ind - 1; i >= k * numRowsInBlock; --i )
    {
      for( integer j = 0; j < numColsInBlock; ++j )
      {
        mat[i+1][j] = mat[i][j];
        work[j] += mat[i][j];
      }
    }
    for( integer j = 0; j < numColsInBlock; ++j )
    {
      mat[k*numRowsInBlock][j] = work[j];
    }
  }
}
 
template< typename MATRIX, typename VEC >
GEOS_HOST_DEVICE
void shiftRowsAheadByOneAndReplaceFirstRowWithColumnSum( integer const numRowsInBlock,
                                                         integer const numColsInBlock,
                                                         MATRIX && mat,
                                                         VEC && work )
{
  shiftBlockRowsAheadByOneAndReplaceFirstRowWithColumnSum( numRowsInBlock, numRowsInBlock, numColsInBlock, 1, mat, work );
}
 
} // namespace compositionalMultiphaseUtilities
 
} // namespace geos
 
#endif //GEOS_PHYSICSSOLVERS_FLUIDFLOW_COMPOSITIONALMULTIPHASEUTILITIES_HPP_