OilfieldToolsNet/opm-common
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #186 from andlaus/minor_reorg

Browse Source 
Minor reorg
This commit is contained in:
Atgeirr Flø Rasmussen
2016-12-14 21:46:05 +01:00
committed by GitHub
parent 36faf5d156 4ab2b3dc70
commit 16451b2bf9
43 changed files with 400 additions and 451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
opm/material/checkFluidSystem.hpp
View File

@@ -46,7 +46,7 @@
#include <opm/material/fluidstates/ImmiscibleFluidState.hpp>
#include <opm/common/Unused.hpp>
#include <opm/material/common/ClassName.hpp>
#include <dune/common/classname.hh>
#include <iostream>
#include <string>
@@ -276,7 +276,7 @@ void checkFluidState(const BaseFluidState &fs)
template <class Scalar, class FluidSystem, class RhsEval, class LhsEval>
void checkFluidSystem()
{
std::cout << "Testing fluid system '" << Opm::className<FluidSystem>() << "'\n";
std::cout << "Testing fluid system '" << Dune::className<FluidSystem>() << "'\n";
// make sure the fluid system provides the number of phases and
// the number of components

84
opm/material/common/ClassName.hpp
View File

@@ -1,84 +0,0 @@
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
Copyright (C) 2012-2013 by Andreas Lauser
Copyright (C) 2010 by Oliver Sander
Copyright (C) 2011 by Martin Nolte
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 2.
This file is based on works developed by the DUNE project, see
<http://www.dune-project.org>. The following license exception
applies to it:
As a special exception, you may use the DUNE library without
restriction. Specifically, if other files instantiate templates or
use macros or inline functions from one or more of the DUNE source
files, or you compile one or more of the DUNE source files and link
them with other files to produce an executable, this does not by
itself cause the resulting executable to be covered by the GNU
General Public License. This exception does not however invalidate
any other reasons why the executable file might be covered by the
GNU General Public License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*!
* \file
* \brief A free function to provide the demangled class name of a given object or type
* as a string
*/
#ifndef OPM_CLASS_NAME_HPP
#define OPM_CLASS_NAME_HPP
#include <cstdlib>
#include <string>
#include <typeinfo>
#if HAVE_CXA_DEMANGLE
#include <cxxabi.h>
#endif
namespace Opm {
/** \brief Provide the demangled class name of a given object as a string */
template <class T>
std::string className()
{
std::string className = typeid( T ).name();
#if HAVE_CXA_DEMANGLE
int status;
char *demangled = abi::__cxa_demangle( className.c_str(), 0, 0, &status );
if( demangled )
{
className = demangled;
std::free( demangled );
}
#endif // HAVE_CXA_DEMANGLE
return className;
}
#if HAVE_QUAD
// specialize for quad precision floating point values to avoid
// needing a type_info structure
template <>
inline std::string className<__float128>()
{ return "quad"; }
#endif
/** \brief Provide the demangled class name of a given object as a string */
template <class T>
std::string className(const T &)
{
return className<T>();
}
} // namespace Opm
#endif // OPM_CLASS_NAME_HPP

2
opm/material/common/UniformXTabulated2DFunction.hpp
View File

@@ -28,7 +28,7 @@
#ifndef OPM_UNIFORM_X_TABULATED_2D_FUNCTION_HPP
#define OPM_UNIFORM_X_TABULATED_2D_FUNCTION_HPP
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>
#include <opm/common/Unused.hpp>

311
opm/material/common/Valgrind.hpp
View File

@@ -1,311 +0,0 @@
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
Consult the COPYING file in the top-level source directory of this
module for the precise wording of the license and the list of
copyright holders.
*/
/*!
* \file
* \brief Some templates to wrap the valgrind client request macros
*/
#ifndef OPM_VALGRIND_HPP
#define OPM_VALGRIND_HPP
#include <opm/common/Unused.hpp>
#if HAVE_VALGRIND
#include <valgrind/memcheck.h>
#endif
#if HAVE_VALGRIND
#define OPM_VALGRIND_OPTIM_UNUSED OPM_OPTIM_UNUSED
#else
#define OPM_VALGRIND_OPTIM_UNUSED OPM_UNUSED
#endif
namespace Valgrind
{
/*!
* \ingroup Valgrind
* \brief Returns whether the program is running under Valgrind or not.
*/
inline bool IsRunning()
{
#if !defined NDEBUG && HAVE_VALGRIND
return RUNNING_ON_VALGRIND;
#else
return false;
#endif
}
/*!
* \ingroup Valgrind
* \brief Make valgrind complain if any of the memory occupied by an object
* is undefined.
*
* Please note that this does not check whether the destinations of an
* object's pointers or references are defined. Also, for performance
* reasons the compiler might insert "padding bytes" between within
* the objects which leads to false positives.
*
* Example:
*
* \code
* int i;
* Valgrind::CheckDefined(i); // Valgrind complains!
* \endcode
*
* \tparam T The type of the object which ought to be checked
*
* \param value the object which valgrind should check
*
* \return true iff there are no undefined bytes in the memory
* occupied by the object.
*/
template <class T>
inline bool CheckDefined(const T& value OPM_VALGRIND_OPTIM_UNUSED)
{
#if !defined NDEBUG && HAVE_VALGRIND
auto tmp = VALGRIND_CHECK_MEM_IS_DEFINED(&value, sizeof(T));
return tmp == 0;
#else
return true;
#endif
}
/*!
* \ingroup Valgrind
* \brief Make valgrind complain if any of the memory occupied by an object
* is not addressable.
*
* Example:
*
* \code
* int* i = NULL;
* Valgrind::CheckAddressable(*i); // Valgrind complains!
* \endcode
*
* \tparam T The type of the object which ought to be checked
*
* \param value the object which valgrind should check
*
* \return true iff there are no unadressable bytes in the memory
* occupied by the object.
*/
template <class T>
inline bool CheckAddressable(const T& value OPM_VALGRIND_OPTIM_UNUSED)
{
#if !defined NDEBUG && HAVE_VALGRIND
auto tmp = VALGRIND_CHECK_MEM_IS_ADDRESSABLE(&value, sizeof(T));
return tmp == 0;
#else
return true;
#endif
}
/*!
* \ingroup Valgrind
* \brief Make valgrind complain if any of the the memory occupied
* by a C-style array objects is undefined.
*
* Please note that this does not check whether the destinations of an
* object's pointers or references are defined. Also, for performance
* reasons the compiler might insert "padding bytes" between within
* the objects which leads to false positives.
*
* Example:
*
* \code
* int i[2];
* Valgrind::CheckDefined(i, 2); // Valgrind complains!
* \endcode
*
* \tparam T The type of the object which ought to be checked
*
* \param value Pointer to the first object of the array.
* \param size The size of the array in number of objects
*
* \return true iff there are no undefined bytes in the memory
* occupied by the array.
*/
template <class T>
inline bool CheckDefined(const T* value OPM_VALGRIND_OPTIM_UNUSED, int size OPM_VALGRIND_OPTIM_UNUSED)
{
#if !defined NDEBUG && HAVE_VALGRIND
auto tmp = VALGRIND_CHECK_MEM_IS_DEFINED(value, size*sizeof(T));
return tmp == 0;
#else
return true;
#endif
}
/*!
* \ingroup Valgrind
* \brief Make the memory on which an object resides undefined in
* valgrind runs.
*
* Example:
*
* \code
* int i = 0;
* Valgrind::SetUndefined(i);
* Valgrind::CheckDefined(i); // Valgrind complains!
* \endcode
*
* \tparam T The type of the object which ought to be set to undefined
*
* \param value The object which's memory valgrind should be told is undefined
*/
template <class T>
inline void SetUndefined(const T &value OPM_VALGRIND_OPTIM_UNUSED)
{
#if !defined NDEBUG && HAVE_VALGRIND
VALGRIND_MAKE_MEM_UNDEFINED(&value, sizeof(T));
#endif
}
/*!
* \ingroup Valgrind
* \brief Make the memory on which an array of object resides
* undefined in valgrind runs.
*
* Example:
*
* \code
* int i[3] = {0, 1, 3};
* Valgrind::SetUndefined(&i[1], 2);
* Valgrind::CheckDefined(i, 3); // Valgrind complains!
* \endcode
*
* \tparam T The type of the object which ought to be set to undefined
*
* \param value Pointer to the first object of the array.
* \param size The size of the array in number of objects
*/
template <class T>
inline void SetUndefined(const T* value OPM_VALGRIND_OPTIM_UNUSED, int size OPM_VALGRIND_OPTIM_UNUSED)
{
#if !defined NDEBUG && HAVE_VALGRIND
VALGRIND_MAKE_MEM_UNDEFINED(value, size*sizeof(T));
#endif
}
/*!
* \ingroup Valgrind
* \brief Make the memory on which an object resides defined.
*
* Example:
*
* \code
* int i;
* Valgrind::SetDefined(i);
* Valgrind::CheckDefined(i); // Valgrind does not complain!
* \endcode
*
* \tparam T The type of the object which valgrind should consider as defined
*
* \param value The object which's memory valgrind should consider as defined
*/
template <class T>
inline void SetDefined(const T& value OPM_VALGRIND_OPTIM_UNUSED)
{
#if !defined NDEBUG && HAVE_VALGRIND
VALGRIND_MAKE_MEM_DEFINED(&value, sizeof(T));
#endif
}
/*!
* \ingroup Valgrind
* \brief Make the memory on which a C-style array of objects resides
* defined.
*
* Example:
*
* \code
* int i[3];
* Valgrind::SetDefined(i, 3);
* Valgrind::CheckDefined(i, 3); // Valgrind does not complain!
* \endcode
*
* \tparam T The type of the object which valgrind should consider as defined
*
* \param value Pointer to the first object of the array.
* \param n The size of the array in number of objects
*/
template <class T>
inline void SetDefined(const T *value OPM_VALGRIND_OPTIM_UNUSED, int n OPM_VALGRIND_OPTIM_UNUSED)
{
#if !defined NDEBUG && HAVE_VALGRIND
VALGRIND_MAKE_MEM_DEFINED(value, n*sizeof(T));
#endif
}
/*!
* \ingroup Valgrind
* \brief Make valgrind complain if an object's memory is accessed.
*
* Example:
*
* \code
* int i = 1;
* Valgrind::SetNoAccess(i);
* int j = i; // Valgrind complains!
* \endcode
*
* \tparam T The type of the object which valgrind should complain if accessed
*
* \param value The object which's memory valgrind should complain if accessed
*/
template <class T>
inline void SetNoAccess(const T &value OPM_VALGRIND_OPTIM_UNUSED)
{
#if !defined NDEBUG && HAVE_VALGRIND
VALGRIND_MAKE_MEM_NOACCESS(&value, sizeof(T));
#endif
}
/*!
* \ingroup Valgrind
* \brief Make valgrind complain if the memory of a C-style array of
* objects is accessed.
*
* Example:
*
* \code
* int i[3] = {0, 1, 2};
* Valgrind::SetNoAccess(i, 2);
* int j = i[1]; // Valgrind complains!
* \endcode
*
* \param value Pointer to the first object of the array.
* \param size The size of the array in number of objects
*/
template <class T>
inline void SetNoAccess(const T *value OPM_VALGRIND_OPTIM_UNUSED, int size OPM_VALGRIND_OPTIM_UNUSED)
{
#if !defined NDEBUG && HAVE_VALGRIND
VALGRIND_MAKE_MEM_NOACCESS(value, size*sizeof(T));
#endif
}
} // namespace Valgrind
#endif

344
opm/material/common/quad.hpp Normal file
View File

@@ -0,0 +1,344 @@
// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
Consult the COPYING file in the top-level source directory of this
module for the precise wording of the license and the list of
copyright holders.
*/
/*!
* \file
*
* \brief This file provides the infrastructure to use quad-precision
* floating point values in the numerical models.
*/
#if HAVE_DUNE_COMMON
#ifdef DUNE_CLASSNAME_HH
#error "Due to some trickery required for the linker, this file must be included _before_ Dune's classname.hh!"
#endif
#include <dune/common/classname.hh>
#endif // HAVE_DUNE_COMMON
#if !defined OPM_COMMON_QUAD_HPP && HAVE_QUAD
#define OPM_COMMON_QUAD_HPP
#include <cmath>
#include <string>
#include <exception>
#include <limits>
#include <iostream>
#include <type_traits>
extern "C" {
#include <quadmath.h>
}
typedef __float128 quad;
namespace std {
// provide the numeric limits for the quad precision type
template <>
class numeric_limits<quad>
{
public:
static const bool is_specialized = true;
static quad min() throw()
{ return FLT128_MIN; }
static quad max() throw()
{ return FLT128_MAX; }
// number of bits in mantissa
static const int digits = FLT128_MANT_DIG;
// number of decimal digits
static const int digits10 = FLT128_DIG;
static const bool is_signed = true;
static const bool is_integer = false;
static const bool is_exact = false;
static const int radix = 0;
static quad epsilon() throw()
{ return FLT128_EPSILON; }
static quad round_error() throw()
{ return 0.5; }
static const int min_exponent = FLT128_MIN_EXP;
static const int min_exponent10 = FLT128_MIN_10_EXP;
static const int max_exponent = FLT128_MAX_EXP;
static const int max_exponent10 = FLT128_MAX_10_EXP;
static const bool has_infinity = true;
static const bool has_quiet_NaN = true;
static const bool has_signaling_NaN = true;
static const float_denorm_style has_denorm = denorm_present;
static const bool has_denorm_loss = false;
static quad infinity() throw()
{ return __builtin_huge_valq(); }
static quad quiet_NaN() throw()
{ return __builtin_nan(""); }
static quad signaling_NaN() throw()
{ return __builtin_nans(""); }
static quad denorm_min() throw()
{ return FLT128_DENORM_MIN; }
static const bool is_iec559 = true;
static const bool is_bounded = true;
static const bool is_modulo = false;
static const bool traps = std::numeric_limits<double>::traps;
static const bool tinyness_before = std::numeric_limits<double>::tinyness_before;
static const float_round_style round_style = round_to_nearest;
};
// provide some type traits for the quadruple precision type
template <>
struct is_floating_point<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_arithmetic<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_fundamental<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_scalar<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_pod<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_signed<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_standard_layout<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_trivial<quad>
: public integral_constant<bool, true>
{};
/*
template <>
struct is_trivially_copyable<quad>
: public integral_constant<bool, true>
{};
*/
template <class OtherType>
struct is_assignable<quad, OtherType>
: public integral_constant<bool, is_arithmetic<OtherType>::value>
{};
template <class OtherType>
struct is_nothrow_assignable<quad, OtherType>
: public is_assignable<quad, OtherType>
{};
/*
template <class OtherType>
struct is_trivially_assignable<quad, OtherType>
: public integral_constant<bool, is_arithmetic<OtherType>::value>
{};
*/
template <>
struct is_copy_assignable<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_nothrow_copy_assignable<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_move_assignable<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_nothrow_move_assignable<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_constructible<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_nothrow_constructible<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_default_constructible<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_nothrow_default_constructible<quad>
: public integral_constant<bool, true>
{};
/*
template <>
struct is_trivially_default_constructible<quad>
: public integral_constant<bool, true>
{};
*/
template <>
struct is_copy_constructible<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_move_constructible<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_nothrow_move_constructible<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_destructible<quad>
: public integral_constant<bool, true>
{};
template <>
struct is_nothrow_destructible<quad>
: public integral_constant<bool, true>
{};
template <class OtherType>
struct is_convertible<quad, OtherType>
: public is_arithmetic<OtherType>
{ };
inline std::ostream& operator<<(std::ostream& os, const quad& val)
{
if (os.precision() > std::numeric_limits<double>::digits10)
throw std::runtime_error("The precision requested for output cannot "
"be represented by a double precision floating "
"point object");
return os << static_cast<double>(val);
}
inline std::istream& operator>>(std::istream& is, quad& val)
{
double tmp;
std::istream& ret = (is >> tmp);
val = tmp;
return ret;
}
inline quad abs(quad val)
{ return (val < 0) ? -val : val; }
inline quad floor(quad val)
{ return floorq(val); }
inline quad ceil(quad val)
{ return ceilq(val); }
inline quad max(quad a, quad b)
{ return (a > b) ? a : b; }
inline quad min(quad a, quad b)
{ return (a < b) ? a : b; }
inline quad sqrt(quad val)
{ return sqrtq(val); }
template <class ExpType>
inline quad pow(quad base, ExpType exp)
{ return powq(base, static_cast<quad>(exp)); }
template <class BaseType>
inline quad pow(BaseType base, quad exp)
{ return powq(static_cast<quad>(base), exp); }
inline quad pow(quad base, quad exp)
{ return powq(base, exp); }
inline quad exp(quad val)
{ return expq(val); }
inline quad log(quad val)
{ return logq(val); }
inline quad sin(quad val)
{ return sinq(val); }
inline quad cos(quad val)
{ return cosq(val); }
inline quad tan(quad val)
{ return tanq(val); }
inline quad atan(quad val)
{ return atanq(val); }
inline quad atan2(quad a, quad b)
{ return atan2q(a, b); }
inline quad round(quad val)
{ return roundq(val); }
inline bool isfinite(quad val)
{ return finiteq(val); }
inline bool isnan(quad val)
{ return isnanq(val); }
inline bool isinf(quad val)
{ return isinfq(val); }
} // namespace std
#if HAVE_DUNE_COMMON
// specialize Dune::className for __float128 since it former does not work properly with
// __float128 (this is mainly the fault of GCC/libstdc++)
namespace Dune {
template <>
inline std::string className<__float128>()
{ return "quad"; }
} // namespace Dune
#endif // HAVE_DUNE_COMMON
#endif // OPM_COMMON_QUAD_HPP

2
opm/material/components/H2O.hpp
View File

@@ -33,7 +33,7 @@
#include <opm/material/IdealGas.hpp>
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include "Component.hpp"

2
opm/material/constraintsolvers/CompositionFromFugacities.hpp
View File

@@ -40,7 +40,7 @@
#include <opm/common/ErrorMacros.hpp>
#include <opm/common/Exceptions.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <limits>

2
opm/material/constraintsolvers/ComputeFromReferencePhase.hpp
View File

@@ -31,7 +31,7 @@
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <dune/common/fvector.hh>

2
opm/material/constraintsolvers/ImmiscibleFlash.hpp
View File

@@ -31,7 +31,7 @@
#include <opm/material/densead/Evaluation.hpp>
#include <opm/material/densead/Math.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/common/ErrorMacros.hpp>
#include <opm/common/Exceptions.hpp>

2
opm/material/constraintsolvers/MiscibleMultiPhaseComposition.hpp
View File

@@ -40,7 +40,7 @@
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
namespace Opm {

2
opm/material/constraintsolvers/NcpFlash.hpp
View File

@@ -33,7 +33,7 @@
#include <opm/material/densead/Evaluation.hpp>
#include <opm/material/densead/Math.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/common/ErrorMacros.hpp>
#include <opm/common/Exceptions.hpp>

2
opm/material/densead/Evaluation.hpp
View File

@@ -31,7 +31,7 @@
#include "Math.hpp"
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <dune/common/version.hh>

2
opm/material/eos/PengRobinsonParams.hpp
View File

@@ -27,7 +27,7 @@
#ifndef OPM_PENG_ROBINSON_PARAMS_HPP
#define OPM_PENG_ROBINSON_PARAMS_HPP
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
namespace Opm
{

2
opm/material/fluidmatrixinteractions/BrooksCoreyParams.hpp
View File

@@ -27,7 +27,7 @@
#ifndef OPM_BROOKS_COREY_PARAMS_HPP
#define OPM_BROOKS_COREY_PARAMS_HPP
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <cassert>

2
opm/material/fluidmatrixinteractions/EclDefaultMaterial.hpp
View File

@@ -29,7 +29,7 @@
#include "EclDefaultMaterialParams.hpp"
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/common/Exceptions.hpp>

2
opm/material/fluidmatrixinteractions/EclMultiplexerMaterial.hpp
View File

@@ -33,7 +33,7 @@
#include "EclStone2Material.hpp"
#include "EclTwoPhaseMaterial.hpp"
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>

2
opm/material/fluidmatrixinteractions/EclStone1Material.hpp
View File

@@ -29,7 +29,7 @@
#include "EclStone1MaterialParams.hpp"
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/common/Exceptions.hpp>

2
opm/material/fluidmatrixinteractions/EclStone2Material.hpp
View File

@@ -29,7 +29,7 @@
#include "EclStone2MaterialParams.hpp"
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/common/Exceptions.hpp>

2
opm/material/fluidmatrixinteractions/EclTwoPhaseMaterial.hpp
View File

@@ -29,7 +29,7 @@
#include "EclTwoPhaseMaterialParams.hpp"
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/common/Exceptions.hpp>

2
opm/material/fluidmatrixinteractions/LinearMaterial.hpp
View File

@@ -30,7 +30,7 @@
#include "LinearMaterialParams.hpp"
#include <opm/material/common/MathToolbox.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>

2
opm/material/fluidmatrixinteractions/ThreePhaseParkerVanGenuchtenParams.hpp
View File

@@ -31,7 +31,7 @@
#include <dune/common/fvector.hh>
#include <opm/common/utility/platform_dependent/reenable_warnings.h>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/common/ErrorMacros.hpp>
#include <opm/common/Exceptions.hpp>

2
opm/material/fluidstates/CompositionalFluidState.hpp
View File

@@ -32,7 +32,7 @@
#include "ModularFluidState.hpp"
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <algorithm>
namespace Opm {

2
opm/material/fluidstates/FluidStateCompositionModules.hpp
View File

@@ -28,7 +28,7 @@
#ifndef OPM_FLUID_STATE_COMPOSITION_MODULES_HPP
#define OPM_FLUID_STATE_COMPOSITION_MODULES_HPP
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/common/ErrorMacros.hpp>

2
opm/material/fluidstates/FluidStateDensityModules.hpp
View File

@@ -32,7 +32,7 @@
#include <opm/common/Exceptions.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <algorithm>

2
opm/material/fluidstates/FluidStateEnthalpyModules.hpp
View File

@@ -32,7 +32,7 @@
#include <opm/common/Exceptions.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <algorithm>

2
opm/material/fluidstates/FluidStateFugacityModules.hpp
View File

@@ -28,7 +28,7 @@
#ifndef OPM_FLUID_STATE_FUGACITY_MODULES_HPP
#define OPM_FLUID_STATE_FUGACITY_MODULES_HPP
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/common/ErrorMacros.hpp>
#include <opm/common/Exceptions.hpp>

2
opm/material/fluidstates/FluidStatePressureModules.hpp
View File

@@ -29,7 +29,7 @@
#define OPM_FLUID_STATE_PRESSURE_MODULES_HPP
#include <opm/material/common/MathToolbox.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>

2
opm/material/fluidstates/FluidStateSaturationModules.hpp
View File

@@ -32,7 +32,7 @@
#include <opm/common/Exceptions.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <algorithm>

2
opm/material/fluidstates/FluidStateTemperatureModules.hpp
View File

@@ -28,7 +28,7 @@
#ifndef OPM_FLUID_STATE_TEMPERATURE_MODULES_HPP
#define OPM_FLUID_STATE_TEMPERATURE_MODULES_HPP
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/common/ErrorMacros.hpp>

2
opm/material/fluidstates/FluidStateViscosityModules.hpp
View File

@@ -32,7 +32,7 @@
#include <opm/common/Exceptions.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <algorithm>

2
opm/material/fluidstates/ImmiscibleFluidState.hpp
View File

@@ -32,7 +32,7 @@
#include "ModularFluidState.hpp"
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <algorithm>

2
opm/material/fluidstates/ModularFluidState.hpp
View File

@@ -36,7 +36,7 @@
#include "FluidStateViscosityModules.hpp"
#include "FluidStateEnthalpyModules.hpp"
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <algorithm>
namespace Opm {

2
opm/material/fluidstates/NonEquilibriumFluidState.hpp
View File

@@ -32,7 +32,7 @@
#include "ModularFluidState.hpp"
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <algorithm>
namespace Opm {

2
opm/material/fluidstates/PressureOverlayFluidState.hpp
View File

@@ -27,7 +27,7 @@
#ifndef OPM_PRESSURE_OVERLAY_FLUID_STATE_HPP
#define OPM_PRESSURE_OVERLAY_FLUID_STATE_HPP
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <array>
#include <utility>

2
opm/material/fluidstates/SaturationOverlayFluidState.hpp
View File

@@ -27,7 +27,7 @@
#ifndef OPM_SATURATION_OVERLAY_FLUID_STATE_HPP
#define OPM_SATURATION_OVERLAY_FLUID_STATE_HPP
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <array>
#include <utility>

2
opm/material/fluidstates/TemperatureOverlayFluidState.hpp
View File

@@ -27,7 +27,7 @@
#ifndef OPM_TEMPERATURE_OVERLAY_FLUID_STATE_HPP
#define OPM_TEMPERATURE_OVERLAY_FLUID_STATE_HPP
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <utility>

30
opm/material/fluidsystems/BaseFluidSystem.hpp
View File

@@ -31,7 +31,7 @@
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>
#include <opm/material/common/ClassName.hpp>
#include <dune/common/classname.hh>
namespace Opm {
@@ -74,7 +74,7 @@ public:
static char *phaseName(unsigned /*phaseIdx*/)
{
OPM_THROW(std::runtime_error,
"Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a phaseName() method!");
"Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a phaseName() method!");
}
/*!
@@ -85,7 +85,7 @@ public:
static bool isLiquid(unsigned /*phaseIdx*/)
{
OPM_THROW(std::runtime_error,
"Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a isLiquid() method!");
"Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a isLiquid() method!");
}
/*!
@@ -105,7 +105,7 @@ public:
static bool isIdealMixture(unsigned /*phaseIdx*/)
{
OPM_THROW(std::runtime_error,
"Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a isIdealMixture() method!");
"Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a isIdealMixture() method!");
}
/*!
@@ -120,7 +120,7 @@ public:
static bool isCompressible(unsigned /*phaseIdx*/)
{
OPM_THROW(std::runtime_error,
"Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a isCompressible() method!");
"Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a isCompressible() method!");
}
/*!
@@ -132,7 +132,7 @@ public:
static bool isIdealGas(unsigned /*phaseIdx*/)
{
OPM_THROW(std::runtime_error,
"Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a isIdealGas() method!");
"Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a isIdealGas() method!");
}
/*!
@@ -143,7 +143,7 @@ public:
static const char *componentName(unsigned /*compIdx*/)
{
OPM_THROW(std::runtime_error,
"Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a componentName() method!");
"Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a componentName() method!");
}
/*!
@@ -154,7 +154,7 @@ public:
static Scalar molarMass(unsigned /*compIdx*/)
{
OPM_THROW(std::runtime_error,
"Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a molarMass() method!");
"Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a molarMass() method!");
}
/*!
@@ -175,7 +175,7 @@ public:
unsigned /*phaseIdx*/)
{
OPM_THROW(std::runtime_error,
"Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a density() method!");
"Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a density() method!");
}
/*!
@@ -198,7 +198,7 @@ public:
unsigned /*phaseIdx*/,
unsigned /*compIdx*/)
{
OPM_THROW(std::runtime_error, "Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a fugacityCoefficient() method!");
OPM_THROW(std::runtime_error, "Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a fugacityCoefficient() method!");
}
/*!
@@ -212,7 +212,7 @@ public:
ParamCache& /*paramCache*/,
unsigned /*phaseIdx*/)
{
OPM_THROW(std::runtime_error, "Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a viscosity() method!");
OPM_THROW(std::runtime_error, "Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a viscosity() method!");
}
/*!
@@ -238,7 +238,7 @@ public:
unsigned /*phaseIdx*/,
unsigned /*compIdx*/)
{
OPM_THROW(std::runtime_error, "Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a diffusionCoefficient() method!");
OPM_THROW(std::runtime_error, "Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a diffusionCoefficient() method!");
}
/*!
@@ -253,7 +253,7 @@ public:
ParamCache& /*paramCache*/,
unsigned /*phaseIdx*/)
{
OPM_THROW(std::runtime_error, "Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide an enthalpy() method!");
OPM_THROW(std::runtime_error, "Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide an enthalpy() method!");
}
/*!
@@ -267,7 +267,7 @@ public:
ParamCache& /*paramCache*/,
unsigned /*phaseIdx*/)
{
OPM_THROW(std::runtime_error, "Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a thermalConductivity() method!");
OPM_THROW(std::runtime_error, "Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a thermalConductivity() method!");
}
/*!
@@ -281,7 +281,7 @@ public:
ParamCache& /*paramCache*/,
unsigned /*phaseIdx*/)
{
OPM_THROW(std::runtime_error, "Not implemented: The fluid system '" << Opm::className<Implementation>() << "' does not provide a heatCapacity() method!");
OPM_THROW(std::runtime_error, "Not implemented: The fluid system '" << Dune::className<Implementation>() << "' does not provide a heatCapacity() method!");
}
};

2
opm/material/fluidsystems/BlackOilFluidSystem.hpp
View File

@@ -35,7 +35,7 @@
#include <opm/material/Constants.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/material/common/HasMemberGeneratorMacros.hpp>
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>

2
opm/material/fluidsystems/H2OAirFluidSystem.hpp
View File

@@ -35,7 +35,7 @@
#include <opm/material/components/Air.hpp>
#include <opm/material/components/H2O.hpp>
#include <opm/material/components/TabulatedComponent.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>

2
opm/material/fluidsystems/H2ON2FluidSystem.hpp
View File

@@ -36,7 +36,7 @@
#include <opm/material/components/SimpleH2O.hpp>
#include <opm/material/components/TabulatedComponent.hpp>
#include <opm/material/binarycoefficients/H2O_N2.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>

2
opm/material/fluidsystems/H2ON2LiquidPhaseFluidSystem.hpp
View File

@@ -36,7 +36,7 @@
#include <opm/material/components/SimpleH2O.hpp>
#include <opm/material/components/TabulatedComponent.hpp>
#include <opm/material/binarycoefficients/H2O_N2.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>

2
opm/material/heatconduction/Somerton.hpp
View File

@@ -31,7 +31,7 @@
#include <opm/material/common/Spline.hpp>
#include <opm/material/common/Valgrind.hpp>
#include <opm/common/Valgrind.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <algorithm>

4
tests/checkComponent.hpp
View File

@@ -28,7 +28,7 @@
#define OPM_CHECK_COMPONENT_HPP
#include <opm/common/Unused.hpp>
#include <opm/material/common/ClassName.hpp>
#include <dune/common/classname.hh>
#include <iostream>
#include <string>
@@ -42,7 +42,7 @@
template <class Component, class Evaluation>
void checkComponent()
{
std::cout << "Testing component '" << Opm::className<Component>() << "'\n";
std::cout << "Testing component '" << Dune::className<Component>() << "'\n";
// make sure the necessary typedefs exist
typedef typename Component::Scalar Scalar;