MimeticInnerProductDispatch.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_FINITEVOLUME_MIMETICINNERPRODUCTS_MIMETICINNERPRODUCTDISPATCH_HPP_
#define GEOS_FINITEVOLUME_MIMETICINNERPRODUCTS_MIMETICINNERPRODUCTDISPATCH_HPP_
 
#include "finiteVolume/mimeticInnerProducts/MimeticInnerProductBase.hpp"
#include "finiteVolume/mimeticInnerProducts/QuasiTPFAInnerProduct.hpp"
#include "finiteVolume/mimeticInnerProducts/QuasiRTInnerProduct.hpp"
#include "finiteVolume/mimeticInnerProducts/TPFAInnerProduct.hpp"
#include "finiteVolume/mimeticInnerProducts/SimpleInnerProduct.hpp"
#include "finiteVolume/mimeticInnerProducts/BdVLMInnerProduct.hpp"
#include "finiteVolume/mimeticInnerProducts/RTInnerProduct.hpp"
#include "LvArray/src/system.hpp"
 
namespace geos
{
namespace mimeticInnerProduct
{
 
struct MimeticInnerProductTypeStrings
{
  static constexpr auto TPFA      = "TPFA";
  static constexpr auto QuasiTPFA = "quasiTPFA";
  static constexpr auto QuasiRT   = "quasiRT";
  static constexpr auto Simple    = "simple";
  static constexpr auto BdVLM     = "beiraoDaVeigaLipnikovManzini";
  static constexpr auto RT        = "RT";
};
 
template< typename LAMBDA >
void
mimeticInnerProductDispatch( MimeticInnerProductBase const & input,
                             LAMBDA && lambda )
{
  if( auto const * const ptr1 = dynamic_cast< TPFAInnerProduct const * >(&input) )
  {
    lambda( *ptr1 );
  }
  else if( auto const * const ptr2 = dynamic_cast< QuasiTPFAInnerProduct const * >(&input) )
  {
    lambda( *ptr2 );
  }
  else if( auto const * const ptr3 = dynamic_cast< QuasiRTInnerProduct const * >(&input) )
  {
    lambda( *ptr3 );
  }
  else if( auto const * const ptr4 = dynamic_cast< SimpleInnerProduct const * >(&input) )
  {
    lambda( *ptr4 );
  }
  else if( auto const * const ptr5 = dynamic_cast< BdVLMInnerProduct const * >(&input) )
  {
    lambda( *ptr5 );
  }
  else if( auto const * const ptr6 = dynamic_cast< RTInnerProduct const * >(&input) )
  {
    lambda( *ptr6 );
  }
  else
  {
    GEOS_ERROR( GEOS_FMT( "mimeticInnerProductDispatch() is not implemented for input of {}",
                          LvArray::system::demangleType( input ) ) );
  }
}
 
template< typename LAMBDA >
void
mimeticInnerProductDispatch( MimeticInnerProductBase & input,
                             LAMBDA && lambda )
{
  if( auto * const ptr1 = dynamic_cast< TPFAInnerProduct * >(&input) )
  {
    lambda( *ptr1 );
  }
  else if( auto * const ptr2 = dynamic_cast< QuasiTPFAInnerProduct * >(&input) )
  {
    lambda( *ptr2 );
  }
  else if( auto * const ptr3 = dynamic_cast< QuasiRTInnerProduct * >(&input) )
  {
    lambda( *ptr3 );
  }
  else if( auto * const ptr4 = dynamic_cast< SimpleInnerProduct * >(&input) )
  {
    lambda( *ptr4 );
  }
  else if( auto * const ptr5 = dynamic_cast< BdVLMInnerProduct * >(&input) )
  {
    lambda( *ptr5 );
  }
  else if( auto * const ptr6 = dynamic_cast< RTInnerProduct * >(&input) )
  {
    lambda( *ptr6 );
  }
  else
  {
    GEOS_ERROR( GEOS_FMT( "mimeticInnerProductDispatch() is not implemented for input of {}",
                          LvArray::system::demangleType( input ) ) );
  }
}
 
template< typename LAMBDA >
void
mimeticInnerProductReducedDispatch( MimeticInnerProductBase const & input,
                                    LAMBDA && lambda )
{
  if( auto const * const ptr1 = dynamic_cast< TPFAInnerProduct const * >(&input) )
  {
    lambda( *ptr1 );
  }
  else if( auto const * const ptr2 = dynamic_cast< QuasiTPFAInnerProduct const * >(&input) )
  {
    lambda( *ptr2 );
  }
  else if( auto const * const ptr3 = dynamic_cast< BdVLMInnerProduct const * >(&input) )
  {
    lambda( *ptr3 );
  }
  else
  {
    GEOS_ERROR( GEOS_FMT( "mimeticInnerProductReducedDispatch() is not implemented for input of {}",
                          LvArray::system::demangleType( input ) ) );
  }
}
 
template< typename LAMBDA >
void
mimeticInnerProductReducedDispatch( MimeticInnerProductBase & input,
                                    LAMBDA && lambda )
{
  if( auto * const ptr1 = dynamic_cast< TPFAInnerProduct * >(&input) )
  {
    lambda( *ptr1 );
  }
  else if( auto * const ptr2 = dynamic_cast< QuasiTPFAInnerProduct * >(&input) )
  {
    lambda( *ptr2 );
  }
  else if( auto * const ptr3 = dynamic_cast< BdVLMInnerProduct * >(&input) )
  {
    lambda( *ptr3 );
  }
  else
  {
    GEOS_ERROR( GEOS_FMT( "mimeticInnerProductReducedDispatch() is not supported for input of {}",
                          LvArray::system::demangleType( input ) ) );
  }
}
 
 
} // end namespace mimeticInnerProduct
 
} // end namespace geos
 
#endif /* GEOS_FINITEVOLUME_MIMETICINNERPRODUCTS_MIMETICINNERPRODUCTDISPATCH_HPP_ */